C++ Dynamic Casting (std::dynamic_cast)

Lets imagine our base Character class look like this:

1class Character {
2public:
3  virtual void Act(Character* Enemy) {
4    Enemy->TakeDamage(50);
5  }
6  
7  virtual void TakeDamage(int Damage) {
8    Health -= Damage;
9  }
10protected:
11  int Health { 200 };
12}
13

Vampires are about to enter the battle, and they can shrug off any damage! Lets override the TakeDamage function to make that happen:

1class Vampire : public Character {
2public:
3  void TakeDamage(int Damage) override {
4    cout << "Muahahaha";
5  }
6}
7

They've been defeating everyone. They can be killed by wooden stakes, but nobody has uncovered this fatal weakness:

1class Vampire : public Character {
2public:
3  void TakeDamage(int Damage) override {
4    cout << "Muahahaha";
5  }
6  
7  void Stake() {
8    Health = 0;
9  }
10}
11

Finally, some Vampire Hunters show up, with the secret knowledge and a solid plan:

1class VampireHunter : public Character {
2public:
3  void Act(Character* Enemy) override {
4    if (EnemyIsVampire) {
5      Enemy->Stake();
6    } else {
7      Enemy->TakeDamage(30);
8    }
9  }
10}
11

Lets see how we can get that working!

The Use Case for Dynamic Casting

In the previous lesson we saw that, if we knew the Enemy was pointing to a Vampire, we could just use static_cast.

1void Act(Character* Enemy) override {
2  Vampire* VampireEnemy {
3    static_cast<Vampire*>(Enemy)
4  };
5  
6  VampireEnemy->Stake();
7}
8

This will work as long as the Enemy really is a Vampire, but we can't know that. Our VampireHunters will be able to fight other types of Character too, so we need a better solution.

When we need to try a cast, but we're not sure it will work, we should use dynamic_cast

Dynamic casts are done at run-time, so they have a performance cost. What we get for that cost is information on whether or not the cast was successful.

We use dynamic_cast in the same way we would use static_cast:

1dynamic_cast<Vampire*>(Enemy);
2

However, now we can now check if the resulting pointer is valid before trying to use it. We can do that with a simple if check on the result of calling dynamic_cast.

1void Act(Character* Enemy) override {
2  if (dynamic_cast<Vampire*>(Enemy)) {
3    // enemy is a vampire
4    // TODO: call the stake function
5  } else {
6    // enemy is not a vampire
7    Enemy->TakeDamage(30);
8  }
9}
10

Within the if statement, we want to call the Stake function.

Stake is specifically a function that exists on Vampire. Enemy is a Character pointer, so we can't just do Enemy->Stake().

Instead, we could do the cast twice - once to check if it's a vampire, and again on line 4 to access the Stake function.

1void Act(Character* Enemy) override {
2  if (dynamic_cast<Vampire*>(Enemy)) {
3    // enemy is a vampire
4    dynamic_cast<Vampire*>(Enemy)->Stake();
5  } else {
6    // enemy is not a vampire
7    Enemy->TakeDamage(30);
8  }
9}
10

But it would be cleaner to just do the cast once, and save it in a variable that we can reuse:

1void Act(Character* Enemy) override {
2  Vampire* VampireEnemy {
3    dynamic_cast<Vampire*>(Enemy)
4  };
5  
6  if (VampireEnemy) {
7    VampireEnemy->Stake();
8  } else {
9    Enemy->TakeDamage(30);
10  }
11}
12

This technique only works with dynamic_cast. Static casting does not check if the cast is valid at run time. The pointer generated from a static_cast will always point to something.

When creating a variable using dynamic_cast, we always want to make sure it succeeds before trying to use it.

1void MakeNoise(Animal* SomeAnimal) {
2  static_cast<Dog*>(SomeAnimal)->Bark();
3}
4

When Dynamic Casting Fails

Something interesting might have caught our attention about the previous code example:

1Vampire* VampireEnemy {
2  dynamic_cast<Vampire*>(Enemy)
3};
4  
5if (VampireEnemy) {
6  VampireEnemy->Stake();
7} else {
8  Enemy->TakeDamage(30);
9}
10

Given how we're using the result of dynamic_cast within the if statement, it seems there are two possible outcomes:

• dynamic_cast returns a pointer to a Vampire, or
• dynamic_cast returns something that is false when used as a boolean

This is indeed true. Dynamic casting always returns a pointer but, if the cast failed, what we get is something called a null pointer. A null pointer is falsey, ie, if we treat it as a boolean like in our if statement above, it will be treated as the boolean value false.

What if we didn't check using the if statement? We may have ended up trying to dereferencing a null pointer using the * or -> operator. This will result in an error at run time - most likely a crash.

Therefore, when we create a pointer using dynamic_cast, we should always be considering the possibility that the cast failed before using the pointer it returned.

C++ Null Pointers (nullptr)

Any pointer can be a null pointer - they are not just the result of casting. Therefore, when using pointers, it is generally recommended to ensure the pointer we receive is valid before trying to dereference it.

In the below example, we are just returning from the function immediately. This means our specific function will not cause a crash.

1void Combat(Character* Player, Character* Enemy) {
2  if (!Player || !Enemy) {
3    cout << "Combat function received a null pointer!";
4    return;
5  };
6  Player->Act(Enemy);
7  Enemy->Act(Player);
8}
9

1void MakeNoise(Animal* Dog) {
2  Dog* SomeDog { dynamic_cast<Dog*>(SomeAnimal) };
3}
4

1if (SomeDog) SomeDog->Bark();
2

1try SomeDog->Bark();
2

1if (typeof SomeDog == Dog*) SomeDog->Bark();
2

Null pointers are not a bad thing. Often, our pointers should be null.

For example, our character class might have a Target* field, which is a pointer to the character that the player has currently selected.

If the player has not selected anything, having that field be a null pointer would be sensible.

Creating Null Pointers in C++

We often want pointers to start off as null pointers. If we do not explicitly give a pointer an initial value, it will point to some garbage location.

1int* SomePointer;
2cout << SomePointer;
3

This code logs out an arbitrary memory address, such as 0x7ffc0a866a60.

We use the nullptr token to set a value to the null pointer:

1int* SomePointer { nullptr };
2cout << SomePointer;
3

This code now logs out the memory address of simply 0, which we can think of as being "a pointer to nothing"

Having a pointer pointing to an arbitrary, unknown memory address can be a problem. Even if we run an if check on one of these pointers before trying to use it, that check will return true.

After all, an uninitialised pointer is not a null pointer. It actually is pointing to something, just not something we intended.

As a result, the following code will compile, but will result in unpredictable results when run - most likely a crash:

1class Character {
2public:
3  void Dance() {};
4};
5
6int main() {
7  Character* Pointer;
8
9  // This will be true - we are pointing to something
10  if (Pointer) {
11    // but it's almost certainly not pointing to a character
12    Pointer->Dance();  // crash!
13  }
14}
15

Because of this, if we do not have an initial value we want to use for a pointer, we should set it to be a null pointer explicitly, using the nullptr syntax:

1class Character {
2public:
3  void Dance() {};
4};
5
6int main() {
7  Character* Pointer { nullptr };
8
9  // This will be false now, and our code will be safe
10  if (Pointer) {
11    Pointer->Dance();
12  }
13}
14

1int* Pointer;
2

1int* Pointer { null };
2

1int* Pointer { nullptr };
2