Static Overloading in C++

We have been using a TakeDamage function quite a lot in previous examples. It is a simple function that allows our Characters to take an integer amount of damage:

1// Take 30 Damage
2Character.TakeDamage(30);
3

However, it might be useful to have another version of that function. Instead of taking an integer amount of damage, that function could let our characters take a percentage of their health as damage.

We could call that version by passing a floating point number:

1// Take 20% damage
2Character.TakeDamage(0.2f);
3

This approach of having multiple functions with the same name is an example of static overloading. Lets see how we can set this up!

Overloading Functions in C++

This behaviour, where we have a function with the same name, but with different parameter types, is called an overloaded function.

The way we create it is perhaps exactly like you'd expect. We simply define two functions with the same name - one that accepts an integer, and the other that accepts a float:

1class Character {
2public:
3  void TakeDamage(int Damage) {
4    Health -= Damage;
5  };
6  void TakeDamage(float Percent) {
7    Health *= (1-Percent);
8  };
9private:
10  int Health { 150 };
11}
12

1bool GetBool(float Number) { return true; }
2bool GetBool(int Number) { return false; }
3
4bool MyBool { GetBool(5) };
5

Improving the Design with Wrapping Functions

In the real world, our TakeDamage functions are likely to be a lot more complicated than the simple example above. For example:

1class Character {
2public:
3  void TakeDamage(int Damage) {
4    Health -= Damage;
5    PlayAnimation();
6    RenderEffects();
7    PlaySound();
8    UpdateAI();
9    UpdateHealthBar();
10  };
11  void TakeDamage(float Percent) {
12    Health *= (1-Percent);
13    PlayAnimation();
14    RenderEffects();
15    PlaySound();
16    UpdateAI();
17    UpdateHealthBar();
18  };
19private:
20  int Health { 150 };
21}
22

These functions are now duplicating code, and will be difficult to maintain in the future.

A common pattern to deal with this is to have only one function be our primary version, where all the heavy work is done.

The overloaded versions can just be simple wrappers that convert arguments to the appropriate values, then defer to the primary version of the function. That might look something like this:

1class Character {
2public:
3  void TakeDamage(int Damage) {
4    Health -= Damage;
5    PlayAnimation();
6    RenderEffects();
7    PlaySound();
8    UpdateAI();
9    UpdateHealthBar();
10  };
11  void TakeDamage(float Percent) {
12    int Damage { Health * Percent };
13    TakeDamage(DamageToInflict)
14  };
15private:
16  int Health { 150 };
17}
18

Now, we have the primary TakeDamage function, where most of our effort can be focused. The float version of our function is just a simple wrapper around it.

1bool GetBool(float Number) { return true; }
2bool GetBool(int Number) { return false; }
3
4bool MyBool { GetBool(5.0) };
5

The next lesson will introduce Static Casting.

Casting is how we can take full control of the data conversion process. It lets us explicitly issue instructions to convert our data into different types. This means we're taking full control of the process, and not always relying on implicit conversion as we have been thus far.