Function Overloading

To overload functions, we simply define functions within the same scope, that have the same name, but have a different parameter list.

Below, we define a Rectangle and Circle type. Alongside each class, we provide standalone CalculateArea() functions:

1struct Rectangle {
2  float Width;
3  float Height;
4};
5
6float CalculateArea(const Rectangle& R){
7  return R.Width * R.Height;
8}

1struct Circle {
2  float Radius;
3};
4
5float CalculateArea(const Circle& C){
6  return 3.14 * C.Radius * C.Radius;
7}

When these functions are both available, they're considered overloaded.

Elsewhere, in code that uses our classes, we can use a consistent syntax. We can just pass an object to CalculateArea(SomeObject), and that expression adapts based on the type of SomeObject.

From the perspective of the consumer, it doesn't look like they're calling two different functions, rather it seems like they're calling a single, polymorphic function:

1int main(){
2  Circle MyCircle{2};
3  cout << "Circle Area: "
4    << CalculateArea(MyCircle);
5
6  Rectangle MyRectangle{3, 4};
7  cout << "\nRectangle Area: "
8    << CalculateArea(MyRectangle);
9}

1Circle Area: 12.56
2Rectangle Area: 12

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

Member functions can also be overloaded in the same way. Let's imagine we have the following situation, where our Character objects can equip weapons:

1class Weapon{};
2
3class Character {
4 public:
5  void Equip(Weapon* Weapon){
6    mWeapon = Weapon;
7  }
8
9 private:
10  Weapon* mWeapon{nullptr};
11};
12
13int main(){
14  Character Player;
15  Weapon WoodenSword;
16  Player.Equip(&WoodenSword);
17}

We'd like to be able to equip other items too. Our first instinct to accommodate this might be to rename our existing Equip() function to EquipWeapon(), and then add new functions called EquipArmor(), EquipShield(), and so on.

But we don't need to - we can just overload the Equip() function, keeping our class friendly to use:

1class Weapon {};
2
3class Shield {};
4
5class Character {
6public:
7  void Equip(Weapon* Weapon){
8    mWeapon = Weapon;
9  }
10
11  void Equip(Shield* Shield){
12    mShield = Shield;
13  }
14
15private:
16  Weapon* mWeapon{nullptr};
17  Shield* mShield{nullptr};
18};
19
20int main(){
21  Character Player;
22  Weapon WoodenSword;
23  Player.Equip(&WoodenSword);
24
25  Shield WoodenShield;
26  Player.Equip(&WoodenShield);
27}

When we're working with overloaded functions, we may see the compiler report errors, claiming our function calls are ambiguous.

In these scenarios, we often need to be more explicit about our data types.

An example of a simple program that falls foul of this rule is below:

1void Func(int Arg){}
2void Func(float Arg){}
3
4int main(){
5  Func(1.5);
6}

1'Func': ambiguous call to overloaded function

In an earlier note covering the concepts of literals, we pointed out that a literal like 1.5 is interpreted as a double, rather than a float. Float literals append an f, as in 1.5f.

So far, we have omitted the f to make our code easier to read for beginners, and because it generally doesn't matter - doubles can be implicitly converted to floats.

However, doubles can be implicitly converted to integers, too, which causes a problem in this context.

Without the f, our code is ambiguous. Should the compiler convert the double to an int and call Func(int)? Or should it convert it to a float and call Func(float)?

Rather than guessing our intentions, it asks us to clarify.

In the next lesson, we'll see how we can solve problems like this by being explicit about our conversions. For now, we can do it manually:

1void Func(int Arg){}
2void Func(float Arg){}
3
4int main(){
5  // Call Func(int)
6  Func(1);
7
8  // Call Func(float)
9  Func(1.5f);
10}

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

In this lesson, we explored several key concepts:

• Understanding Polymorphism and Overloading: We started by exploring polymorphism and explaining the main ways we can implement it in C++.
• Function Overloading with Different Types: We learned how to overload functions by creating functions with the same name but different parameters
• Overloading Member Functions: The concept was further extended to member functions in classes, illustrating a Character class that can equip different items like weapons and shields.
• Resolving Ambiguities in Overloaded Functions: We addressed potential ambiguities that arise with overloaded functions and how to resolve them