CMPT 212 Object-Oriented Applications Design in C++ Fall 1997

Dynamic Object Polymorphism (continued)

• (continued)
  • A vtable contains pointers to the class's virtual functions. The format a vtable can be determined at compile time, and a vtable is initialized once at program start-up.

  • Each instance contains a hidden pointer which points to the vtable for its class.

  • When a virtual member function is called, the pointer from the instance to the vtable is followed, then the pointer from the vtable to the member function is followed.

• Note that dynamic polymorphism mechanisms are needed only when dealing with pointer (or references) to instances. If we are dealing directly with an instance, the compiler can determine its type from the type declaration.

• Example:

     class Point {
        public:
  	 ...
  	 virtual display();
        ...
        };
  
     class Circle : public Point {
        public:
  	 ...
  	 virtual display();
        ...
        };
  
     class Disk : public Circle {
        public:
  	 ...
  	 virtual display();
        ...
        };
  
  	 

• Virtual functions are only required for member functions which will be overridden in a derived class.

• The virtual keyword only needs to appear in the function prototype in the base class, but adding it to the prototypes in the derived classes may make it clearer for a programmer to read.
  • A virtual member function is virtual for all derived classes, whether or not the virtual keyword appears in the function prototype in derived classes.

• Example:

     Point * graphobjs[10];
     ...
     for (int i=0; i<10; i++) {
        graphobjs[i]->display();
        }
  	 

  • This code will still work even if we later derive new classes from Point that have their own display member function.

Virtual Destructors

• It is a good idea to make destructors virtual.

• Example:

     derivedClass * d = new derivedClass;
     baseClass * b = d;
     delete b;
  	 

  • The memory will be released correctly, but the wrong destructor is called.

  • The ~baseClass destructor will be called, since b is declared to point to an instance of a baseClass.

  • Making destructors virtual ensures that the correct destructor will be called.

• Example:

     class baseClass {
        public:
  	 virtual ~baseClass();
        ...
        };
  
     class derivedClass : public baseClass {
        public:
  	 virtual ~derivedClass();
        ...
        };
  
  	 

Abstract Base Classes

• Problem: Sometimes we may have a base class for which no instances should exist.

• Such a class is called an abstract base class or abstract class.

• Examples:
  • elephant, lion, and monkey are all derived classes from the base class animal. We want to allow instances of elephant to exist, but not instances of just animal.

  • university, high school, and elementary school are derived from school. We don't want instance of just school. Any school instance must also be an instance of one of the derived classes.

• In C++, how can we indicate that a given class is an abstract base class?
  • If a class contains at least one "pure virtual function", then the class is an abstract base class and no instances of it can exist.

Pure Virtual Functions

• A pure virtual function is a virtual member function which has no implementation (not even in a .cpp file).

• A pure virtual function is defined by putting "= 0" after the function prototype.

• Example:

     class animal {
        public:
  	 virtual void eat() = 0;
        ...
        };
  	 

• Any class derived from an abstract base class must give an implementation of every pure virtual function in the abstract base class. Otherwise, the derived class is also an abstract class, and no instances of it can exist.

• The purpose of pure virtual functions is to specify a minimum interface that all derived classes must provide.
  • Example: If every animal must move, breathe, and eat, then we could have this interface:

       class animal {
          public:
    	 virtual void move() = 0;
    	 virtual void breathe() = 0;
    	 virtual void eat() = 0;
          ...
          };
    	       

    Each class derived from animal must implement these functions, but since different animals move, breathe, and eat in different ways, they can implmenent them in different ways.

Return to lecture notes index

Lectures