CMPT 212 Object-Oriented Applications Design in C++ Spring 1998

Static Object Polymorphism (continued)

• Example: Suppose we have a collection of graphical objects and we want to set the colour of each of them to the colour 7.

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

• Static object polymorphism only works when the compiler can determine at compile time (staticly) which member function to call.
  • The examples above work because there are only one move and setColour functions.

  • It will work for these statements because the compiler can determine which display to call.

       Point  p;
       Circle c;
       ...
       p.display();
       c.display();
    	       

  • It cannot work for these statements because the compiler cannot determine if p is pointing to a Point instance or to an instance of a derived class.

       void myFunc(Point * p) {
          p->display();
       }
    	       

    The function Point::display() will be called.

  • To solve this problem, we require dynamic polymorphism, which is implemented using "virtual" functions.

Slicing

• Question: What happens if we assign an instance of a derived class to an instance of a base class?
  • Example:

       Point  p;
       Circle c;
       ...
       p = c;
    	       

• Question: What if we assign in the other direction?
  • Example:

       Point  p;
       Circle c;
       ...
       c = p;
    	       

• The first case is allowed; the second is not.

• Slicing is when an instance of a derived class is assigned to an instance of a base class. Any properties of the derived class which are not in the base class are "sliced off".
  • Example:

       Point  p;
       Circle c;
       ...
       p = c;
    	       

    

• We cannot assign an instance of a base class to an instance of a derived class because we do not have enough information.
  • Example:

       Point  p;
       Circle c;
       ...
       c = p;
    	       

    

Dynamic Object Polymorphism

• Dynamic object polymorphism is where the type (class) of each instance in determined at run-time, and when a member function is called for an instance, the decision as to which function is called is made at run-time.

• Some object-oriented languages, such as Smalltalk, have unrestricted dynamic polymorphism.

• Dynamic polymorphism requires that each instance maintain a dictionary of its member functions.
  • When a member function is called, a look-up is done in the dictionary.

  • This look-up must be done for every member function call, which can result in slow performance.

• C++ implments limited dynamic polymorphism.
  • The programmer specifies which member functions should be implemented using a look-up table.

  • These member functions are declared using the keyword virtual.

  • Instead of building a dictionary for each instance, C++ builds a virtual dispatch table (vtable) for the classes which have virtual functions.

  • 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.

Return to lecture notes index

Lectures