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

Static Object Polymorphism

• We can have a pointer to an instance.
  • Example:

       Point * p = new Point;
       p->move(3.0, 4.0);
       p->display();
       delete p;
    	       

• A pointer defined to point to an instance of some base class can also point to instances of derived classes.
  • Example:

       Point * p = new Circle;
       p->move(3.0, 4.0);
       p->display();      // which "display" function?
       delete p;
    	       

• However, we can only access data members and member functions which are present in the base class.
  • A pointer which is defined to point to a Point can point to any Point instance (including a Circle instalce or a Disk instance), but it can only use those properties and functions which are common to all Point instances.

• The ability to treat instances of different classes the same by using only their common properties and functions is called static object polymorphism.

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

Return to lecture notes index

Lectures