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

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.

Protected Members

• Problem: We want member functions of a derived class to be able to access members (data members or member functions) of a base class, but we don't want these members to be publicly available.
  • If we make the members private, then the derived class cannot access them.

  • If we make them public, then anyone can access them.

• Solution: Make them protected.

• protected members are like private members except that they can be accessed by derived classes.

• protected members are most often used for data members, so that the derived classes can access them directly without going through public access functions.

Public, Private, and Protected Inheritance

• So far we have only seen public inheritance.
  • Example:

       class baseClass {
          public:
             int a;
          private:
             int b;
          };
    
       class derivedClass {
          public:
             int c;
          private:
             int d;
          };
                   

    In an instance of derivedClass, the members a and c are publicly accessible, and b and d are not.

• Problem: Suppose we do not want the public members of the base class to be public in the derived class. Suppose we want them to be private or protected in the derived class.

• Solution: Use private or protected inheritance.

• Do not confuse public, private, and protected inheritance with public, private, and protected members.

• Access in base class	Base class inherited as	Access in derived class
  public protected private	public	public protected no access
  public protected private	protected	protected protected no access
  public protected private	private	private private no access

Return to lecture notes index

Lectures