Multiple inheritance allows a class to inherit from more than one parent class. This enables a derived class to inherit members from multiple base classes. However, multiple inheritance also introduces several problems including ambiguity when multiple parent classes contain methods with the same name, and the "diamond problem" where a class inherits from two parents that both inherit from the same grandparent class. Explicitly specifying which parent class's method to call can resolve naming conflicts, but complexity increases exponentially with more inherited classes. Overall, multiple inheritance improves code reuse but is prone to issues that make programs harder to understand and maintain.

1. Multiple Inheritance

2. Multiple Inheritance
• If a class is derived from two or more base classes then it is called
multiple inheritance. In C++ multiple inheritance a derived class
has more than one base class.
• Multiple inheritance enables a derived class to inherit members
from more than one parent.

3. Difference in Multipe Inheritance & Multilevel
Inheritance
• Though but multiple and multilevel sounds like same but they
differ hugely in meaning. In multilevel inheritance, we have
multiple parent classes whereas in in multiple inheritance we have
multiple base classes.
• To put it in simple words, in multilevel inheritance, a class is
derived from a class which is also derived from another base class.
And these levels of inheritance can be extended. On the contrary,
in multiple inheritance, a class is derived from two different base
classes.

4. For example
• Multilevel inheritance : Inheritance of characters by a
child from father and father inheriting characters from
his father (grandfather)
• Multiple inheritance : Inheritance of characters by a
child from mother and father

5. C++ Multiple Inheritance Block Diagram

6. C++ Multiple Inheritance Syntax
• class A
• {
• ..........
• };
• class B
• {
• ...........
• } ;
• class C : acess_specifier A,access_specifier A // derived class from A and B
• {
• ...........
• } ;

7. C++ Multiple Inheritance Example
#include
using namespace std;
class A
{public:
int x;
void getx()
{
cout << "enter value of x: "; cin >>
x;
}
};
class B
{
public:
int y;
void gety()
{
cout << "enter value of y: "; cin
>> y;
}
};

8. C++ Multiple Inheritance Example
class C : public A, public B //C is
derived from class A and class B
{
public:
void sum()
{cout << "Sum = " << x + y;
}
};
int main()
{
C obj1; //object of derived class C
obj1.getx();
obj1.gety();
obj1.sum();
return 0;
} //end of program

9. C++ Multiple Inheritance Example
Output
enter value of x: 5
enter value of y: 4
Sum = 9

10. C++ Multiple Inheritance Example 2
Let’s say we wanted to write a program to keep track of a
bunch of teachers. A teacher is a person. However, a
teacher is also an employee (they are their own employer
if working for themselves). Multiple inheritance can be
used to create a Teacher class that inherits properties
from both Person and Employee. To use multiple
inheritance, simply specify each base class (just like in
single inheritance), separated by a comma.

11. C++ Multiple Inheritance Example 2

12. C++ Multiple Inheritance Example 2
• std::string getName() { return m_name; }
• int getAge() { return m_age; }
• };
• class Employee
• {
• private:
• std::string m_employer;
• double m_wage;
• public:
• Employee(std::string employer, double wage)
• : m_employer(employer), m_wage(wage)
• {
• }
#include <string>
class Person
{
private:
std::string m_name;
int m_age;
public:
Person(std::string name, int age)
: m_name(name), m_age(age)
{
}

13. C++ Multiple Inheritance Example 2
public:
Teacher(std::string name, int age,
std::string employer, double wage, int
teachesGrade)
: Person(name, age), Employee(employer,
wage), m_teachesGrade(teachesGrade)
{
}
};
std::string getEmployer() { return
m_employer; }
double getWage() { return m_wage; }
};
// Teacher publicly inherits Person and
Employee
class Teacher: public Person, public
Employee
{
private:
int m_teachesGrade;

14. Problems with multiple inheritance
• While multiple inheritance seems like a simple extension
of single inheritance, multiple inheritance introduces a
lot of issues that can markedly increase the complexity
of programs and make them a maintenance nightmare.
Let’s take a look at some of these situations.
• First, ambiguity can result when multiple base classes contain a
function with the same name. For example:

15. Problems with multiple inheritance
Example
• long getID() { return m_id; }
• };
• class NetworkDevice
• {
• private:
• long m_id;
• public:
• NetworkDevice(long id)
• : m_id(id) {
• }
•
#include <iostream>
class USBDevice
{
private:
long m_id;
public:
USBDevice(long id)
: m_id(id)
{
}

16. Problems with multiple inheritance
Example
{
}
};
int main()
{
WirelessAdapter c54G(5442, 181742);
std::cout << c54G.getID(); // Which
getID() do we call?
return 0;
}
long getID() { return m_id; }
};
class WirelessAdapter: public
USBDevice, public
NetworkDevice
{
public:
WirelessAdapter(long usbId,
long networkId)
: USBDevice(usbId),
NetworkDevice(networkId)

17. Problems with multiple inheritance
Example
• When c54G.getID() is compiled, the compiler looks to see if
WirelessAdapter contains a function named getID(). It doesn’t.
The compiler then looks to see if any of the parent classes have a
function named getID(). See the problem here? The problem is
that c54G actually contains TWO getID() functions: one inherited
from USBDevice, and one inherited from NetworkDevice.
Consequently, this function call is ambiguous, and you will receive
a compiler error if you try to compile it.

18. Solution
• However, there is a way to work around this problem: you can
explicitly specify which version you meant to call:
int main()
{
WirelessAdapter c54G(5442, 181742);
std::cout << c54G.USBDevice::getID();
return 0;
}

19. Solution
• While this workaround is pretty simple, you can see how things
can get complex when your class inherits from four or six base
classes, which inherit from other classes themselves. The
potential for naming conflicts increases exponentially as you
inherit more classes, and each of these naming conflicts needs to
be resolved explicitly.

20. Diamond Problem
• Second, and more serious is the diamond problem, which your
author likes to call the “diamond of doom”. This occurs when a
class multiply inherits from two classes which each inherit from a
single base class. This leads to a diamond shaped inheritance
pattern.

21. Diamond Problem Example