In C++ The Complete Reference, Schildt says that a class that contains a virtual function is called a polymorphic class. This begs the question "What is polymorphism?". Schildt gives a very nice example of this term. He says to consider a house with an ordinary thermostat to control temperature. You know the house has a furnace but you don't know what kind. If you want to set the temperature you simply set the thermostat to the desired temperature. You don't know (or likely really care at all) how the furnace accomplishes its task. It might be a gas furnace, an electric heater, solar power - you don't care. You leave it up to the furnace to do its own task in a manner appropriate to that device.

How does this relate to polymorphism? Well, an analogy to computer programming is the concept of push/pop operations on various kinds of stacks.

• The push and pop operators are akin to setting temperatures on a thermostat.
• The stack is akin to a furnace. Just as you can have any type of furnace, you can have any kind of stack - integer, float, character, and so on.

The idea behind all this is to simplify the life of the operator - the programmer.

• In the base class, you must begin the function declaration with the keyword virtual.

• The keyword virtual is not used in the derived functions.

• The number and type of parameters in the derived function must match the number and type in the initial declaration of the virtual function.

Here is a simple example.

#include <iostream>
using namespace std;

/*-------------------------------------------------
  Class Name:	base_class
-------------------------------------------------*/
class base_class {

		// The keyword VIRTUAL must be used here!!
public:		
   virtual void printit() {
       cout << "Print from base class\n";
       } 
}; // end base_class


/*-------------------------------------------------
  Class Name:	first_class
-------------------------------------------------*/
class first_class : public base_class  {
public:
    void printit() {
	cout << "Print from first class\n";
	} 
}; // end first_class


/**************************************************
   Name:	main 
**************************************************/
void main() {

base_class *base_ptr;	// declare a pointer for the base class
base_class base;	// declare an object of the base class

base_ptr = &base;	// point to the new object
base_ptr->printit();	// execute its virtual function

first_class first1;	// declare an object of the derived class

base_ptr = &first1;	// point to the new object
base_ptr->printit();	// execute its virtual function

} // end main function

	Print from base class

	Print from first class

A few notes about virtual functions:

• The keyword virtual is used only in the base class declaration.

• When a derived class redefines the virtual function in a base or predecessor class, this is referred to as overriding the function. Don't confuse this with overloading a function.

  When you call an overriding function, you must supply the same number and type of parameters as the original. (You'll remember that the opposite is true for an overloaded function call.)

• Friend functions cannot be virtual, nor can constructor functions, although destructor functions can be virtual.

• A derived class does not have to redefine (override) a virtual function. You'll see in the following example, that the "second_class" class relies on the definition of the virtual function in the base class. In other words, if a derived class does not specify code for the virtual function, then the code in the predecessor function is used.

• A derived function inherits the virtual functions of its predecessors which may or may not be the base class. Notice in the following example how the "tourist_class" is derived from the "coach_class". "tourist_class" does not override the virtual function, so the definition in the immediate predecessor, in this case "coach_class", is used.

/* Filename: pub/class/170/ftp/cpp/Vfuncs/ex2-wptrs.cpp   */

#include <iostream>
     using namespace std;


     /*-------------------------------------------------
       Class Name:   base_class
     -------------------------------------------------*/
     class base_class {

                     // The keyword VIRTUAL must be used here!!
     public:
        virtual void printit() {
             cout << endl << "Print from base class" << endl;
            }
     }; // end base_class


     /*-------------------------------------------------
       Class Name:   first_class
     -------------------------------------------------*/
     class first_class : public base_class  {
     public:
         void printit() {
             cout << endl << "Print from first class" << endl;
             }
     }; // end first_class

     /*-------------------------------------------------
       Class Name:   second_class
     -------------------------------------------------*/
     class second_class : public base_class  {
     }; // end second_class

     /*-------------------------------------------------
       Class Name:   coach_class
     -------------------------------------------------*/
     class coach_class : public base_class  {
     public:
         void printit() {
             cout << endl << "Print from coach class" << endl;
             }
     }; // end coach_class

     /*-------------------------------------------------
       Class Name:   tourist_class
     -------------------------------------------------*/
     class tourist_class : public coach_class  {
     }; // end tourist_class





/**************************************************
     Name:        main
**************************************************/
void main() {

     base_class *base_ptr;   // declare a pointer for the base class
     base_class base;        // declare an object of the base class

     base_ptr = &base;         // point to the new object
     base_ptr->printit();    // execute its virtual function

     first_class first1;     // declare an object of the derived class

     base_ptr = &first1;       // point to the new object
     base_ptr->printit();    // execute its virtual function

     second_class second1;     // declare an object for second
     base_ptr = &second1;
     base_ptr->printit();

     coach_class coach1;     // declare an object for coach
     base_ptr = &coach1;
     base_ptr->printit();

     tourist_class tour1;     // declare an object for tourist
     base_ptr = &tour1;
     base_ptr->printit();

} // end main function

Here is what happens when that program is run:

mercury[20]% ex2

Print from base class

Print from first class

Print from base class

Print from coach class

Print from coach class
mercury[21]%

If you would like to experiment with that program you can copy it from Mercury's ftp site. There are some comments in the program suggesting how you might modify the classes. To copy the program use the Hercules command-line ftp program from Mercury's anonymous ftp site.