We have observed that if a base class has a method "Speak()", and that method is overridden in it's derived class, a pointer to a base object that is assigned to a derived object will simply "do the right thing".   Example:

In the Giant class, what happens if you want to add a method to Giant that is inappropriate for Monster?  Perhaps something like the method SquashLittlePeopleLikeABug(), which Giants may do, but many other Monsters may not be capable of.  Example:

If you called SquashLittlePeopleLikeABug() on your Monster pointer, you would get a compiler error:

error C2039: 'SquashLittlePeopleLikeABug' : is not a member of 'Monster'

When the compiler tries to resolve SquashLittlePeopleLikeABug() in its virtual table, there will be no entry.  If you have a pointer to a base class assigned to a derived class, it should be because you intend to use that object polymorphically.  Don't try accessing methods specific to a derived class with a base class pointer.  As usual, there is a work around, a method of cheating. You might cast a base class pointer to a derived type.  To do this you need the dynamic_cast operator. 

dynamic_cast operator - The dynamic_cast operator ensures casting safely, but it is considered by many to be passé and unpredictable.   The purpose of virtual functions is to allow the virtual table, rather than the programmer, to determine the runtime type of the object.  This helps you quickly find places in your code where you have used this feature and remove them.  If you have a pointer to a base class, such as Monster, and you assign to it a pointer to a derived class, such as Giant, you can use the Monster pointer polymorphically.  If you then need to get at the Giant object to call the SquashLittlePeopleLikeABug() method, you create a Giant pointer and use the dynamic_cast operator to make the conversion.  At runtime the base pointer is examined.  If the conversion is proper, the new Giant pointer is fine, if not, or if you don't have a Giant object, the new pointer will be NULL.  The dynamic_cast is complemented by the static_cast operator and functions like so:

dynamic_cast<type-id>( expression ) - It converts the operand (expression) to the object of type <type-id>.  The <type-id> must be a pointer or a reference to a pre-defined class. 

static_cast<type-id>( expression ) -  It converts the operand (expression) to the object of type <type-id> without checking to make sure the conversion is safe.  It is useful for converting a pointer to a base class object into a pointer to a derived class object.  It can also convert enums to ints and ints to floats. 

Example (Note: Depending on the patch/version, this may not function the same among different compilers)

In this example there are two loops.  In the first, the user is asked to add a Cat or Dog object to the array of Mammal pointers in a loop that iterates three times.  This first loop calls the Mammal, Dog and Cat constructors as each object is chosen by the user and entered into an array.  The second loop uses an array to call the appropriate Speak() method from Dog and Cat that overrides the one in Mammal.  A pointer to Cat is created, "pRealCat".  It is initialized to 0 and dynamic_cast is used to make sure that the object the Purr() method is called on is a Cat and not something else for each element of Zoo[i].  If the object is a Cat, the pointer will not be NULL, and will pass the test and cout << "rrrrrrrrr".  If the object is not a Cat, the pointer will be NULL, and so it will fail the test and cout << "Uh oh, not a cat!\n".   Here's another example:

#include <iostream.h>

//---------------------------------------------------------------------------------------------------------------------

class B {  };

//---------------------------------------------------------------------------------------------------------------------

class C : public B {  };

//---------------------------------------------------------------------------------------------------------------------

class D : public C {  };

//---------------------------------------------------------------------------------------------------------------------
 

void f(D *pd)
{
  C *pc = dynamic_cast<C*>(pd);         // ok: C is a direct base class
                                        // pc points to C subobject of pd

  B *pb = dynamic_cast<B*>(pd);         // ok: B is an indirect base class
                                        // pb points to B subobject of pd
  

}

//---------------------------------------------------------------------------------------------------------------------

void main() { 

     D DObject;
     f(&DObject);

}

Example of a hierarchy of classes:

In this case, the classes Circle, Square and Rectangle derive from the base class Shape and override its virtual methods. 

ADT - Abstract Data Type.  An ADT, or Abstract Data Type, represents an ambiguous or vague concept like Shape, rather than an object of physical reality like Circle.  ADT's are always base classes to other classes.  You can not make an instance of a class that is an ADT.  You declare a class to be an ADT by including 1 or more pure virtual functions in the class declaration.

Pure Virtual Functions - Pure virtual functions are used to create ADT's.  Virtual functions are made pure by initializing them with 0.  Example: virtual void Draw() = 0;  Once a class contains a pure virtual method, we can assume certain implications:

• The pure virtual method will NEVER be used, and it must ALWAYS be overridden in each derived class.
• The class that contains it is an ADT, and the base class for derived classes.
• Since the class is an ADT, there will NEVER be an instance or object of that class, only of derived classes.

Any class deriving from an ADT inherits the pure virtual function as pure and so must override every pure virtual function in order to instantiate objects.  If Rectangle inherits from Shape, and Shape has 3 pure virtual functions, then Rectangle must override all 3 of those pure virtual functions, else it will be an ADT itself.  An example of making virtual functions pure:

class Shape
{
      public:
      Shape(){}
      ~Shape(){}

      //Pure virtual functions are virtual methods initialized to 0.  This makes the class an ADT.
      virtual long GetArea() = 0; 
      virtual long GetPerim()= 0;
      virtual void Draw() = 0;

      private:
};

Again, let's restate that typically pure virtual functions are never implemented, no objects are created that use them, and the ADT works purely as the definition of an interface to objects that derive from it.   The ADT never created objects of itself, only its derived classes have instances.  In this way it functions more as an organizational tool of the "Is-A/Has-A" relationship than an actual, working class structure.  You can provide an implementation to a pure virtual function, so that it can be called by objects derived from the ADT.  You might do this to provide common functionality to all of the overridden functions.  Below Shape is an ADT, the Circle class overrides Draw(), and then chains up to the base class function for additional functionality.  Example:

The output of the example above is the same as the output of the previous example.  However, the structure is different - the Shape class has now become an ADT.  If only one function is declared pure virtual, the class is an ADT.  Circle and Rectangle override Draw(), but chain up to the base method to take advantage of shared functionality.  You can derive ADTs from other ADTs.  In the code below, no Animal objects or Mammal objects can be instantiated because they are both base classes and both are ADTs.  However, all Mammals may inherit the Reproduce() method without overriding it.

Here, Mammal overrides the Animal Reproduce() method to provide a common method of reproduction for all Mammals.  The Fish class must override Reproduce(), since it derives directly from Animal and can not use Mammalian reproduction.  Remember:

1. Use ADTs to provide common functionality to related classes.
2. Override all pure virtual functions.
3. If possible, make pure virtual any function that must be overridden.
4. Don't instantiate an object of an ADT.  It is an abstract, ambiguous base class only.

©2004 C. Germany