🧬 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.