C++ Polymorphism

Before we introduce the next topic, lets take some time to explain the goal.

There's always many ways to solve a programming problem. But, which approach should we take?

Typically, a goal that we'll often here when it comes to software design is that we want our systems to be flexible, but not complex.

A common scenario where this comes up is the need to support a large range of object types, without getting bogged down.

In the context of a game, for example, that might include:

• lots of enemy types to fight in our combat system
• lots of quests to do in our questing system
• lots of items to select from for our equipment system

For example, when we build something like a combat system, we want to design it in such a way that each monster type has its own way of fighting.

We don't want to define all that within the combat system. We might have hundreds or thousands of monster types - imagine how complex our combat system would get.

Instead, we want to define those behaviours within the class code for each individual monster subtype. For example, the code that manages Dragons should be in the Dragon class.

What is Polymorphism?

Polymorphism is the key to combining a huge range of different objects, but to keep our systems simple.

Our system just needs to care about the base class of those subtypes. The base type might be Character, for example. Lets see a simplistic representation of our combat system:

1void Combat(Character* A, Character* B) {
2    A->Act();
3    B->Act();
4}
5

We want function calls like A->Act() to have different effects, depending on which subtype of character A is pointing at. For example, if A is a Goblin, the effect of this function call will be different than if A were a Dragon.

But, even though the behaviour of the Combat function is changing, its code doesn't. That is polymorphism.

To get it working in C++, we use a combination of four things. We've already seen the first three:

• Inheritance
• Pointers / References
• Function Overrides

Lets see an example that combines them:

1#include <iostream>
2using namespace std;
3
4class Character {
5public:
6  void Act() {
7    cout << "Character Attacking!" << endl;
8  }
9};
10
11class Goblin : public Character {
12public:
13  void Act() {
14    cout << "Goblin Attacking!" << endl;
15  }
16};
17
18void Combat(Character* A, Character* B) {
19    A->Act();
20    B->Act();
21}
22
23int main() {
24    Character Character;
25    Goblin Goblin;
26    Combat(&Character, &Goblin);
27}
28

Remember, we want the Combat function to support any subtype of Character, without requiring changes.

Here, we're passing it a Character and a Goblin. Whilst our code compiles and runs, sadly it isn't doing what we want just yet.

Given that B is specifically a Goblin, we want our Combat function to be calling the Goblin version of Act. Sadly, it's calling the Character version twice:

1Character Attacking!
2Character Attacking!
3

That's because we're missing the 4th key part of polymorphism - virtual functions. We'll introduce those in the next lesson!