Replacing Inherited Functions

C++ Scope when using Inheritance

Learn how the scoping rules apply when dealing with inheritance, and how we can bypass them with the Scope Resolution operator

We've already seen how our classes can inherit functions from their ancestors. A common requirement is that child classes be able to override the functions they're inheriting.

Lets imagine we have the following classes:

1class Character {
2public:
3  void TakeDamage(int Damage) {
4    Health -= Damage;
5  };
6protected:
7  int Health { 100 };
8};
9
10class Hero : public Character {
11private:
12  float Armour { 0.2f };
13};
14

Our goal is to let our Hero objects take reduced damage, based on their Armour value

The problem is the TakeDamage function is something it is inheriting from the Character, and we don't want all Characters to have armour, just specifically heroes.

Implementing Override Functions

To implement this, we need to override the parent implementation of TakeDamage from within our Hero class.

To do this, we provide a function on our Hero class with the same prototype and the same access level (eg, public) as the function we want to override.

1class Character {
2public:
3  void TakeDamage(int Damage) {
4    Health -= Damage;
5  };
6private:
7  int Health { 100 };
8};
9
10class Hero : public Character {
11public:
12  void TakeDamage(int Damage) {
13    Health -= (Damage * (1-Armour));
14  };
15private:
16  float Armour { 0.2f };
17};
18

Now, a different version of the function will be called, depending on the type of the object it is being called with:

1Character Monster;
2// Monster will lose 100 health
3Monster.TakeDamage(100);
4
5Hero Player;
6// Player will lose 80 health
7Player.TakeDamage(100);
8

1class Animal {
2public:
3  int CountLegs() { return 4; }
4};
5
6class Spider : public Animal {
7public:
8  int CountLegs() { return 8; }
9};
10
11Animal Daisy;
12int LegCount { Daisy.CountLegs() };
13

1class Animal {
2public:
3  int CountLegs() { return 4; }
4};
5
6class Spider : public Animal {
7public:
8  int CountLegs() { return 8; }
9};
10
11Spider Spooky;
12int LegCount { Spooky.CountLegs() };
13

1class Animal {
2public:
3  int CountLegs() { return 4; }
4};
5
6class Spider : public Animal {
7public:
8  int CountLegs() { return 8; }
9};
10
11class Tarantula : public Spider {};
12
13Tarantula Hairy;
14int LegCount { Hairy.CountLegs() };
15

This is a powerful tool because, in the future, we will be writing code that calls functions on objects without necessarily knowing what subtype of object it is. It might be a plain old Character; it might be a Monster, or Hero or Goblin, or any other derivative of Character.

This means that, in the future, we will be able to expand our game incredibly easily. We will be able to add new types of characters to our game without having to update any of our other code - such as the Combat or Logging systems we've used in previous challenges.

This is a critical concept of object oriented programming, called polymorphism. In the next section of the course, we will be extending the ideas here to unlock the full potential of polymorphism.

For now though, lets explore an important design option when overriding functions.

Extending Base Functions and the :: operator

Commonly, our use case for replacing a function in this way is not necessarily to replace the base implementation entirely. More commonly, we just want to extend the base implementation.

For example, in a real game, when a Character takes damage, it's generally going to require more than updating a single Health value. We could be dealing with animation, sound, blood effects, AI and more.

1class Character {
2public:
3  void TakeDamage(int Damage) {
4    Health -= Damage;
5    PlayAnimation();
6    PlaySound();
7    UpdateAI();
8    RenderEffects();
9    /// etc
10  };
11protected:
12  int Health { 100 };
13};
14

We probably don't want to replace (or duplicate) all of that in our override - we just want to reduce the Damage slightly. To achieve this, we can call the parent's implementation of the function with a smaller number.

1class Hero : public Character {
2public:
3  void TakeDamage(int Damage) {
4    int ReducedDamage { Damage * (1-Armour) };
5    // Pass ReducedDamage to the parent TakeDamage function
6  };
7private:
8  float Armour { 0.2f };
9};
10

Given we've overridden the TakeDamage function, we can't just access it using TakeDamage from our Hero class. Our hero class now has its own version of TakeDamage

As we've seen with how scopes work in the past, the compiler will use the "most local" version of a variable or function. Given we're writing code in the Hero class, the most local function is the one that is also in the Hero class.

Fortunately, we can instruct the compiler what scope to use. We do that with the scope resolution operator ::

By prefixing our function call with Character:: we can specify we want to access the function that is defined in the Character class, rather than the one in our current scope.

1class Hero : public Character {
2public:
3  void TakeDamage(int Damage) {
4    int ReducedDamage { Damage * (1-Armour) };
5    Character::TakeDamage(ReducedDamage);
6  };
7private:
8  float Armour { 0.2f };
9};
10

Now, when we or another developer adds features or fixes a bug in the Character's TakeDamage function, our Hero benefits from that too. This makes our code easier to maintain and less prone to bugs.

1void TakeDamage(int Damage) {
2  int ReducedDamage { Damage * (1-Armour) };
3  Super::TakeDamage(DamageToTake);
4};
5

1class Animal {
2public:
3  int CountLegs() { return 4; }
4};
5
6class Cow : public Animal {
7  int CountLegs() {
8    cout << "Moo";
9    return Animal::CountLegs();
10  }
11};
12
13Cow Kevin;
14int LegCount { Kevin.CountLegs() };
15