C++ Scope when using Inheritance

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

Lets imagine we have the following classes:

1class Character {
2public:
3  int GetHealth() {
4    return Health;
5  };
6  int Health { 100 };
7};
8
9class Monster : public Character {
10public:
11  int Health { 200 };
12};
13

Our goal is that both our Character and more specific Monster objects to have a Health property, but for their value to be different.

Lets create a Monster and see if our code works:

1Monster SomeGoblin;
2cout << SomeGoblin.Health << endl;
3cout << SomeGoblin.GetHealth();
4

Our output is:

1200
2100
3

This is not quite what we want. SomeGoblin.Health is returning the Health value from our Monster class, but GetHealth() is using the value from our Character class.

Understanding Scope with Inheritance

This behaviour is quite similar to what we previously saw in our introductory lesson on scopes. There, we saw when we refer to a variable, the most local version of that variable is used.

C++ Global and Local Scope

Learn more about how and when we can access variables, by understanding the importance of the scope in which they exist.

Just like we saw in that lesson, the problem is that Health in the Character class and Health in the Monster class are different variables. They just happen to have the same name. We're "shadowing" or "masking" the variable, not replacing it.

Since SomeGoblin is a Monster, when we create an expression like SomeGoblin.Health, we look for the Health variable within the Monster class. That variable exists, so it is used.

However, when we have the expression SomeGoblin.GetHealth(), there is no GetHealth function in our Monster class, so the compiler searches up the inheritance tree.

It finds GetHealth exists on the parent scope, so it uses that function.

However, now that we are in the scope of the Character class, we no longer have access to things that are in the child scope. The Health variable of the Monster class is out of reach, so the GetHealth function returns the value stored in the Character class.

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

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

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

Fixing C++ Scope Issues

So, how can we solve this simple problem of letting our Monster objects have a different Health value? One option is duplicating the GetHealth function into the class:

1class Character {
2public:
3  int GetHealth() {
4    return Health;
5  };
6  int Health { 100 };
7};
8
9class Monster : public Character {
10public:
11  int GetHealth() {
12    return Health;
13  };
14  int Health { 200 };
15};
16

But this loses all the advantages of inheritance that we talked about. A better option would be to update the inherited value from the default constructor:

1class Character {
2public:
3  int GetHealth() {
4    return Health;
5  };
6protected:
7  int Health { 100 };
8};
9
10class Monster : public Character {
11public:
12  Monster() {
13    Health = 200;
14  };
15};
16

We've additionally moved the Health variable into the protected section. This is not necessary, but is a good practice, as described in our lessons on encapsulation.

Now, our inherited class works as we expect:

1Monster SomeGoblin;
2cout << SomeGoblin.GetHealth();
3

Our output is:

1200
2

Extending Base Functions and the :: operator

Another situation we're likely to run in to is one where we need to replace an inherited function:

1class Character {
2public:
3  void TakeDamage() {
4    cout << "I have taken damage" << endl;
5  };
6};
7
8class Monster : public Character {
9public:
10  void TakeDamage() {
11    cout << "You will pay for that!" << endl;
12  };
13};
14

This behaves as we might expect:

1Monster SomeGoblin;
2SomeGoblin.TakeDamage();
3

1You will pay for that!
2

This is straightforward when the function we want to replace is very simple.

However, that will not always be the case. The TakeDamage function might have lots of moving parts and, from our inherited function, we still want to do all of those things. We just want to do something extra, too.

Rather than duplicating the entire function, we can instead call the base class function from our inherited class function. However, given the functions have the same name, it's not too clear how to do that.

Doing it directly won't work - we'll just create an infinite loop:

1class Monster : public Character {
2public:
3  void TakeDamage() {
4    TakeDamage();
5    cout << "You will pay for that!" << endl;
6  };
7};
8

Fortunately, we have the Scope Resolution operator, ::.

Where there are multiple functions or variables with the same name available within a scope, we can use the :: operator to specify which one we want to use. This lets us bypass the default "use the most local scope" behaviour when we try to access a variable or function.

1class Character {
2public:
3  void TakeDamage() {
4    cout << "I have taken damage" << endl;
5    // Imagine lots of additional code here
6  };
7};
8
9class Monster : public Character {
10public:
11  void TakeDamage() {
12    Character::TakeDamage();
13    cout << "You will pay for that!" << endl;
14  };
15};
16

Now, we have unlocked the ability to extend inherited functions, rather than just replacing them entirely.

1Monster SomeGoblin;
2SomeGoblin.TakeDamage();
3

1I have taken damage
2You will pay for that!
3

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

1// This only works if our code is handled by Unreal
2class MyClass : public SomeUnrealClass {
3  void TakeDamage() {
4    Super::TakeDamage();
5    cout << "You will pay for that!";
6  };
7}
8