Write a program to implement hybrid inheritance using virtual base classes

🔷 Hybrid Inheritance in C++ Using Virtual Base Classes

In C++, inheritance is a powerful feature that helps achieve code reusability and polymorphism. While single and multilevel inheritance are straightforward, hybrid inheritance can lead to ambiguity if not handled carefully. This is where virtual base classes come into play.

✅ What is Hybrid Inheritance?

Hybrid inheritance is a combination of two or more types of inheritance, multiple, multilevel, hierarchical, or single, within the same program.

A common hybrid inheritance scenario:

       Person

       /    \

   Student  Employee

       \    /

     Intern

Here, `Intern` inherits from both `Student` and `Employee`, which both inherit from the base class `Person`. This setup leads to ambiguity, especially when accessing members of the base class, because they are inherited multiple times.

🧠 Problem of Ambiguity

Without precautions, the compiler doesn’t know which version of the base class’s members to use. To fix this, we use virtual inheritance.

🧪 What are Virtual Base Classes?

A virtual base class ensures that only one instance of the base class is inherited, even if it is inherited multiple times indirectly.

class Student : virtual public Person { ... };

class Employee : virtual public Person { ... };

Now, even though `Intern` inherits from both `Student` and `Employee`, it will only have one shared instance of `Person`.

🧑‍💻 C++ Program Demonstrating Hybrid Inheritance

#include <iostream>

using namespace std;

// Base class

class Person {

public:

    void displayPerson() {

        cout << "I am a person." << endl;

    }

};

// First derived class using virtual inheritance

class Student : virtual public Person {

public:

    void displayStudent() {

        cout << "I am a student." << endl;

    }

};

// Second derived class using virtual inheritance

class Employee : virtual public Person {

public:

    void displayEmployee() {

        cout << "I am an employee." << endl;

    }

};

// Final derived class inheriting from both Student and Employee

class Intern : public Student, public Employee {

public:

    void displayIntern() {

        cout << "I am an intern." << endl;

    }

};

int main() {

    Intern i;

    i.displayPerson();    // No ambiguity due to virtual inheritance

    i.displayStudent();

    i.displayEmployee();

    i.displayIntern();

    return 0;

}

🖨️ Output

I am a person.

I am a student.

I am an employee.

I am an intern.

📝 Explanation

• The base class `Person` is inherited virtually by both `Student` and `Employee`.
• The class `Intern` inherits from both `Student` and `Employee`, forming a hybrid structure.
• Using virtual inheritance, only one instance of `Person` exists in `Intern`.
• This avoids ambiguity and ensures a clean class structure.

🎯 Conclusion

Hybrid inheritance is useful when designing complex systems with overlapping responsibilities, such as combining roles like `Student`, `Employee`, or `Volunteer`. However, it introduces the problem of ambiguity, which can be solved efficiently using virtual base classes.