Implementing C++ Inheritance

In this lesson, we will see how we can start to implement inheritance in C++.

Lets imagine we have an Actor class, defined as follows:

1class Actor {
2  // Actor class code
3};
4

We want to create a new class, Character, that will inherit from the Actor class.

We can do that in the following way:

1class Character : Actor {
2  // Character class code
3};
4

After the name of the class we are creating, we can choose which class it inherits from. We do that using a : followed by the name of the class we want to be the parent.

C++ Class Inheritance Trees

In the previous lesson, we had this diagram for an inheritance tree we wanted to create:

Lets set it up in code:

1class Actor {
2public:
3  void Render() {};
4};
5
6class Character : Actor {
7public:
8  void Move() {};
9  void Attack() {};
10  void DropLoot() {};
11};
12
13class Goblin : Character {
14public:
15  void Enrage() {};
16};
17
18class Dragon : Character {
19public:
20  void Fly() {};
21};
22

C++ Public and Private Inheritance

Our code, at this point, might not work entirely as we expect. Lets try this:

1Character PlayerOne;
2PlayerOne.Render();
3

We will get an error claiming that Render is private. This may be surprising, as we have declared it as public within the Actor class.

However, just like functions and variables, inheritance itself can be public or private. By default, class inheritance is private.

We can change this to be public within our class heading:

1class Character : public Actor {};
2

Now, anything that is public in Actor will be public in Monster

Setting the inheritance to public will not overrule access restrictions within the base class. If something was private in Actor, it will still be private in Monster.

In practice, public inheritance is by far the most useful and most commonly used, so it will be what we focus on in this course.

1class Animal {
2public:
3  void Move() {};
4};
5
6class Dog : Animal {};
7
8int main() {
9  Dog MyDog;
10  MyDog.Move();
11}
12

1class Animal {
2public:
3  void Move() {};
4}
5
6class Dog : Animal {};
7
8int main() {
9  Dog MyDog;
10  MyDog.Move();
11}
12

1class Dog : public Animal {
2   // Rest of the class here
3}
4

1class Dog : Animal {
2public:
3  void Move();
4};
5

C++ final - Preventing Inheritance

Sometimes, we create a class that is not designed to ever have a child class. To clarify that intent, and have the compiler to enforce it, we can add the final specifier to the class heading:

1class Actor final {};
2
3class Monster : Actor {};
4

Should anyone try to inherit from our class, as done on line 3 in the above example, their code will not compile. This will yield an error similar to the following:

1Cannot inherit from 'Actor' as it has been declared as 'final'
2