Inheritance hierarchies reflect real world relationships.  To understand our world, we break it up into bits and group
these bits together into classifications. 

I. The "Has-a" Relationship

If something breathes, moves, eats and reproduces it is an Animal object.  We group together those things that  possess the characteristics of Animal objects, demonstrating the "has-a" relationship:  an Animal eats, an Animal reproduces, and an Animal is usually capable of some form of locomotion.  There are other objects in the universe that are not Animal: plants which photosynthesize and rocks which do not consume food.  For an object to be an Animal, it must possess distinctive characteristics relative to its "has-a" relationship.  There are a set of physical characteristics as well a a set of actions that correspond to Animal.   If we were going to create an Animal class, its data members and methods would be defined by the "has-a" relationship.  Example:

class Animal {
        public:
        Animal(){ }
        ~Animal() { }
   
       //Methods - actions of an animal
       void Eat() { cout << "Eating.";  }
       void Reproduce() { cout << "Reproducing."; }
       void Move() { cout << "Moving."; }

       private:
       bool hungry;
       int age;
       int weight;
       int SensoryOrgan;  
}

In the same way, an Employee object's "has-a" relationship would consist of the attributes: Social Security Number, Name, Age, Pay Rate, etc.  Its methods might consist of: Hire(), Fire(), PayRaise(), setSSN(), etc.

II. The "Is-a" Relationship

In the "is-a" relationship, objects that are grouped into larger, macroscopic classifications are broken down in to smaller and smaller groups.  A Cat object is a Mammal object, a Mammal object is an Animal object.  Derivation is a way of explaining the "is-a" relationship.  The Iguana class would inherit from the Reptile class,  and the Reptile class from the Animal class.  As an illustration, you don't have to state explicitly that Dogs move, eat, or reproduce - they inherit that from Mammal.  We might later choose to override these Mammal methods with ones more specific to Dog, but Dog inherits these methods in basic form built-in from its base class, Mammal.  A class that adds new functionality to an existing class is said to "derive" from that class.  The original class is said to be the new class's "base class".  In Java, they would be called subclass and superclass - in C++, base class and derived class.  Typically a base class has more than 1 derived class. 

Many of the examples in this section, due to lack of space and time and for the sake of brevity, use what is referred to as "stubbing out".  This is writing only enough code to show that the function was called and leaving the details for later when you have more time.  This is one way in which you can build scaffolding for your applications, around which you will later construct the entire program.

When declaring a class, indicate what class it derives from by writing a colon after the class name, the type of derivation (public, private or protected), and the class from which it derives.   Example: class Dog : public Mammal .  The class from which you derive must have been declared earlier in your code or you will get a compiler error for trying to derive from a class that the compiler does not know exists.  Example:

No Output.

In this first example, the Monster class declared.  In C++ you can represent only a fraction of the information needed to represent reality, reality is far too complex to include both every base and derived class of Monster, so you include only those that will map back to reality reasonably well. In this case, the Giant class inherits from Monster.  Every Giant object will have 3 member variables: itsAge, itsWeight, and itsBreed - the combination of the data members of the base and derived class.  The class declaration for Giant does not include itsAge and itsWeight, it inherits these from Monster along with all of Monster's methods except the copy constructor, constructor and destructor.  This brings us to the inevitable discussion of three type of inheritance - that is to say three type of derivation:

1) public - Public data members and methods are available to all classes, both derived and non-derived.  They may be accessed without accessor methods.  Because of this, though easiest to code and debug, this is the least preferred method to code inheritance. 
2) protected - Protected data members are available to derived classes without having to use accessor methods, but they are not available to any other classes that have not derived specifically from the base class declaring its member to be protected.
3) private - Private data members are not available to derived classes.  If there is a public accessor method available in the base class, the derived class may use it to manipulate private data members.  If not, the base class private data members and methods are simply unavailable.

Output:

In this example, Employee is the base class and Manager derives from Employee.  We can see that when we instantiate the Employee object, CharlesGermany, that is may use all of the methods and data members of the Employee class.  CharlesGermany may not, however, use any of the manager methods or members.  Inheritance flows from the parent to the child, not vice versa.  On the other hand, the Manager class derives from the Employee class.  In this case it can use both the methods and members of the Manager class and the Employee class.   Notice that each time a Manager is created, and Employee is created as well.  Calling the Manager constructor calls the Employee constructor.  It is the same with destructors.  Notice that as the program ends, it calls the destructor for both a Manager object and an Employee object, then it calls the destructor for and Employee object.  This is the reverse order which the constructors were called in as the objects were created.  This LIFO (Last In First Out) illustrates the storage method of objects on the stack.

Passing arguments to base constructors - In the case of the Mammal class, you may want to overload the Mammal constructor to take a specific age and the Dog constructor to take a breed.  What if Cats want to initialize weight, yet Mammals don't?  Base class initialization can be performed during class initialization by writing the base class name followed by the parameters expected by the base class.   Example:

In this case, Cat's default constructor calls Mammal's default constructor.  We call the base class constructor which takes no parameters in order to supply default values for Cat's base class member variables.  All of this overloading in the midst of inheritance brings us to the process of overriding functions.

©2004 C. Germany