C++ Inheritance – Multiple & Multilevel Inheritance Explained

Introduction – Why Inheritance Matters in C++

Inheritance is a core pillar of object-oriented programming in C++, allowing one class to acquire the properties and behavior of another. This enables code reuse, scalability, and a clear hierarchy structure. C++ supports multiple and multilevel inheritance, giving it more flexibility than many other OOP languages.

In this guide, you’ll learn:

• What inheritance is and its syntax
• Types of inheritance: single, multiple, and multilevel
• How to use protected and constructors in inheritance
• Best practices with real-world use cases

What Is Inheritance in C++?

Inheritance allows a new class (derived/child) to acquire members (data and functions) from an existing class (base/parent). This allows the derived class to:

• Extend the base class with additional features
• Override base class behavior

Code Examples – With Output

Example 1: Single Inheritance

#include <iostream>
using namespace std;

class Animal {
public:
    void speak() {
        cout << "Animal speaks" << endl;
    }
};

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

int main() {
    Dog d;
    d.speak();
    d.bark();
    return 0;
}

Output:

Animal speaks
Dog barks

Multilevel Inheritance

A class is derived from a derived class—forming a chain.

Example 2: Multilevel Inheritance

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

class Mammal : public Animal {
public:
    void breathe() {
        cout << "Breathing..." << endl;
    }
};

class Dog : public Mammal {
public:
    void bark() {
        cout << "Barking..." << endl;
    }
};

int main() {
    Dog d;
    d.eat();
    d.breathe();
    d.bark();
    return 0;
}

Output:

Eating...
Breathing...
Barking...

Multiple Inheritance

C++ allows a class to inherit from more than one class.

Example 3: Multiple Inheritance

class A {
public:
    void displayA() {
        cout << "Class A" << endl;
    }
};

class B {
public:
    void displayB() {
        cout << "Class B" << endl;
    }
};

class C : public A, public B {
public:
    void displayC() {
        cout << "Class C" << endl;
    }
};

int main() {
    C obj;
    obj.displayA();
    obj.displayB();
    obj.displayC();
    return 0;
}

Output:

Class A
Class B
Class C

Inheritance Types in C++

Best Practices & Tips

Best Practice: Always declare destructors in base classes as virtual if inheritance is used.

Tip: Use protected access when you want to allow derived classes to access members, but not external code.

Pitfall: Be cautious with multiple inheritance—name conflicts can lead to ambiguity.

Real-World Use Cases

Vehicle Systems: Vehicle → Car → ElectricCar (multilevel)
Game Engines: Entity → Player, Entity → Enemy (hierarchical)
UI Frameworks: Widget → Button, Label, Image
AI Systems: Algorithm → MachineLearning → DeepLearning

Summary – Recap & Next Steps

Key Takeaways:

• Inheritance allows classes to reuse and extend behavior
• C++ supports powerful multiple and multilevel inheritance
• Use virtual destructors and handle ambiguity in multiple inheritance carefully

Real-World Relevance:
C++ inheritance powers simulation systems, GUI toolkits, compilers, and design frameworks.

Next Steps:

• Learn about Polymorphism in C++
• Explore Virtual Functions & Runtime Behavior

FAQ – C++ Inheritance

Can a class inherit from more than one base class?
Yes. Use multiple inheritance like class C : public A, public B.

What is the difference between public, protected, and private inheritance?
Public keeps base members’ access unchanged. Protected makes them protected. Private makes them private in the derived class.

Does C++ support multilevel inheritance?
Yes. You can create a chain of derived classes like C → B → A.

Is virtual inheritance different?
Yes. It avoids ambiguity in diamond inheritance (covered in advanced OOP).

Should base class destructors be virtual?
Yes, especially when deleting derived objects via base class pointers.