Working with Inherited Members

In our previous lessons, we explored how classes can inherit functions and variables from their parent, or base, classes. This powerful feature of object-oriented programming allows us to build upon existing code, promoting reusability and efficiency.

In this lesson, we will delve into how to effectively work with these inherited members. We'll uncover how to harness their potential while steering clear of some common pitfalls that can trip us up.

By the end of this lesson, you'll have a solid understanding of how to use inherited members in your programs, setting a strong foundation for more advanced topics later in the course.

Calling Inherited Constructors

We previously saw how we could define constructors for our classes. These allowed us to pass values when creating an object, to control how it gets initialized.

Things get a bit more complicated when we’re working with inheritance because we need to construct the inherited variables too.

We do this by calling the constructors that are in those classes we inherited from. If we don’t intervene in that process, we’ll use default constructors, all the way down:

1#include <iostream>
2using namespace std;
3
4class Monster {
5public:
6  Monster(){
7    cout << "Default Constructing Monster";
8  }
9};
10
11class Goblin : public Monster {
12public:
13  Goblin(){
14    cout << "\nDefault Constructing Goblin";
15  }
16};
17
18int main(){ Goblin Bonker; }

1Default Constructing Monster
2Default Constructing Goblin

Within any constructor of our derived class, we can explicitly set which base constructor we want to use.

The only way we can do this is through a member initializer list. The following program replicates the previous behavior, but our Goblin constructor is now explicitly calling the default constructor on Monster:

1#include <iostream>
2using namespace std;
3
4class Monster {
5public:
6  Monster(){
7    cout << "Default Constructing Monster";
8  }
9};
10
11class Goblin : public Monster {
12public:
13  Goblin() : Monster{}{
14    cout << "\nDefault Constructing Goblin";
15  }
16};
17
18int main(){ Goblin Bonker; }

1Default Constructing Monster
2Default Constructing Goblin

If the inherited type doesn’t have a default constructor, and we don’t specify which alternative to use, we won’t be able to create any objects using our derived class.

To control which inherited constructor we call, we need to pass arguments within the Monster{} expression in our member initializer list.

The compiler uses these arguments to determine which constructor to use, just like it does when we construct an object in any other context.

Below, we’ve removed the default constructor from our Monster, replacing it with a constructor that accepts an int.

Then, within the member initializer list of our Goblin default constructor, we pass that int:

1#include <iostream>
2using namespace std;
3
4class Monster {
5public:
6  Monster(int Health) : mHealth{Health}{
7    cout << "Constructing Monster with an int";
8  }
9
10  int GetHealth(){ return mHealth; }
11
12private:
13  int mHealth{100};
14};
15
16class Goblin : public Monster {
17public:
18  Goblin() : Monster{150}{
19    cout << "\nDefault Constructing Goblin";
20  }
21};
22
23int main(){
24  Goblin Bonker;
25  cout << "\nHealth: " << Bonker.GetHealth();
26}

1Constructing Monster with an int
2Default Constructing Goblin
3Health: 150

Naturally, we are free to use expressions in this process, including parameters. In the following example, we’ve removed the default constructor of our Goblin, also replacing it with one that accepts an int.

We then forward that int to the Monster constructor from our member initializer list:

1#include <iostream>
2using namespace std;
3
4class Monster {
5public:
6  Monster(int Health) : mHealth{Health}{
7    cout << "Constructing Monster with an int";
8  }
9
10  int GetHealth(){ return mHealth; }
11
12private:
13  int mHealth{100};
14};
15
16class Goblin : public Monster {
17public:
18  Goblin(int Health) : Monster{Health}{
19    cout << "\nConstructing Goblin with an int";
20  }
21};
22
23int main(){
24  Goblin Bonker{200};
25  cout << "\nHealth: " << Bonker.GetHealth();
26}

1Constructing Monster with an int
2Constructing Goblin with an int
3Health: 200

Finally, let's see a slightly more complex example. Below, we’ve updated our Goblin constructor to accept two integers.

The first is forwarded to the Monster constructor to set the inherited mHealth,

The second argument is used to set mDamage, a variable that is specific to the Goblin type:

1#include <iostream>
2using namespace std;
3
4class Monster {
5public:
6  Monster(int Health) : mHealth{Health}{
7    cout << "Constructing Monster with an int";
8  }
9
10  int GetHealth(){ return mHealth; }
11
12private:
13  int mHealth{100};
14};
15
16class Goblin : public Monster {
17public:
18  Goblin(int Health, int Damage) :
19    Monster{Health}, mDamage{Damage}{
20    cout <<
21      "\nConstructing Goblin with two ints";
22  }
23
24  int GetDamage(){ return mDamage; }
25
26private:
27  int mDamage;
28};
29
30int main(){
31  Goblin Bonker{200, 15};
32  cout << "\nHealth: " << Bonker.GetHealth()
33    << "\nDamage: " << Bonker.GetDamage();
34}

1Constructing Monster with an int
2Constructing Goblin with two ints
3Health: 200
4Damage: 15

1class Weapon {
2public:
3  Weapon(int Damage) : mDamage{Damage} {}
4private:
5  int mDamage;
6};
7
8class Sword : public Weapon {
9public:
10  Sword() : Weapon{20} {}
11};

Updating Inherited Variables

Sometimes, we’ll want to change the value of an inherited variable, but there is no inherited constructor to let us set its initial value directly.

In these cases, we can just let the base constructor complete, and then change the value from our derived constructor. As always, to access an inherited variable, it needs to be either public or protected within the base class.

Below, our Monster objects are default constructed with a Health value of 100. But, if we’re specifically creating a Goblin, that type’s constructor updates the value to 150:

1#include <iostream>
2using namespace std;
3
4class Monster {
5public:
6  int Health{100};
7};
8
9class Goblin : public Monster {
10public:
11  Goblin(){ Health = 150; }
12};
13
14int main(){
15  Goblin Bonker;
16  cout << "Health: " << Bonker.Health;
17}

1Health: 150

1#include <iostream>
2using namespace std;
3
4class Actor {
5public:
6  Actor(){ cout << "Actor Constructor\n"; }
7};
8
9class Monster : public Actor {
10public:
11  Monster(){ cout << "Monster Constructor\n"; }
12};
13
14class Goblin : public Monster {
15public:
16  Goblin(){ cout << "Goblin Constructor\n"; }
17};
18
19int main(){
20  Goblin Bonker;
21}

1Actor Constructor
2Monster Constructor
3Goblin Constructor

Common Mistake: Shadowing Inherited Variables

A common way beginners try to update the value of inherited variables is simply to specify a variable with the same name and type on their derived classes:

1#include <iostream>
2using namespace std;
3
4class Monster {
5public:
6  int Health{100};
7};
8
9class Goblin : public Monster {
10public:
11  int Health{150};
12};
13
14int main(){
15  Goblin Bonker;
16  cout << "Health: " << Bonker.Health;
17}

In some cases, such as the previous example, this even seems to work:

1Health: 150

But what has actually happened here is that we now have two variables - one in the scope of Monster, and one in the scope of Goblin.

This is very similar to the notion of shadowed variables we introduced in our earlier lesson on scope.

We can see how the approach breaks down when we make our class a little more complex. Below, we’ve moved Health into the private section, and added a getter to our Monster class, which Goblin is inheriting.

1#include <iostream>
2using namespace std;
3
4class Monster {
5public:
6  int GetHealth(){ return Health; }
7
8private:
9  int Health{100};
10};
11
12class Goblin : public Monster {
13  int Health{150};
14};
15
16int main(){
17  Goblin Bonker;
18  cout << "Health: " << Bonker.GetHealth();
19}

We can now see that we’re getting the Health value from our Monster class, rather than our Goblin class.

1Health: 100

This is because we’re calling GetHealth(), which is defined in the Monster scope. And, in that scope, Health refers to the variable with the value of 100.

1class Weapon {
2public:
3  int GetDamage(){ return Damage; }
4
5protected:
6  int Damage{10};
7};
8
9class Sword : public Weapon {
10public:
11  Sword(){ Damage *= 2; }
12};
13
14int main(){
15  Sword IronSword;
16  int WeaponDamage{IronSword.GetDamage()};
17}

1class Weapon {
2public:
3  int GetDamage(){ return Damage; }
4  int Damage{10};
5};
6
7class Spear : public Weapon {
8public:
9  int Damage;
10};
11
12int main(){
13  Spear IronSpear;
14  IronSpear.Damage = 20;
15  int WeaponDamage{IronSpear.GetDamage()};
16}

Shadowing Inherited Functions

When working with inheritance, we often want to modify the behavior of one or more of our inherited functions.

Typically, this involves defining a function with the same prototype as the one we’re inheriting.

Below, we’ve provided a specific implementation of an inherited function, allowing us to implement subtype-specific behaviors:

1#include <iostream>
2using namespace std;
3
4class Monster {
5public:
6  void Attack(){ cout << "Monster Attacking"; }
7};
8
9class Goblin : public Monster {
10public:
11  void Attack(){ cout << "Goblin Attacking"; }
12};
13
14int main(){
15  Goblin Bonker;
16  Bonker.Attack();
17}

1Goblin Attack

Similar to variables, this is another example of shadowing. The function we’re shadowing still exists on the base class. But with functions, this is rarely as problematic as it is for variables.

Later in the course, we’ll introduce the concept of polymorphism, which builds on this concept to create extremely flexible and intuitive designs.

1class Weapon {
2public:
3  int GetDamage(){ return Damage; }
4
5protected:
6  int Damage{10};
7};
8
9class MagicalSword : public Weapon {
10public:
11  int GetDamage(){
12    return isEnchanted ? Damage * 2 : Damage;
13  }
14
15protected:
16  bool isEnchanted{true};
17};
18
19int main(){
20  MagicalSword SwordOfLight;
21  int WeaponDamage{SwordOfLight.GetDamage()};
22}

Extending Inherited Functions

Expanding on the idea of providing a replacement implementation of an inherited function, we’ll also sometimes want to take a more subtle approach.

For example, the inherited function might be quite complex, which we’ve simulated below just with a load of logging:

1#include <iostream>
2using namespace std;
3
4class Monster {
5 public:
6  void Attack(){
7    cout << "\nMonster Attacking";
8    cout << "\nPlaying Animation";
9    cout << "\nPlaying Sound";
10    cout << "\nUpdating UI";
11    cout << "\nEven More Stuff";
12  }
13};
14
15class Goblin : public Monster {
16 public:
17  void Attack(){
18    // ...??
19  }
20};
21
22int main() {
23  Goblin Bonker;
24  Bonker.Attack();
25}

We may want the version of that function in our subclass to do all those things, too - we just want it to do something extra.

When shadowing an inherited function, we can call the inherited version using the base class name, and the scope resolution operator ::

It looks like this:

1#include <iostream>
2using namespace std;
3
4class Monster {
5public:
6  void Attack(){
7    cout << "\nMonster Attacking";
8    cout << "\nPlaying Animation";
9    cout << "\nPlaying Sound";
10    cout << "\nUpdating UI";
11    cout << "\nEven More Stuff";
12  }
13};
14
15class Goblin : public Monster {
16public:
17  void Attack(){
18    Monster::Attack();
19    cout << "\n\nand now some Goblin things";
20  }
21};
22
23int main(){
24  Goblin Bonker;
25  Bonker.Attack();
26}

1Monster Attacking
2Playing Animation
3Playing Sound
4Updating UI
5Even More Stuff
6
7and now some Goblin things

1void Attack(){
2  Super::Attack();
3  cout << "\n\nand now some Goblin things";
4}

1class Monster {
2public:
3  void SetDamage(int Damage){
4    mDamage = Damage;
5  }
6
7  int GetDamage(){ return mDamage; }
8
9private:
10  int mDamage;
11};
12
13class Goblin : public Monster {
14public:
15  void SetDamage(int Damage){
16    Monster::SetDamage(
17      isEnraged ? Damage * 2 : Damage);
18  }
19
20private:
21  bool isEnraged{true};
22};
23
24int main(){
25  Goblin Bonker;
26  Bonker.SetDamage(15);
27  int GoblinDamage{Bonker.GetDamage()};
28}

Summary

In this lesson, we dove deep into the nuances of using inherited members in C++. We learned how to call inherited constructors from the member initializer list of derived constructors, ensuring a smooth and efficient setup of our derived objects. Key highlights from this lesson include:

• Understanding the order and process of calling base class constructors in derived classes.
• Learning to modify inherited variables in derived classes and the importance of variable visibility (public or protected).
• Recognizing and avoiding common pitfalls, such as variable shadowing, which can lead to confusing bugs.
• Exploring how to shadow and extend inherited functions, allowing for more specialized behaviors in derived classes.

Next Lesson

References

This lesson demystifies references, explaining how they work, their benefits, and their role in performance and data manipulation

ContinueView Course