Inheritance was introduced into C++ for several reasons. Of course, the major reason is the capability of expressing the inheritance relationship. (I'll return to that in a moment.) A minor reason is to reduce the amount of typing. Suppose that you have a class Student, and you're asked to add a new class called GraduateStudent. Inheritance can drastically reduce the number of things you have to put in the class. All you really need in the class GraduateStudent are things that describe the differences between students and graduate students.

Another minor side effect has to do with software modification. Suppose you inherit from some existing class. Later, you find that the base class doesn't do exactly what the subclass needs. Or perhaps the class has a bug. Modifying the base class might break any code that uses that base class. Creating and using a new subclass that overloads the incorrect feature solves your problem without causing someone else further problems.

Here's the GraduateStudent example filled out into a program InheritanceExample:

//
//  InheritanceExample - demonstrate an inheritance
//               relationship in which the subclass
//               constructor passes argument information
//               to the constructor in the base class
//
#include <cstdio>
#include <cstdlib>
#include <iostream>

using namespace std;
class Advisor {}; // define an empty class

class Student
{
  public:
    Student(const char *pName = "no name")
       : name(pName), average(0.0), semesterHours(0)
    {
        cout << "Constructing student " << name << endl;
    }

    void addCourse(int hours, float grade)
    {
        cout << "Adding grade to " << name << endl;
        average = semesterHours * average + grade;
        semesterHours += hours;
        average = average / semesterHours;
     }

     int hours( ) { return semesterHours;}
     float gpa( ) { return average;}

   protected:
     string name;
     double average;
     int    semesterHours;
 };

 class GraduateStudent : public Student
 {
   public:
     GraduateStudent(const char *pName, Advisor adv,
                     double qG = 0.0)
         : Student(pName), advisor(adv), qualifierGrade(qG)
    {
         cout << "Constructing graduate student "
              << pName << endl;
    }

    double qualifier( ) { return qualifierGrade; }

  protected:
    Advisor advisor;
    double qualifierGrade;
};

int main(int nNumberofArgs, char* pszArgs[])
{
    // create a dummy advisor to give to GraduateStudent
    Advisor adv;

    // create two Student types
    Student llu("Cy N Sense");

GraduateStudent gs("Matt Madox", adv, 1.5);

    // now add a grade to their grade point average
    llu.addCourse(3, 2.5);
    gs.addCourse(3, 3.0);

    // display the graduate student's qualifier grade
    cout << "Matt's
         << gs.qualifier() << endl;

    // wait until user is ready before terminating program
    // to allow the user to see the program results
    system("PAUSE");
    return 0;
}

This program demonstrates the creation and use of two objects, one of class Student and a second of GraduateStudent. The output of this program is as follows:

Constructing student Cy N Sense
Constructing student Matt Madox
Constructing graduate student Matt Madox
Adding grade to Cy N Sense
Adding grade to Matt Madox
Matt's qualifier grade = 1.5
Press any key to continue...

GraduateStudent(const char *pName, Advisor adv,
                double qG = 0.0)
    : Student(pName), advisor(adv), qualifierGrade(qG)
{
    // whatever else the constructor does
}

class Pig
{
  public:
    Pig() : pHouse(nullptr) {}
  protected:
    House* pHouse;
};
class LittlePig : public Pig
{
  public:
    LittlePig(double volStraw, int numSticks,
              int numBricks)
      : straw(volStraw), sticks(numSticks),
        bricks(numBricks)
    { }

  protected:
    double straw;
     int sticks;
     int bricks;
};

Notice that the class GraduateStudent includes the members of class Student and Advisor, but in a different way. By defining a data member of class Advisor, you know that a Student has all the data members of an Advisor within it. However, you can't say that a GraduateStudent is an Advisor – instead you say that a GraduateStudent HAS_A Advisor. What's the difference between this and inheritance?

Use a car as an example. You could logically define a car as being a subclass of vehicle, so it inherits the properties of other vehicles. At the same time, a car has a motor. If you buy a car, you can logically assume that you are buying a motor as well. (Unless you go to the used-car lot where I got my last junk heap.)

If friends ask you to show up at a rally on Saturday with your vehicle of choice and you go in your car, they can't complain (even if someone else shows up on a bicycle) because a car IS_A vehicle. But, if you appear on foot carrying a motor, your friends will have reason to laugh at you because a motor is not a vehicle. A motor is missing certain critical properties that vehicles share – such as radios without AUX plugs for your MP-3 player.

From a programming standpoint, the HAS_A relationship is just as straightforward. Consider the following:

class Vehicle {};
class Motor {};
class Car : public Vehicle
{
  public:
    Motor motor;
};

void VehicleFn(Vehicle& v);
void MotorFn(Motor& m);

int main(int nNumberofArgs, char* pszArgs[])
{
    Car car;
    VehicleFn(car);    // this is allowed
    MotorFn(car);      // this is not allowed
    MotorFn(car.motor);// this is
    return 0;
}

The call VehicleFn(c) is allowed because car IS_A vehicle. The call MotorFn(car) is not because car is not a Motor, even though it contains a Motor. If the intention were to pass the Motor portion of c to the function, this must be expressed explicitly, as in the call MotorFn(car.motor).