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 introduce 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.

Inheriting 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.

When we're working with inheritance, constructors have some additional properties to be aware of. By default, constructors are not inherited by their derived class.

Below, our Monster class has a constructor that accepts three int arguments, but that constructor is not automatically available to the Goblin derived class:

1#include <iostream>
2using namespace std;
3
4class Monster {
5 public:
6  Monster() = default;
7  Monster(int x, int y, int z) {
8    std::cout << "Three integers\n";
9  }
10};
11
12class Goblin : public Monster {};
13
14int main() {
15  Goblin Bonker{1, 2, 3};
16}

1Error: no overloaded function could convert all the argument types

To have a class inherit it's parent's constructors, we use the slightly weird using SomeType::SomeType syntax, where SomeType is the name of the base class:

1#include <iostream>
2using namespace std;
3
Monster Class (Unchanged)|Show
4class Monster {/*...*/};
12
13class Goblin : public Monster {
14  using Monster::Monster;
15};
16
17int main() {
18  Goblin Bonker{1, 2, 3};
19}

1Three integers

If our derived class has a constructor whose argument list matches the argument list of a base class constructor, the using BaseType::BaseType instruction will prioritize the more derived version:

1#include <iostream>
2using namespace std;
3
4class Monster {
5 public:
6  Monster() = default;
7  Monster(int x, int y) {
8    std::cout << "Two integers\n";
9  }
10  Monster(int x, int y, int z) {
11    std::cout << "Three integers\n";
12  }
13};
14
15class Goblin : public Monster {
16public:
17  // Goblin now has an (int, int, int) constructor, so
18  // this will only inherit the (int, int) constructor
19  using Monster::Monster;
20  
21  Goblin(int x, int y, int z) {
22    std::cout << "I'll handle this one\n";
23  }
24};
25
26int main() {
27  // Use Monster constructor
28  Goblin Bonker{1, 2};
29
30  // Use Goblin constructor
31  Goblin Basher{1, 2, 3};
32}

1Two integers
2I'll handle this one

Calling Inherited Constructors

Things get a bit more complicated when we want to add new constructors to our derived class that inherits some variables. This is because the constructor on a derived class needs to initialize the variables on the base class, too.

The easiest way of doing this is by calling 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 our inheritance hierarchy:

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 place where we can call an inherited constructor is within 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
Monster Class (Unchanged)|Show
4class Monster {/*...*/};
11
12class Goblin : public Monster {
13public:
14  Goblin() : Monster{}{
15    cout << "\nDefault Constructing Goblin";
16  }
17};
18
19int 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
Monster Class (Unchanged)|Show
4class Monster {/*...*/};
16
17class Goblin : public Monster {
18public:
19  Goblin(int Health) : Monster{Health}{
20    cout << "\nConstructing Goblin with an int";
21  }
22};
23
24int main(){
25  Goblin Bonker{200};
26  cout << "\nHealth: " << Bonker.GetHealth();
27}

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
Monster Class (Unchanged)|Show
4class Monster {/*...*/};
16
17class Goblin : public Monster {
18public:
19  Goblin(int Health, int Damage) :
20    Monster{Health}, mDamage{Damage}{
21    cout <<
22      "\nConstructing Goblin with two ints";
23  }
24
25  int GetDamage(){ return mDamage; }
26
27private:
28  int mDamage;
29};
30
31int main(){
32  Goblin Bonker{200, 15};
33  cout << "\nHealth: " << Bonker.GetHealth()
34    << "\nDamage: " << Bonker.GetDamage();
35}

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 called Health - 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 Attack() 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 idea 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 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
Monster Class (Unchanged)|Show
4class Monster {/*...*/};
15
16class Goblin : public Monster {
17public:
18  void Attack(){
19    Monster::Attack();
20    cout << "\n\nand now some Goblin things";
21  }
22};
23
Main Function (Unchanged)|Show
24int main(){/*...*/};

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

We not restricted to using shadowed functions in just this way. We can treat them like any other function - we can call them at any time, and we can forward or calculate arguments as needed:

1void Attack(Damage){
2  cout << "Some initial Goblin things";
3  Monster::Attack(Damage);
4  cout << "Some final goblin things";
5}
6
7void BigAttack(Damage){
8  if (isBigAttackReady) {
9    Monster::Attack(Damage * 2);
10    isBigAttackReady = false;
11  } else {
12    cout << "Not Ready!\n";
13  }
14}

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 explored 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.

Free and Unlimited Access

Professional C++

Unlock the true power of C++ by mastering complex features, optimizing performance, and learning expert workflows used in professional development

View Course