Virtual Functions

Junaed Sattar November 10, 2008 Lecture 10

Constructor/Destructor Order

Destructors, constructors, and assignment operators are not inherited

they may be called automatically were necessary

Constructors are called from the bottom up Destructors are called from the top down

Example
class Base { public: Base() { cout << "calling base constructor." << endl; } ~Base() { cout << "calling base destructor." << endl; } };
class Derived1: public Base{ public: Derived1() { cout << "calling derived1 constructor." << endl; } ~Derived1() { cout << "calling derived1 destructor." << endl; } }; class Derived2 :public Derived1{ public:Derived2() { cout << "calling derived2 constructor." << endl; } ~Derived2() { cout << "calling derived2 destructor." << endl; } }; int main(){ Derived2 d; }

Output
calling base constructor.
calling derived1 constructor.

calling derived2 constructor.

calling derived2 destructor.

calling derived1 destructor.

calling base destructor.

Virtual Functions

C++ matches a function call with the correct function definition at compile time

known as static binding

the compiler can match a function call with the correct function definition at run time

known as dynamic binding.

declare a function with the keyword virtual if you want the compiler to use dynamic binding for that specific function.

Virtual Methods

Therefore,

a virtual function is a member function you may redefine for other derived classes, can ensure that the compiler will call the redefined virtual function for an object of the corresponding derived class, even if you call that function with a pointer or reference to a base class of the object.

A class that declares or inherits a virtual function is called a polymorphic class.

Declaring virtual

prefix declaration with the virtual keyword

redefine a virtual member function in any derived class this is called overriding

understand the contrast with overloading

More on definition

overridden function must have same name and same parameter list

no need to use the virtual keyword again return type can be different

if the parameter lists are different, they are considered different

in this case, it is not overridden, but hidden hidden methods cannot be called

Example
class A { public: virtual void f() { cout << "Class A" << endl; } }; class B: public A { public: void f(int) { cout << "Class B" << endl; } };

class C: public B {
public: void f() { cout << "Class C" << endl; } };

Output
int main() { B b; C c; A* pa1 = &b; A* pa2 = &c; // b.f(); pa1->f(); pa2->f(); }

Outputs:
Class A Class C

Synopsis

b::f() is not allowed

it hides A::f() (a virtual function)

not overloading (why?)

method overloading must happen within the same class, not in inheritance hierarchies

c::f() is allowed

virtual, overrides A::f()

So, why?

a hierarchy of geometric shape classes

Line

draw()

Rectangle
draw()

Circle
draw()

draws circles, ellipses, rectangles etc

Square
draw()

Ellipse
draw()

just use method draw throughout the hierarchy

More why

to enforce a software design

developers must define their own implementation

e.g. ImagingDevice objects (webcam, firewire, disk images, movies ..)

must acquire frames in their own way

should have uniform interface (hiding implementation details)

use pure virtual methods

Purely Virtual

a virtual function declared with no definition

base class contains no implementation at all

class containing a pure virtual function is an abstract class

similar to Java interfaces cannot instantiate from abstract classes inherited classes must define implementation

enforces a design through inheritance hierarchy

Example
class A { public: virtual void f() = 0; // pure virtual }; class B: public A { public: void f() { cout << "Class B" << endl; } }; class C: public B { public: void f() { cout << "Class C" << endl; } };

Output
int main() { B b; C c; A* pa1 = &b; A* pa2 = &c; pa1->f(); pa2->f(); } Outputs: Class B Class C

Another example
class ImagingDevice { protected: unsigned char *buffer; int width, height; ... public: ImagingDevice(); virtual ~ImagingDevice(); // virtual destructor ... virtual bool InitializeDevice() = 0; virtual bool GetImage()=0; virtual bool UninitializeDevice() = 0; virtual void SaveImage()=0; ... };

Continuing
class USBDevice: public ImagingDevice { ... public: USBDevice(); virtual ~USBDevice(); ... }; bool USBDevice::InitializeDevice(){ ... } bool USBDevice::UninitializeDevice(){ ... } bool USBDevice::GetImage(){ ... } void USBDevice::SaveImage(){ ... }

Why virtual destructor?

for properly cleaning up dynamically allocated memory

class Base{ public: Base(){} ... }; class Derived: public Base { int *memory; public: Derived(){ memory = new int[1000]; } ~Derived(){ delete [] memory; } }

Virtual Destructor
int foo() { Base *b = new Derived(); ... delete b; // will not call destructor of d, as it // should, (why?) }

Diagnosis

If not declared virtual, compiler uses type of pointer to decide which method to call

in this case, b is of type Base, so the Base destructor will get called memory leak from d (how?)

solution: always declare destructors virtual, even if no other virtual functions

Next

Generic programming with templates

The Standard Template Library