Chapter 11: Inheritance I

Chapter Goals

• To understand the concepts of inheritance and polymorphism
• To learn how inheritance is a tool for code reuse
• To learn how to call base-class constructors and member functions

Derived Classes

• Inheritance is a mechanism for enhancing existing working classes.
• If a new class needs to be implemented and a class representing a more general concept is already available, then the new class can inherit from the existing class.
• The existing, more general class is called the base class.
• The more specialized class that inherits from the base class is called the derived class.
• Example: We already have a class Employee, and a manager is a special case of an employee.

  class Manager : public Employee {
  public:
     new member functions
  private:
     new data members
  };

Syntax 11.1 Derived Class Definition

class Derived_class_name : public Base_class_name
{
   features
};

class Manager : public Employee
{
public:
   Manager(string name, double salary, string dept);
   string get_department() const;
private:
   string department;
};

Derived Classes

• All member functions and data members of the base class are automatically inherited by the derived class.

  Manager m;
  m.set_salary(68000);

• In the derived class definition you specify only new member functions and data members.

  class Manager : public Employee {
  public:
     Manager(string name, double salary, string dept);
     string get_department() const;
  private:
     string department;
  };

• The class diagram below shows the relationship between derived classes. The arrow with a hollow head indicates inheritance.

  

• Example: Modelling a set of clocks that display the times in different cities.

Derived Classes (clocks1.cpp)

Derived Classes

• The Clock class presented in clocks1.cpp provides a base class that can tell the current local time.
• You can set a clock to either "military" or "am/pm" format.
• We will create a derived class, TravelClock that gains two additional data fields: location and time_difference.
• The time for a TravelClock is computed by taking the local time and adding the time difference.

  TravelClock clock("New York", 3);
  cout << "The time in " << clock.get_location() << " is "
     << clock.get_hours() << ":" << clock.get_minutes();

• A TravelClock differs from a Clock in three ways:
  • Its objects store the location and time difference.
  • The get_hours function of the TravelClock adds the time difference to the current time.
  • The get_location function returns the actual location, not the string "Local".
• When the TravelClock class inherits from the Clock class, it needs only to spell out these three differences.

  class TravelClock : public Clock {
  public:
     TravelClock(bool mil, string loc, double off);
     int get_hours() const;
     string get_location() const;
  private:
     string location;
     int time_difference;
  };

• The data members of the base class are present in each derived class object, but they are not accessible by the member functions of the derived class besause these fields are private data of the base class.
  

Calling the Base-Class Constructor

• The constructor of a derived class has two tasks:
  • Initialize the base object.
  • Initialize all data members.
• Frequently, a derived-class constructor must invoke the base-class constructor before initializing the derived-class data.
• Here, we call the Clock constructor with the parameter mil before executing the code inside the {}.

  TravelClock::TravelClock(bool mil, string loc, int diff)
     : Clock(mil)
  {  location = loc;
     time_difference = diff;
     while (time_difference < 0)
            time_difference = time_difference + 24;
  };

• If you omit the base-class constructor, then the base object is constructed with the default constructor of the base class.
• If the base class has no default constructor, then you have to explicitly call the base-class constructor in the derived-class constructor.

Syntax 11.2 Constructor with Base-Class Initializer

Derived_class_name :: Derived_class_name(expressions)
   : Base_class_name(expressions)
{
   statements
}

Manager::Manager(string name, double salary, string dept)
   : Employee(name, salary)
{
   department = dept;
}

Calling Base-Class Member Functions

• Suppose B::f is a function in the base class. The the derived class D can take three kinds of actions.
  • The derived class can extend B::f by supplying a new implementation that refers to the base-class implementation. For example, the TravelClock::get_hours function is an extension of Clock::get_hours.
  • The derived class can replace B::f by supplying a new implementation that is unrelated to the base-class implementation. For example, TravelClock::get_location is a replacement for Clock::get_location.
  • The derived class can inherit B::f by not supplying an implementation for f. For example, TravelClock inherits Clock::get_minutes and Clock::is_military.

• A member function called without an implicit parameter - it is called through the implicit parameter object of the derived class.

  int TrvaelClock::get_hours() const
  { . . . 
  
     if (is_military())  /* clock uses military time */
            return (h + time_difference) % 24;
    . . . 
   }

• When the base class and the derived class have a member function with the same name, you must be more specific which function you want to call.

  int TrvaelClock::get_hours() const
  {  . . .
     int h = Clock::get_hours(); /* calls base-class function */
     . . .
  }

• The following call would die in an infinite recursion.

  int TravelClock::get_hours() const
  {  . . .
     int h = get_hours(); /* BAD! calls itself */
     . . . 
  }

Calling Base-Class Member Functions (clocks2.cpp)