Lecture 3. Inheritance

Objective: In this lecture unit, we show:

how the general principles of inheritance and the object-oriented concept of polymorphism relate to code reuse,
how inheritance is implemented in C++,
how a collection of classes can be derived from a single abstract class, and
how run-time binding decisions, rather than compile-time linking decision, can be made for these classes.

3.1 Inheritance Basics

Inheritance models an IS-A relationship where we have a class A and want to create a class B which IS-A (variation of) class A. E.g. a Circle IS-A Shape and a Car IS-A Vehical.
We can always copy the definition of A and make the necessary changes, but then code proliferates and becomes difficult to manage.
Obviously, inheritance would be a better solution. It allows the reuse of code.

In C++, you would implement inheritance as:

class Derived : public Base
{
  // Base members unlisted are inherited unchanged
  // except for constructor, destructor, copy
  // constructor, and operator=
public:
  // new public members
  // Base members which are to be changed

private:
  // new private members
  // Base members disabled in Derived
};

This says: instances of B are just like instances of A except that
- they may have certain additional member functions and/or member data; and
- certain members of A can be redefined in B.
A protected member is like a private member with the exception that it can be accessible by members of derived classes.
A's members are inherited by B.
B is called a derived class and A its base class.
If C is a derived class from B, then C inherits members from both A and B.
Inheritance relationships form hierarchies.

A derived class may redefine a virtual member function, say f, inherited from a base class. If f is referenced through a pointer, then dynamic or (late) binding is necessary.

class Employee
{
public:
   Employee();
   void get_name(string& name) const;
   int  get_number() const;
   void change_name(const string& new_name);
   void change_number(int new_number);

private:
   string name;
   int number;
};

class HourlyEmployee : public Employee
{
public:
   HourlyEmployee();
   double get_wage_rate() const;
   void change_wage_rate(double new_rate);

private:
   double wage_rate;
};

3.2 Types of Inheritance

                       =============================================
                       Inheritance    Base Class      Derived Class
                          Type      Member Access     Member Access
                       =============================================
                                        public           public
                          public       protected        protected
                                        private          private
                       ---------------------------------------------
                                        public          protected
                         protected     protected        protected
                                        private       (inaccessible)
                       ---------------------------------------------
                                        public           private
                          private      protected         private
                                        private       (inaccessible)
                       ---------------------------------------------

3.3 Types of Inheritance (Example)

Mark each of the following numbered statements as legal (Y) or illegal (N):

class A
{
public:
   int aPubVar;

private:
   int aPrivVar;

protected:
   int aProtVar;
};

class B : public A
{
public:
   int bPubFunc();
   int bPubVar;

protected:
   int bProtFunc();
   int bProtVar;
};

class C : protected B
{
private:
   int cPrivFunc();
};

int B::bPubFunc()
{
     ...
(1)  aPubVar  = 0;
(2)  aPrivVar = 0;
(3)  aProtVar = 0;
     ...
}

int C::cPrivFunc()
{
     ...
(4)  aPubVar  = 0;
(5)  aPrivVar = 0;
(6)  aProtVar = bProtFunc();
     ...
}

main()
{
     ...
     C cObj;
(7)  cObj.aPubVar  = cObj.bPubFunc();
(8)  cObj.aProtVar = cObj.bPubFunc();
(9)  cObj.bPubVar  = cObj.bProtFunc();
(10) cObj.bProtVar = cObj.bProtFunc();
     ...
}

3.4 Adding Members

C++ defines in <stdexcept> the class exception. There areseveral kinds of exceptions, including bad_alloc and bad_cast. They are derived classes of exception. All exception classes have the what method which can be used to return a (primitive) string that details an error message.

Object& operator[](int index)
{
   if (index < 0 || index >= size())
   {
      throw BadIndex(index, size());
   }
   return objects[index];
}

class BadIndex : public exception
{
public:
   BadIndex(int idx, int sz) : index(idx), size(sz) {}

   int getIndex() const { return index; }
   int getSize()  const { return sz; }

private:
   int index;
   int size;
};

int main()
{
   NewVector v(10);

   try
   {
      for (int i = 0; i <= v.size(); i++)
         v[i] = 0;
   }
   catch(const BadIndex& e)
   {
      cout << e.what() << ", index=" << e.getIndex()
           << ", size=" << e.getSize() << endl;
   }
   return 0;
}

3.5 Overriding a Method

Override a method from the base class in the derived class by providing a derived class method with the same signature.

Can use the scope operator to call the base class method in the overriding method. This is known as partial overriding.

class Workaholic : public Worker
{
public:
   void doWork()
   {
      Worker::doWork();
      drinkCoffee();
      Worker::doWork();
   }
};

3.6 Static and Dynamic Binding

The decision of which doWork() to call in each case can be made at compile-time -- static binding.
```
Worker w;
Workaholic wh;
   ...
w.doWork();
wh.doWork();
```

C++ uses static binding by default unless you specify dynamic binding should be used.

Worker *wptr;
cin >> x;
if (x != 0)
   wptr = new Workaholic();
else
   wptr = new Worker();
  ...
wptr->doWork();  // Which doWork to use?

One asks for dynamic binding by specifying the method to be virtual.
To use dynamic binding,
- the function must be declared to be virtual;
- it is invoked via a pointer to the base type, and
- the decision cannot be made at compile-time.
Constructor must not be declared virtual.
In an inheritance hierarchy, the base class destructor needs to be virtual to ensure the correct destructor is called.

Example:

class exception
{
public:
   exception();
   exception(const exeception& rhs);
   virtual ~exception();
   const exception& operator=(const exception& rhs);
   virtual const char *what();

private:
   // implementation dependent
};