polymorphism and virtual functions. topics polymorphism virtual functions pure virtual functions...

Polymorphism and Virtual Functions

TopicsPolymorphismVirtual FunctionsPure Virtual FunctionsAbstract Base ClassesVirtual DestructorsV-TablesRun Time Type Identification (RTTI)Dynamic Cast

Objectives

At the completion of this module, students should be able to:

Design classes that enable polymorphism* Properly use inheritance* Include virtual functionsCorrectly use polymorphism in a program* Store pointers to dynamically created objects in arrays of base class pointersExplain how V-Tables are used to make polymorphism workExplain why a virtual destructor is neededSafely access base class functions in a program, using rtti anddynamic casts.

Introduction : The Orchestra

Polymorphic Variables

Consider the statement:

Instrument* instr = new Brass(“bugle”, “toot”);

The declared or “static” type of instr is Instrument*

However, instr can potentially hold a pointer to avariable of a different type. In particular, it can hold the address of an object of any class derived from Instrument. The type of object actually pointed to is instr’s “dynamic” type.

From Inheritance . . .

Recall that you can store the address of a derived classobject in a base class pointer.

What happens if you use the base class pointer toinvoke a function that exists in the base class, but hasbeen over-ridden in the derived class?

Virtual Functionsclass Instrument{ public: virtual void play ( ) const; void display ( ); protected: string name;};

the keyword virtual says that wecan over-ride this function in aderived class. But, when we use a baseclass pointer to point to the object,and invoke the virtual function, thesystem will automatically find andexecute the function defined in the derived class, not the base class!

Moreover, if we have many different derivedclasses, the system will find the correctfunction for the object that the pointer points to.

This is called late binding,or dynamic binding.

bugle

toot

Brass joe(“bugle”, “toot”);String mary(“harp”, “strummm”);Percussion bill(“kettle”, “whomp”);

Instrument* instr;instr = &joe;instr->play( );

instr = &mary;instr->play( );

instr = &bill;instr->play( );

harp

strumm

kettle

whomp

instr

joe

mary

bill

Foo

Bar Widget

Foo

Bar Widget

# myData : string

printMyData( ) : void

- barData1 : string

+ printMyData( ) : void

- widgetData1 : string


Foo

Bar Widget

# myData : string


- barData1 : string




void printMydata( ){ cout << “I am a Foo object, my data is “ << myData << endl;}

Foo

Bar Widget

# myData : string


- barData : string




void printMydata( ){ cout << “I am a Bar object, my data is “ << myData << barData << endl;}

myData is visibleto the child class

Foo

Bar Widget

# myData : string


- barData : string


- widgetData : string


void printMydata( ){ cout << “I am a Widget object, my data is “ << myData << widgetData << endl;}

What will the following do?

Foo foo (“C++ Rocks”);Bar bar (“Prof deBry”, “Rocks?”);Widget widget(“I Love”, “C++”);

foo.printMyData( );bar.printMyData( );widget.printMyData( );

But …What will the following do?

Foo *fooPtrs[3];fooPtrs[0] = &foo;fooPtrs[1] = &bar;fooPtrs[2] = &widget;

fooPtrs[0]->printMyData( );fooPtrs[1]->printMyData( );fooPtrs[2]->printMyData( );

What will the following do?

Make printMyData( ) virtual

Foo *fooPtrs[3];fooPtrs[0] = &foo;fooPtrs[1] = &bar;fooPtrs[2] = &widget;

fooPtrs[0]->printMyData( );fooPtrs[1]->printMyData( );fooPtrs[2]->.printMyData( );

Try it …

Rules for Polymorphism

In the base class, the keyword virtual must precedeany function that you want to call using polymorphism.

In the derived class the signature must exactly matchthe signature of the function being over-ridden. If thesignature is different, the compiler considers it to bea different function, not an over-riding function.

The actual implementation of the function in thederived class will be different than that in the baseclass.

The function is invoked through a base class pointerthat contains the address of the derived class object.

Pure Virtual Functions

In the previous example, we provided an implementationfor the printMyData( ) function in the base class. Often times you will not need to provide an implementation for a virtual function in the base class.

You can do this by making the function a pure virtualfunction. Pure virtual functions have no implementation.

class Foo{ public: virtual void printMyData( ) const = 0; protected: string myData;}

the =0 notation signals that thisis a pure virtual function. Thereshould be no implementation ofthis function written.

Abstract Classes

If a class contains at least one pure virtual functionthen it is impossible to create an object of that class.

Why?

Such classes are called abstract classes.

Virtual Destructors

If an object is destroyed by applying the delete operatorto a base class pointer, only the base class destructor iscalled. This can leave derived class data members on theheap with no way to delete them.

This problem is solved by making the destructor in thebase class virtual. Polymorphism then causes the derivedclass destructor to be called first. It will automatically callthe base class destructor, insuring that all data isproperly removed from the heap.

V-TablesWhen the compiler encounters a class definitionthat contains virtual functions, it builds a v-tablefor that class. The v-table contains the addressesof all of the virtual functions for the class.

class Instrument{ public: int getValue( ); virtual void play ( ); virtual void display ( ); virtual ~Instrument ( );};

Instrument’s v-table

play ( )

~Instrument( )

Instrument::play

Instrument::~Instrument

display( ) Instrument::display

When the compiler encounters a derived class definitionthat inherits publicly from this base class, it copies thev-table from the base class for the derived class.

class Brass : public Instrument{ public: void play ( ); void display ( int ); ~Brass ( );};

Brass’s v-table

play ( )

~Instrument( )

Instrument::play



Now, for any function in the derived class that over-ridesa virtual function in the base class, the compiler sets theaddress for that function to the derived class function’saddress.

class Brass{ public:

Brass’s v-table

play ( )

~Instrument( )

Instrument::play



void play ( );

Brass::play( )

void display( int);

~Brass( );

Brass::~Brass( )

the signature of the display functiondoes not match the one in the base

class, so no change is made to the v-table.

Brass’s v-table

play ( )

~Instrument( )

display( ) Instrument::display( )

Brass::play( )

Brass::~Brass( )

Now, when an object of the derived class is createda pointer to the class’s v-table is added to the object.

Instrument* orchestra = new Brass( … some parameters…);

memberdata

The Brass object

The address of the object is saved in a base class pointer

Brass’s v-table

play ( )

~Instrument( )


Brass::play( )

Brass::~Brass( )myTuba

memberdata

orchestra

Instrument* iPtr = new Brass( … some parameters…);

Invoke the play( ) function

Brass’s v-table

play ( )

~Instrument( )


Brass::play( )

Brass::~Brass( )myTuba

memberdata

orchestra -> play ( );

orchestra

1. the pointer is dereferenced to find the object.

2. the pointer to the v-table is located in the object.

3. This pointer is dereferenced to access the v-table

4. the play( ) function is located in the v-table and the corresponding address is used to invoke the play function.

What happens now if you want to invoke thedisplay (int) function from the Brass class?

class Brass{ public: void play ( ); void display ( int ); ~Brass ( );}; Brass’s v-table

play ( )

~Instrument( )

Instrument::play



the function display (int) was not defined in the base class, and it is not virtual, so itis not in the v-table.

So, if you write

orchestra -> display ( 5 );

You will get a compiler error, becauseOrchestra is a base class pointer, and thefunction display ( int ) is not defined in thebase class.

As you have seen, when you store the addressof a derived class object in a base class pointer,you lose information about the class that theobject belongs to. Thus, it seems impossible toinvoke the derived class function display (int) withthe statement

orchestra -> display (5);

We could cast the pointer to a derived classpointer … but what if we are not sure thatthe object being pointed to really is an objectof the Brass class?

Run Time Type Identification

Run Time Type Identification (RTTI) provides a wayto find out what kind of an object is pointed to by abase class pointer.

To find the type of object being pointed to, we usea special function typeid ( ). To use this function wemust #include <typeinfo>.

Instrument

virtual void play( )

Brass

virtual void play( )void play (int)

Percussion


Woodwind


Consider the inheritance hierarchy …

And suppose you have the following situation:

Instrument *orchestra[3];

orchestra[0] = new Brass (some parameters);orchestra[1] = new Percussion (some parameters);orchestra[2] = new Woodwind (some parameters);

… and you want to execute the line

orchestra[0]->display(37);

Since orchestra[0] contains a base class pointerand play(int) is not in the v-table …

orchestra[0]->play(37);

will give you a compiler error

So … how do you execute Brass class play(int) function?

We can determine whether or not an object pointedto in the array of base class pointers is a Brassinstrument by writing

for (int i = 0; i < 3; i++ ){ if ((typeid (*orchestra[i])) == typeid (Brass)) { // code }} dereference the pointer

and get the typeid of whatit points to.

then compare it with thetypeid of the Brass class.

If we determine that the object pointed to is, in fact,an object of the Brass class, then we can downcastthe pointer and invoke the derived class function.

In this case we use a dynamic cast. The dynamic cast checks at run time to be sure that the cast is safe.

Dynamic Casting

dynamic_cast<Brass*>(orchestra[i]) -> play (5);

this is a base class pointerthis casts the pointer

to a Brass pointerand we can now invokethe play (int) function!

Notes

• There is some overhead involved with the use of RTTI• The typeid function should only be used for comparisons• Dynamic casting also involves some overhead• Dynamic casting only works with pointers

polymorphism and virtual functions. topics polymorphism virtual functions pure virtual functions...

Documents

instr instr

base class virtual

base class functions

class foo

base class destructor

virtual functions slide

derived class object

printmydata function