Downcasting

In our lessons on inheritance and polymorphism, we talked about how an object of a specific type also has the type of every ancestor class. Below, our Bonker object is both a Character and a Goblin:

1class Character {};
2
3class Goblin : public Character {};
4
5int main(){
6  Goblin Bonker;
7}

We see an example of this below, where our Goblin is passed to the Act() function in the form of a Character*.

We’re then able to call the inherited GetName() function:

1#include <iostream>
2using namespace std;
3
4class Character {
5public:
6  Character(string Name) : mName{Name}{}
7  string GetName(){ return mName; }
8
9private:
10  string mName;
11};
12
13class Goblin : public Character {
14public:
15  Goblin(string Name) : Character{Name}{}
16
17  void Enrage(){
18    cout << "Getting Angry!";
19    Damage += 5;
20  }
21
22private:
23  int Damage{10};
24};
25
26void Act(Character* Enemy){
27  cout << Enemy->GetName() << " Acting\n";
28}
29
30int main(){
31  Goblin Bonker{"Bonker"};
32  Act(&Bonker);
33}

1Bonker Acting

Why do we need Downcasting?

Above, we saw that if we have a Character* pointing we can call Character functions, as expected. But what if we wanted to call some Goblin function, such as Enrage()?

After all, this Character* is pointing at a Goblin, so we should be able to do that. But if we try, we get a compilation error:

1#include <iostream>
2using namespace std;
3
Character Class (Unchanged)|Show
4class Character {/*...*/};
13
Goblin Class (Unchanged)|Show
14class Goblin : public Character {/*...*/};
27
28void Act(Character* Enemy){
29  cout << Enemy->GetName() << " Acting\n";
30  Enemy->Enrage();
31}
32
33int main(){
34  Goblin Bonker{"Bonker"};
35  Act(&Bonker);
36}

1error: no member named 'Enrage' in 'Character'

Perhaps this makes sense. When we have a variable of type Goblin, and we call a function on that object that is defined in the Character class, this is safe. By the rules of inheritance, all Goblins are also Characters

But, this is not true in the opposite direction. Not all Characters are guaranteed to be Goblins. Therefore, when we have a variable of type Character*, and we try to call a function that is defined in the Goblin class, we get a compilation error.

Downcasting using static_cast

To address this, we need to rely on casting. Specifically, we have a pointer to a Character, and we want to convert this to a pointer to a Goblin. so we can access the goblin-specific functionality.

This scenario, where we are casting a pointer down the inheritance tree to a more specific subtype, is called downcasting.

The simplest form of this involves using the static_cast approach we introduced earlier in the chapter.

Static Casting

Explore the concept of static casting in C++, including examples and best practices for converting data types at compile time

In our Act() function, we can use static_cast to convert our Character pointer to a Goblin pointer.

1void Act(Character* Enemy){
2  Goblin* GoblinPtr{
3    static_cast<Goblin*>(Enemy)
4  };
5}

We can then Enrage using our Goblin pointer:

1#include <iostream>
2using namespace std;
3
Character Class (Unchanged)|Show
4class Character {/*...*/};
13
Goblin Class (Unchanged)|Show
14class Goblin : public Character {/*...*/};
27
28void Act(Character* Enemy){
29  cout << Enemy->GetName() << " Acting\n";
30  static_cast<Goblin*>(Enemy)->Enrage();
31}
32
33int main(){
34  Goblin Bonker{"Bonker"};
35  Act(&Bonker);
36}

1Bonker Acting
2Getting Angry!

This may seem contrived - why not just use a Goblin* to store a pointer to a Goblin?

Remember, the point of run time polymorphism is that we want functions like Act to work across a range of types.

If we updated our parameter to be a Goblin* instead of a Character*, we could call Enrage() directly, but we then couldn’t call Act() with anything except goblins.

1class Animal {};
2
3class Dog : public Animal {
4public:
5  void Bark(){}
6};
7
8int main(){
9  Dog MyDog;
10  Animal* MyDogPointer{&MyDog};
11  // Call Bark using MyDogPointer
12}

1MyDogPointer->Bark();

1static_cast<Dog*>(MyDogPointer)->Bark();

1static_cast<Dog>(MyDogPointer).Bark()

Downcasting Can Fail

Something important to note about downcasting is that it can fail in one of two ways.

Compile Time Failure (Impossible Downcasts)

Below, we’re trying to cast a Goblin* to a Dragon*. This would never work - a Goblin cannot possibly be a Dragon as Dragon does not inherit from Goblin.

static_cast can detect this problem, and raise an error:

1class Character {};
2
3class Goblin : public Character {};
4
5class Dragon : public Character {};
6
7void Act(Goblin* Enemy){
8  static_cast<Dragon*>(Enemy);
9}

1error: 'static_cast': cannot convert
2from 'Goblin *' to 'Dragon *'

This is one of the advantages of static_cast over C-style casting. A C-style cast would let this error through, resulting in a bug:

1void Act(Goblin* Enemy){
2  (Dragon*)Enemy;
3}

Run Time Failure

The second, more common way a downcast will fail is when our conversion is possible in theory, but is simply not valid in this specific case.

Below, our Act() function attempts to cast a Character* to a Goblin*. This is theoretically possible - Character is a base class for Goblin, so a Character* could be pointing at a Goblin.

But in this specific case, it’s not:

1#include <iostream>
2using namespace std;
3
Character Class (Unchanged)|Show
4class Character {/*...*/};
13
Goblin Class (Unchanged)|Show
14class Goblin : public Character {/*...*/};
27
28void Act(Character* Enemy){
29  cout << Enemy->GetName() << " Acting\n";
30  static_cast<Goblin*>(Enemy)->Enrage();
31}
32
33int main(){
34  Character Dragon{"Dave"};
35  Act(&Dragon);
36}

Because our Act() function assumes that the Character* is always pointing at a Goblin, we have a bug. Our program will behave unpredictably, likely crashing.

For scenarios where an object may or may not be a specific subtype, we need to use dynamic casting.

Static vs Dynamic Casting

In the first example, static_cast worked well because the Character* within Act() was always pointing to a Goblin. Within our simple program, that was the only possibility.

But, this is not always going to be the case. Often, the specific subtypes our functions are dealing with on each invocation will be different, and they will depend on runtime conditions such as user decisions.

A limitation of static_cast is it only checks if Character is a parent class of Goblin. It does not check whether this specific Character is a Goblin.

Because static_cast is done at compile time, it has no performance overhead. This is great if we know the downcast will work, however, in many scenarios, we can’t be sure.

For those scenarios, we have dynamic casting.

1class Character {
2public:
3  virtual ~Character() = default;
4};

Downcasting using dynamic_cast

The way we invoke dynamic_cast follows the same pattern as static_cast:

1void Handle(Character* Object){
2  Goblin* GoblinPointer{
3    dynamic_cast<Goblin*>(Object)
4  };
5};

The key difference is that dynamic_cast performs an additional run-time check to determine whether the pointer actually is pointing to the thing we’re trying to cast it to.

In this case, it’s checking whether the Object pointer really is pointing at a Goblin.

If the pointer was not pointing at the type we specified, dynamic_cast returns a nullptr,

This allows us to react to cast failures because we can detect null pointers using an if statement in the usual way:

1void Handle(Character* Object){
2  Goblin* GoblinPointer{
3    dynamic_cast<Goblin*>(Object)
4  };
5
6  if (GoblinPointer) {
7    cout << "That was a Goblin\n";
8  } else {
9    cout << "That was not a Goblin\n";
10  }
11};

Below, we show this in action. We first pass Handle a Goblin, and then a basic Character:

1#include <iostream>
2using namespace std;
3
4class Character {
5public:
6  virtual ~Character() = default;
7};
8
9class Goblin : public Character { };
10
11void Handle(Character* Object){
12  Goblin* GoblinPointer{
13    dynamic_cast<Goblin*>(Object)
14  };
15
16  if (GoblinPointer) {
17    cout << "That was a Goblin\n";
18  } else {
19    cout << "That was not a Goblin\n";
20  }
21};
22
23int main(){
24  Goblin Enemy;
25  Handle(&Enemy);
26
27  Character Player;
28  Handle(&Player);
29}

1That was a Goblin
2That was not a Goblin

A Practical Example

Let's go through a slightly more complex example. Below, we have a polymorphic combat system, very similar to what we created in the previous lesson.

Two Character objects are passed to Battle() as pointers, and they both then Act() upon each other:

1#include <iostream>
2using namespace std;
3
4class Character {
5public:
6  Character(string Name) : mName{Name}{}
7  string GetName(){ return mName; }
8
9  void TakeDamage(int Damage){
10    cout << mName << " Taking Damage\n";
11    mHealth -= Damage;
12  }
13
14  virtual void Act(Character* Target){
15    Target->TakeDamage(50);
16  }
17
18protected:
19  string mName;
20  int mHealth{150};
21};
22
23void Battle(Character* A, Character* B){
24  B->Act(A);
25  A->Act(B);
26}
27
28int main(){
29  Character Player{"Player"};
30
31  Character EnemyGoblin{"Goblin"};
32  Battle(&Player, &EnemyGoblin);
33  cout << '\n';
34
35  Character EnemyVampire{"Vampire"};
36  Battle(&Player, &EnemyVampire);
37}

1Player Taking Damage
2Goblin Taking Damage
3
4Player Taking Damage
5Vampire Taking Damage

Let's add some subclasses we can use. Below, our vampire enemy now has its own dedicated Vampire class. It has also developed a weakness to wooden stakes, represented by the vampire-specific Stake() function.

Our player has become a VampireHunter which, for now, just behaves in the same way as the basic Character:

1#include <iostream>
2using namespace std;
3
Character Class (Unchanged)|Show
4class Character {/*...*/};
23
Battle Function (Unchanged)|Show
24void Battle(Character* A, Character* B){/*...*/};
29
30class Vampire : public Character {
31public:
32  Vampire(string Name) : Character{Name}{}
33
34  void Stake(){
35    cout << mName << " Getting Staked\n";
36    mHealth = 0;
37  }
38};
39
40class VampireHunter : public Character {
41public:
42  VampireHunter(string Name) : Character{Name}{}
43};
44
45int main(){
46  VampireHunter Player{"Player"};
47
48  Character EnemyGoblin{"Goblin"};
49  Battle(&Player, &EnemyGoblin);
50  cout << '\n';
51
52  Vampire EnemyVampire{"Vampire"};
53  Battle(&Player, &EnemyVampire);
54}

So far, not much has changed - combat is proceeding as before:

1Player Taking Damage
2Goblin Taking Damage
3
4Player Taking Damage
5Vampire Taking Damage

We’d like to update our VampireHunter with the ability to Stake() vampire enemies. But we still need to fight non-vampires, too.

So, using what we’ve learned, we can override the Act() function and use dynamic_cast to determine whether or not we’re fighting a Vampire.

If we are, we Stake() them, otherwise, we fall back to the default Character action:

1#include <iostream>
2using namespace std;
3
Character Class (Unchanged)|Show
4class Character {/*...*/};
23
Battle Function (Unchanged)|Show
24void Battle(Character* A, Character* B){/*...*/};
29
Vampire Class (Unchanged)|Show
30class Vampire : public Character {/*...*/};
40
41class VampireHunter : public Character {
42public:
43  VampireHunter(string Name) : Character{Name}{}
44
45  void Act(Character* Target) override{
46    Vampire* VampirePtr{
47      dynamic_cast<Vampire*>(Target)};
48
49    if (VampirePtr) {
50      VampirePtr->Stake();
51    } else {
52      Character::Act(Target);
53    }
54  }
55};
56
main Function (Unchanged)|Show
57int main(){/*...*/};

1Player Taking Damage
2Goblin Taking Damage
3
4Player Taking Damage
5Vampire Getting Staked

It’s worth reflecting that we didn’t need to change our combat system (the contrived Battle function, and the Character class it uses) at any point in this process.

Our combat system doesn’t know anything about vampires and vampire hunting - all of that is encapsulated away in our vampiric types.

Because of the power of polymorphism, our combat system gets richer and more dynamic, without its code needing to get more complex, or even change at all.

Summary

• Understanding Downcasting: We learned that downcasting is a way to convert a pointer or reference from a base class to a derived class in the inheritance hierarchy.
• static_cast for Downcasting: We explored the use of static_cast for downcasting, which is suitable when we're certain about the type of the object at compile time. This method is efficient but lacks runtime type checking.
• dynamic_cast for Safe Downcasting: We discussed dynamic_cast, which is used when the type of the object is not known until runtime. This method provides a safe way to perform downcasting by returning a nullptr if the cast is not possible.
• Practical Application in Polymorphic Systems: Through examples involving characters in a combat system, we illustrated how downcasting can enrich the functionality of polymorphic systems without complicating the underlying code structure.