Inheritance in C++

 Inheritance is a key feature of object-oriented programming (OOP) in C++, allowing one class (called the derived or child class) to inherit properties and behavior (data members and member functions) from another class (called the base or parent class). It promotes reusability, modularity, and helps in maintaining and organizing large codebases.

Key Concepts:

1. Base Class (Parent Class): The class whose properties (data members and functions) are inherited by another class.
2. Derived Class (Child Class): The class that inherits the properties of the base class.

Benefits of Inheritance:

• Code Reusability: A derived class can use functions and members of the base class without rewriting the code.
• Extensibility: New features and functions can be added to the existing class without altering the original code.
• Modularity: It allows complex systems to be broken into smaller, manageable components.

---

Types of Inheritance:

1. Single Inheritance
2. Multiple Inheritance
3. Multilevel Inheritance
4. Hierarchical Inheritance
5. Hybrid Inheritance

---

1. Single Inheritance

In single inheritance, a derived class inherits from only one base class. It represents a simple parent-child relationship.

Example:

#include <iostream>

using namespace std;

// Base class

class Animal {

public:

    void eat() {

        cout << "Eating..." << endl;

    }

};

// Derived class

class Dog : public Animal {

public:

    void bark() {

        cout << "Barking..." << endl;

    }

};

int main() {

    Dog d;

    d.eat();  // Inherited from Animal

    d.bark(); // Defined in Dog

    return 0;

}

In this example, the Dog class inherits the eat() function from the Animal class and adds its own behavior bark().

---

2. Multiple Inheritance

In multiple inheritance, a derived class inherits from more than one base class. This allows the derived class to have properties of multiple base classes.

Example:

#include <iostream>

using namespace std;

// Base class 1

class Father {

public:

    void showFather() {

        cout << "Father's property" << endl;

    }

};

// Base class 2

class Mother {

public:

    void showMother() {

        cout << "Mother's property" << endl;

    }

};

// Derived class

class Child : public Father, public Mother {

public:

    void showChild() {

        cout << "Child's property" << endl;

    }

};

int main() {

    Child c;

    c.showFather();  // Inherited from Father

    c.showMother();  // Inherited from Mother

    c.showChild();   // Defined in Child

    return 0;

}

Here, Child class inherits properties from both Father and Mother classes.

---

3. Multilevel Inheritance

In multilevel inheritance, a class is derived from another derived class. This creates a chain of inheritance.

Example:

#include <iostream>

using namespace std;

// Base class

class Animal {

public:

    void eat() {

        cout << "Eating..." << endl;

    }

};

// Derived class 1

class Dog : public Animal {

public:

    void bark() {

        cout << "Barking..." << endl;

    }

};

// Derived class 2

class Puppy : public Dog {

public:

    void weep() {

        cout << "Weeping..." << endl;

    }

};

int main() {

    Puppy p;

    p.eat();   // Inherited from Animal

    p.bark();  // Inherited from Dog

    p.weep();  // Defined in Puppy

    return 0;

}

In this example, the Puppy class inherits from the Dog class, which in turn inherits from the Animal class, creating a multilevel inheritance structure.

---

4. Hierarchical Inheritance

In hierarchical inheritance, multiple derived classes inherit from a single base class. It represents a tree-like structure where several child classes share a common parent class.

Example:

#include <iostream>

using namespace std;

// Base class

class Animal {

public:

    void eat() {

        cout << "Eating..." << endl;

    }

};

// Derived class 1

class Dog : public Animal {

public:

    void bark() {

        cout << "Barking..." << endl;

    }

};

// Derived class 2

class Cat : public Animal {

public:

    void meow() {

        cout << "Meowing..." << endl;

    }

};

int main() {

    Dog d;

    d.eat();   // Inherited from Animal

    d.bark();  // Defined in Dog

    Cat c;

    c.eat();   // Inherited from Animal

    c.meow();  // Defined in Cat

    return 0;

}

In this example, both Dog and Cat classes inherit from the Animal class, sharing the common functionality of eat().

---

5. Hybrid Inheritance

Hybrid inheritance is a combination of two or more types of inheritance. This can include single, multiple, multilevel, or hierarchical inheritance in any combination. It often leads to a diamond problem, where an ambiguity can arise if the same base class is inherited more than once via different paths. This is resolved in C++ by virtual inheritance.

Example (Showing Diamond Problem):

#include <iostream>

using namespace std;

// Base class

class Animal {

public:

    void eat() {

        cout << "Eating..." << endl;

    }

};

// Derived class 1

class Dog : public Animal {};

// Derived class 2

class Cat : public Animal {};

// Derived class 3 inherits from both Dog and Cat

class Puppy : public Dog, public Cat {};

int main() {

    Puppy p;

    // p.eat();  // Ambiguity: Which 'eat()' to call (from Dog or Cat)?

    return 0;

}

Summary of Inheritance Types:

1. Single Inheritance: One class inherits from one base class.
2. Multiple Inheritance: One class inherits from multiple base classes.
3. Multilevel Inheritance: A chain of inheritance, where a derived class is further inherited.
4. Hierarchical Inheritance: Multiple derived classes inherit from a single base class.
5. Hybrid Inheritance: A combination of two or more inheritance types, potentially leading to the diamond problem, resolved by virtual inheritance.

Inheritance is fundamental to object-oriented programming, helping to model real-world relationships, promote code reuse, and manage complexity in software systems.