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

Read chapter 13 (except sections with Template in the name) from C++ Primer Plus (2nd ed.), by Stephen Prata.

Multiple Inheritance

• Multiple inheritance is where a class inherits from more than one base class.

• Multiple inheritance is a simple concept, but it can be difficult for a language designer to implement.
  • Many object-oriented languages do not have multiple inheritance. For example: Smalltalk, Modula-3, Ada95, Java.

• Example:

     class animal { ... };
  
     class mammal : public animal { ... };
  
     class egg_layer : public animal { ... };
  
     class platypus : public animal, public egg_layer { ... }:
           

Lifecycle of an Object

• There are 5 stages in the life of an object:
  1. Before the constructor is run:
     • memory is allocated for the object.
     • the constructors of any base classes are called.
     • the constructors of any component objects are called.

  2. The constructor body is run.

  3. The object is used by the program.

  4. The destructor is run.

  5. After the destructor has exited:
     • the destructors of any component objects are called.
     • the destructors of any base classes are called.
     • memory for the object is released.

• Note that the order that the destructors are called is the reverse order that the constructors are called.

• If we want to call constructors other than the default constructors for the base classes and the component objects, we must do that before (that is, outside) the body of the constructor.
  • They must be "called" in the initialization list of the constructor.

  • Example:

       class Point {
          public:
             Point() { x_coord = 0.0; y_coord = 0.0; }
             Point(float x, float y) { x_coord = x; y_coord = y; }
             ...
          private:
             float x_coord;
             float y_coord;
          };
    
       class Circle : public Point {
          public:
             Circle();
             Circle(float x, float y, float r);
             ...
          private:
             float radius;
          };
    
       Circle::Circle() {
          radius = 0.0;
       }
    
       Circle::Circle(float x, float y, float r) 
          : Point(x, y), radius(r) {
       }
                   

    We could also use initialization lists for the two Point constructors and the default Circle constructor.

• If the base class has constructors, but no default constructor, then the initialization list of the derived class's constructor must specify which base class constructor to use.

• The order of elements in the initialization list does not matter. The order of execution is this:
  1. Virtual base classes are constructed.
  2. Base classes are constructed. With multiple inheritance, they are initialized in the declared order.
  3. Component objects are initialized in the order that they appear in the member list.
  4. Simple data members are initialized in the order that they appear in the member list.

Return to lecture notes index

Lectures