Inheritance

In Lesson 13 you met the idea: one of the four pillars of object-oriented programming is inheritance. It lets a new class reuse the members of a class that already exists, instead of writing them all over again. The class that is inherited from is the base class (also called the parent class). The class that inherits is the derived class (also called the child class). Write the shared behaviour once, inherit it everywhere you need it.

What Is Inheritance?

A dog eats and sleeps, and so does a cat. Instead of writing eat() and sleep() inside both classes, write them once in an Animal class and let Dog and Cat inherit them. The derived class gets everything the base class has — and can add its own members on top:

#include <iostream>

class Animal {
public:
    void eat() { std::cout << "Eating..." << std::endl; }
    void sleep() { std::cout << "Sleeping..." << std::endl; }
};

class Dog : public Animal {
public:
    void bark() { std::cout << "Woof!" << std::endl; }
};

int main() {
    Dog dog;
    dog.eat();
    dog.sleep();
    dog.bark();
    return 0;
}

Eating...
Sleeping...
Woof!

The line class Dog : public Animal is the whole trick: the colon and the word public say that Dog inherits from Animal. A Dog object can call eat() and sleep() even though those functions were only written in Animal.

The Syntax — public, protected, private Inheritance

The word after the colon chooses how the base class members arrive in the derived class. There are three forms, but in practice you will use public inheritance almost always — it is the only form that keeps the is-a relationship true:

Notice that private members of the base are never accessible to the derived class — no form of inheritance opens them. That is what protected is for: a member marked protected is private to the outside world, but the derived class can use it:

#include <iostream>

class Animal {
protected:
    int legs = 4;
public:
    void showLegs() { std::cout << "Legs: " << legs << std::endl; }
};

class Dog : public Animal {
public:
    void run() { std::cout << "Running on " << legs << " legs." << std::endl; }
};

int main() {
    Dog dog;
    dog.run();
    dog.showLegs();
    return 0;
}

Running on 4 legs.
Legs: 4

The derived class reads legs directly, but code in main cannot write dog.legs — that would not compile, because protected is still closed to the outside.

Constructors and Destructors in Inheritance

When a derived object is created, the base constructor runs first, then the derived constructor. When the object dies, the order reverses: the derived destructor runs first, then the base destructor. Base first in, last out:

#include <iostream>

class Animal {
public:
    Animal() { std::cout << "Animal constructed." << std::endl; }
    ~Animal() { std::cout << "Animal destroyed." << std::endl; }
};

class Dog : public Animal {
public:
    Dog() { std::cout << "Dog constructed." << std::endl; }
    ~Dog() { std::cout << "Dog destroyed." << std::endl; }
};

int main() {
    Dog dog;
    return 0;
}

Animal constructed.
Dog constructed.
Dog destroyed.
Animal destroyed.

If the base constructor needs arguments, the derived constructor passes them with an initializer list: Dog(std::string n) : Animal(n) {}. The base is always built before the derived class adds its own part.

Overriding — A Child Can Replace a Parent's Function

A derived class can define its own version of a base class function. That is called overriding. For a derived object, the derived version wins:

#include <iostream>

class Animal {
public:
    void speak() { std::cout << "Some sound." << std::endl; }
};

class Dog : public Animal {
public:
    void speak() { std::cout << "Woof!" << std::endl; }
};

class Cat : public Animal {
public:
    void speak() { std::cout << "Meow!" << std::endl; }
};

int main() {
    Animal animal;
    Dog dog;
    Cat cat;
    animal.speak();
    dog.speak();
    cat.speak();
    return 0;
}

Some sound.
Woof!
Meow!

Types of Inheritance

Inheritance comes in several shapes. You will use single and hierarchical inheritance the most; multiple inheritance is possible in C++ but needs care, because two bases can both bring the same member (the diamond problem).

Common Mistakes with Inheritance