Multiple Inheritance and Virtual Base Classes

In the introductory course, we covered inheritance, which allowed us to declare our class as a child of some other class. In the following example, Human inherits from Character:

1class Character {};
2class Human : public Character{};

C++ supports multiple inheritance. This allows our classes to have multiple base classes. We separate base classes using a comma:

1class Human {};
2
3class Elf {};
4
5class HalfElf : public Human, public Elf {};

With this setup, any HalfElf object will inherit the functions and variables of both the Human and Elf class.

Multiple inheritance sounds like a powerful concept, but it has some problems. Two of the most immediate ones are naming conflicts and the diamond problem, which we’ll cover next.

Naming Conflicts

The first problem that can arise with multiple inheritance is that two (or more) of the base classes can have functions or variables with the same name. Below, we demonstrate this with a variable called Agility:

1#include <iostream>
2
3class Human {
4public:
5  int Agility{8};
6};
7
8class Elf {
9public:
10  int Agility{10};
11};
12
13class HalfElf : public Human, public Elf {};
14
15int main(){
16  HalfElf Elrond;
17  std::cout << "Elrond Agility: "
18    << Elrond.Agility;
19}

In this scenario, does Elrond have the agility of a Human, or of an Elf?

Turns out, he has both, and the compiler throws an error because we haven’t specified which value we want

1error C2385: ambiguous access of 'Agility'
2could be the 'Agility' in base 'Human'
3or could be the 'Agility' in base 'Elf'

There are two common ways we specify which variable or function we want to use:

• Through the scope resolution operator, ::
• through a call to static_cast

The following example demonstrates both:

1#include <iostream>
2
Unchanged Code|Show
3class Human {/*...*/}
8
Unchanged Code|Show
9class Elf {/*...*/}
14
15class HalfElf : public Human, public Elf {};
16
17int main(){
18  HalfElf Elrond;
19  std::cout << "Elrond Agility (Human): "
20    << Elrond.Human::Agility;
21  std::cout << "\nElrond Agility (Elven): "
22    << static_cast<Elf&>(Elrond).Agility;
23}

1Elrond Agility (Human): 8
2Elrond Agility (Elven): 10

The Diamond Problem

The second issue that can occur with multiple inheritance is the so-called diamond problem.

This happens when a class inherits the same base class multiple times, through different paths. It’s called the diamond problem, because the simplest variation of it involves a class inheriting from two classes, and each of those classes inheriting from the same base class.

This creates a class hierarchy that looks like a diamond:

In code, it looks like this:

1class Character {};
2
3class Human : public Character {};
4
5class Elf : public Character {};
6
7class HalfElf : public Human, public Elf {};

Let's consider the previous Agility problem, now converted to a diamond hierarchy:

1#include <iostream>
2
3class Character {
4public:
5  Character(int Agility) : Agility{Agility}{}
6  int Agility;
7};
8
9class Human : public Character {
10public:
11  Human() : Character(8){}
12};
13
14class Elf : public Character {
15public:
16  Elf() : Character(10){}
17};
18
19class HalfElf : public Human, public Elf {};
20
21int main(){
22  HalfElf Elrond;
23  std::cout << "Elrond Agility: "
24    << Elrond.Agility;
25}

We now have the same problem - the attempt to retrieve Agility needs to be clarified. This time, the error message isn’t so helpful:

1ambiguous access of 'Agility'
2could be the 'Agility' in base 'Character'
3or could be the 'Agility' in base 'Character'

The problem is, we are now inheriting from Character twice. The "diamond" naming is somewhat misleading because our class hierarchy is more like this:

We can still specify which Agility we want, by specifying the intermediate class, in the same way as before:

1#include <iostream>
2
Unchanged Code|Show
3class Character {/*...*/}

1Elrond Agility (Human): 8
2Elrond Agility (Elven): 10

But, we rarely want to be inheriting the same class twice, so usually we want to do something else instead. Typically, we want virtual inheritance.

Virtual Base Classes

When implementing inheritance, we can specify that we want to use a virtual base class:

1class Character {
2public:
3  Character(int Agility) : Agility{Agility}{}
4  int Agility;
5};
6
7class Human : virtual public Character {
8public:
9  Human() : Character(8){}
10};
11
12class Elf : virtual public Character {
13public:
14  Elf() : Character(10){}
15};

When we instantiate a class that uses virtual inheritance directly, everything works as normal:

1#include <iostream>
2
Unchanged Code|Show
3class Character {/*...*/}
9
Unchanged Code|Show
10class Human : virtual public Character {/*...*/}
15
Unchanged Code|Show
16class Elf : virtual public Character {/*...*/}
21
22int main(){
23  Human Aragorn;
24  std::cout << "Aragorn Agility: "
25    << Aragorn.Agility;
26
27  Elf Legolas;
28  std::cout << "\nLegolas Agility: "
29    << Legolas.Agility;
30}

1Aragorn Agility: 8
2Legolas Agility: 10

However, things work differently when we add a more derived class to this tree, such as HalfElf:

1class Character {};
2
3class Human : virtual public Character {};
4
5class Elf : virtual public Character {};
6
7class HalfElf : public Human, public Elf {};

Now, when we use the HalfElf class, we can imagine the created object searches upwards, through the inheritance tree, to find any virtual base classes.

Any virtual base classes it finds get moved to become a direct descendant. If the virtual class was already a direct descendant (either explicitly, or moved there from some other part of the inheritance tree), it gets removed entirely.

This has the effect of flatting and deduplicating virtual base classes within our inheritance tree for those objects:

This reorganization happens on-demand, at run time. As a result, similar to virtual methods, virtual inheritance has a performance cost. Therefore, we should not use it by default - we should only use it when needed.

Below, we implement the previous diagram in code:

1class Character {
2public:
3  Character() : Agility{5}{}
4  Character(int Agility) : Agility{Agility}{}
5  int Agility;
6};
7
8class Human : virtual public Character {
9public:
10  Human() : Character(8){}
11};
12
13class Elf : virtual public Character {
14public:
15  Elf() : Character(10){}
16};
17
18class HalfElf : public Elf, public Human {};

Implications of Virtual Inheritance

Now that we’re using virtual inheritance, two major things have changed from our earlier examples.

Firstly, we no longer have duplicate variables and methods in the object we created. We now only have one copy of the base class, and can access variables and methods of that class without needing to specify which intermediate class they came from:

1#include <iostream>
2
Unchanged Code|Show
3class Character {/*...*/}
10
Unchanged Code|Show
11class Human : virtual public Character {/*...*/}
16
Unchanged Code|Show
17class Elf : virtual public Character {/*...*/}
22
23class HalfElf : public Elf, public Human {};
24
25int main(){
26  HalfElf Elrond;
27  std::cout << "Elrond Agility: "
28    << Elrond.Agility;
29}

Secondly, the classes that used virtual inheritance (Human and Elf) are no longer constructing the base Character object. In this scenario, Character is now a direct ancestor of HalfElf, so it falls to HalfElf to initialize it.

In this example, we didn’t do any explicit initialization, so Character was created using the default constructor. The default Character constructor sets Agility to 5, which we can see from the output:

1Elrond Agility: 5

When an intermediate class is virtual, the derived class can initialize its base class directly. If the base class doesn’t have a default constructor, the derived class must initialize it.

Below, we’ve removed the default constructor from Character, and called the Character(int) constructor from the HalfElf class:

1#include <iostream>
2
3class Character {
4public:
5  Character(int Agility) : Agility{Agility}{}
6  int Agility;
7};
8
Unchanged Code|Show
9class Human : virtual public Character {/*...*/}
14
Unchanged Code|Show
15class Elf : virtual public Character {/*...*/}
20
21class HalfElf : public Elf {
22public:
23  HalfElf() : Character(9){}
24};
25
26int main(){
27  Human Aragorn;
28  std::cout << "Aragorn Agility: "
29    << Aragorn.Agility;
30
31  HalfElf Elrond;
32  std::cout << "\nElrond Agility: "
33    << Elrond.Agility;
34
35  Elf Legolas;
36  std::cout << "\nLegolas Agility: "
37    << Legolas.Agility;
38}

1Aragorn Agility: 8
2Elrond Agility: 9
3Legolas Agility: 10

Should I use Multiple Inheritance?

Even with virtual base classes, multiple inheritance is still quite messy and can lead to excessively complex class hierarchies. As such, it’s generally something that should be used with caution.

Multiple inheritance is never necessary. There is always an alternative solution to implement any design. This is evidenced by the fact that many object-oriented programming languages don’t support it, yet those languages are still used to create complex software.

If we are going to use multiple inheritance, it can be worth self-imposing some restrictions on how it is used. These restrictions can be designed to get most of the benefit while bypassing most of the problems.

The Google style guide, and many others, recommend the following:

Using "non-implementation inheritance" refers to design patterns like interfaces and abstract classes.

In C++, these design patterns are created using pure virtual functions, which we’ll introduce in the next lesson.

Summary

In this lesson, we explored multiple inheritance, including the challenges of naming conflicts, the diamond problem, and how virtual base classes can resolve these issues.

Key Takeaways

• C++ supports multiple inheritance, allowing a class to have more than one base class.
• Naming conflicts can occur with multiple inheritance, requiring explicit specification of which base class member to use.
• The diamond problem arises when a class inherits from two classes that both inherit from the same base class.
• Virtual inheritance is used to solve the diamond problem by ensuring a class inherits only one instance of a base class, even through multiple inheritance paths.
• Virtual base classes introduce a performance cost due to dynamic resolution.
• Multiple inheritance should be used with caution due to its complexity and potential for creating overly complex class hierarchies.

Next Lesson

Pure Virtual Functions, Abstract Classes, and Interfaces

Learn how to create interfaces and abstract classes using pure virtual functions

ContinueView Course