C++ Program to Implement Multiple Inheritance

Introduction

In the world of object-oriented programming, inheritance is a powerful concept that allows the creation of a new class based on an existing class. Multiple inheritance, where a class can inherit from more than one base class, is a unique feature of C++ that can be particularly useful in modeling complex relationships. In this article, we’ll explore how to implement multiple inheritance using Person and Employee classes in C++. We’ll walk through the prerequisites, examine various examples, and explain the intricacies of each approach.

Prerequisites

Before we dive into the code, it’s essential to have a basic understanding of:

1. C++ Programming Language: Familiarity with basic syntax, classes, and inheritance.
2. Object-Oriented Programming (OOP): Understanding of fundamental OOP concepts like classes, objects, and inheritance.
3. Standard Library Functions: Knowledge of C++ Standard Library functions and header files.

With these prerequisites in mind, let’s explore different ways to implement multiple inheritance using the Person and Employee classes.

Example 1: Basic Multiple Inheritance

Code Explanation

In this example, we will create a Person class and an Employee class. Then, we will create a Manager class that inherits from both Person and Employee.

Code

#include <iostream>
#include <string>
using namespace std;

class Person {
public:
    string name;
    int age;
    void displayPersonInfo() {
        cout << "Name: " << name << ", Age: " << age << endl;
    }
};

class Employee {
public:
    int employeeID;
    double salary;
    void displayEmployeeInfo() {
        cout << "Employee ID: " << employeeID << ", Salary: " << salary << endl;
    }
};

class Manager : public Person, public Employee {
public:
    string department;
    void displayManagerInfo() {
        displayPersonInfo();
        displayEmployeeInfo();
        cout << "Department: " << department << endl;
    }
};

int main() {
    Manager manager;
    manager.name = "Alice";
    manager.age = 30;
    manager.employeeID = 12345;
    manager.salary = 75000.0;
    manager.department = "HR";

    manager.displayManagerInfo();

    return 0;
}

Output

Name: Alice, Age: 30
Employee ID: 12345, Salary: 75000
Department: HR

Explanation

In this example, the Manager class inherits from both Person and Employee. The Manager class has access to the properties and methods of both base classes. The displayManagerInfo method demonstrates how to access and display information from both Person and Employee.

Example 2: Resolving Ambiguities in Multiple Inheritance

Code Explanation

Multiple inheritance can sometimes lead to ambiguities, especially when the base classes have methods with the same name. In this example, we will resolve such ambiguities.

Code

#include <iostream>
#include <string>
using namespace std;

class Person {
public:
    string name;
    void displayInfo() {
        cout << "Name: " << name << endl;
    }
};

class Employee {
public:
    int employeeID;
    void displayInfo() {
        cout << "Employee ID: " << employeeID << endl;
    }
};

class Manager : public Person, public Employee {
public:
    void displayManagerInfo() {
        Person::displayInfo();
        Employee::displayInfo();
    }
};

int main() {
    Manager manager;
    manager.name = "Bob";
    manager.employeeID = 67890;

    manager.displayManagerInfo();

    return 0;
}

Output

Name: Bob
Employee ID: 67890

Explanation

In this example, both Person and Employee classes have a method named displayInfo. To resolve the ambiguity, we explicitly specify which base class’s method to call using the scope resolution operator (::). This ensures that the correct method is called for each part of the Manager class.

Example 3: Using Virtual Inheritance

Code Explanation

Virtual inheritance is a technique used to prevent multiple “instances” of a base class when using multiple inheritance. This is particularly useful when dealing with complex inheritance hierarchies.

Code

#include <iostream>
#include <string>
using namespace std;

class Person {
public:
    string name;
    int age;
    void displayPersonInfo() {
        cout << "Name: " << name << ", Age: " << age << endl;
    }
};

class Employee : virtual public Person {
public:
    int employeeID;
    double salary;
    void displayEmployeeInfo() {
        cout << "Employee ID: " << employeeID << ", Salary: " << salary << endl;
    }
};

class Manager : public Employee {
public:
    string department;
    void displayManagerInfo() {
        displayPersonInfo();
        displayEmployeeInfo();
        cout << "Department: " << department << endl;
    }
};

int main() {
    Manager manager;
    manager.name = "Charlie";
    manager.age = 40;
    manager.employeeID = 11223;
    manager.salary = 90000.0;
    manager.department = "IT";

    manager.displayManagerInfo();

    return 0;
}

Output

Name: Charlie, Age: 40
Employee ID: 11223, Salary: 90000
Department: IT

Explanation

In this example, the Employee class inherits from Person using virtual inheritance. This ensures that there is only one instance of Person in the Manager class, even though it inherits from Employee. This approach is particularly useful in more complex inheritance hierarchies to avoid redundancy and ambiguity.

Conclusion

Multiple inheritance in C++ is a powerful feature that allows a class to inherit from more than one base class. Through the examples provided, we’ve seen different ways to implement multiple inheritance, including basic inheritance, resolving method ambiguities, and using virtual inheritance to prevent redundancy