Polymorphism and Virtual Functions

Topics Polymorphism Virtual Functions Pure Virtual Functions Abstract Base Classes Virtual Destructors V-Tables Run 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 functions Correctly use polymorphism in a program * Store pointers to dynamically created objects in arrays of base class pointers Explain how V-Tables are used to make polymorphism work Explain why a virtual destructor is needed Safely access base class functions in a program, using rtti and dynamic 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 a variable 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 instrs dynamic type.

From Inheritance... Recall that you can store the address of a derived class object in a base class pointer. What happens if you use the base class pointer to invoke a function that exists in the base class, but has been over-ridden in the derived class?

Virtual Functions class Instrument { public: virtual void play ( ) const; void display ( ); protected: string name; }; the keyword virtual says that we can over-ride this function in a derived class. But, when we use a base class pointer to point to the object, and invoke the virtual function, the system will automatically find and execute the function defined in the derived class, not the base class! Moreover, if we have many different derived classes, the system will find the correct function 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

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

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 + printMyData( ) : void

Foo Bar Widget # myData : string + printMyData( ) : void - barData1 : string + printMyData( ) : void - widgetData1 : string + printMyData( ) : void void printMydata( ) { cout << I am a Foo object, my data is << myData << endl; }

Foo Bar Widget # myData : string + printMyData( ) : void - barData : string + printMyData( ) : void - widgetData2 : string + printMyData( ) : void void printMydata( ) { cout << I am a Bar object, my data is << myData << barData << endl; } myData is visible to the child class

Foo Bar Widget # myData : string + printMyData( ) : void - barData : string + printMyData( ) : void - widgetData : string + printMyData( ) : void 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 precede any function that you want to call using polymorphism. In the derived class the signature must exactly match the signature of the function being over-ridden. If the signature is different, the compiler considers it to be a different function, not an over-riding function. The actual implementation of the function in the derived class will be different than that in the base class. The function is invoked through a base class pointer that contains the address of the derived class object.

Pure Virtual Functions In the previous example, we provided an implementation for 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 virtual function. Pure virtual functions have no implementation.

class Foo { public: virtual void printMyData( ) const = 0; protected: string myData; } the =0 notation signals that this is a pure virtual function. There should be no implementation of this function written.

Abstract Classes If a class contains at least one pure virtual function then 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 operator to a base class pointer, only the base class destructor is called. This can leave derived class data members on the heap with no way to delete them. This problem is solved by making the destructor in the base class virtual. Polymorphism then causes the derived class destructor to be called first. It will automatically call the base class destructor, insuring that all data is properly removed from the heap.

V-Tables When the compiler encounters a class definition that contains virtual functions, it builds a v-table for that class. The v-table contains the addresses of all of the virtual functions for the class. class Instrument { public: int getValue( ); virtual void play ( ); virtual void display ( ); virtual ~Instrument ( ); }; Instruments v-table play ( ) ~Instrument( ) Instrument::play Instrument:: ~Instrument display( ) Instrument::display

When the compiler encounters a derived class definition that inherits publicly from this base class, it copies the v-table from the base class for the derived class. class Brass : public Instrument { public: void play ( ); void display ( int ); ~Brass ( ); }; Brasss v-table play ( ) ~Instrument( ) Instrument::play Instrument:: ~Instrument display( ) Instrument::display

Now, for any function in the derived class that over-rides a virtual function in the base class, the compiler sets the address for that function to the derived class functions address. class Brass { public: Brasss v-table play ( ) ~Instrument( ) Instrument::play Instrument:: ~Instrument display( ) Instrument::display void play ( ); Brass::play( ) void display( int); ~Brass( ); Brass::~Brass( ) the signature of the display function does not match the one in the base class, so no change is made to the v-table.

Brasss v-table play ( ) ~Instrument( ) display( ) Instrument::display( ) Brass::play( ) Brass::~Brass( ) Now, when an object of the derived class is created a pointer to the classs v-table is added to the object. Instrument* orchestra = new Brass( … some parameters…); member data The Brass object

The address of the object is saved in a base class pointer Brasss v-table play ( ) ~Instrument( ) display( ) Instrument::display( ) Brass::play( ) Brass::~Brass( ) myTuba member data orchestra Instrument* iPtr = new Brass( … some parameters…);

Invoke the play( ) function Brasss v-table play ( ) ~Instrument( ) display( ) Instrument::display( ) Brass::play( ) Brass::~Brass( ) myTuba member data 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 the display (int) function from the Brass class? class Brass { public: void play ( ); void display ( int ); ~Brass ( ); }; Brasss v-table play ( ) ~Instrument( ) Instrument::play Instrument:: ~Instrument display( ) Instrument::display the function display (int) was not defined in the base class, and it is not virtual, so it is not in the v-table.

So, if you write orchestra -> display ( 5 ); You will get a compiler error, because Orchestra is a base class pointer, and the function display ( int ) is not defined in the base class.

As you have seen, when you store the address of a derived class object in a base class pointer, you lose information about the class that the object belongs to. Thus, it seems impossible to invoke the derived class function display (int) with the statement orchestra -> display (5);

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

Run Time Type Identification Run Time Type Identification (RTTI) provides a way to find out what kind of an object is pointed to by a base class pointer. To find the type of object being pointed to, we use a special function typeid ( ). To use this function we must #include.

Instrument virtual void play( ) Brass virtual void play( ) void play (int) Percussion virtual void play( ) Woodwind virtual void play( ) 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 pointer and 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 pointed to in the array of base class pointers is a Brass instrument by writing for (int i = 0; i < 3; i++ ) { if ((typeid (*orchestra[i])) == typeid (Brass)) { // code } dereference the pointer and get the typeid of what it points to. then compare it with the typeid of the Brass class.

If we determine that the object pointed to is, in fact, an object of the Brass class, then we can downcast the 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 (orchestra[i]) -> play (5); this is a base class pointer this casts the pointer to a Brass pointer and we can now invoke the 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