Understanding Operator Overloading in C++

In this article, you will start to understand operator overloading in C++.

What is it?

Operator Overloading can give a special behavior (or meaning) to an operator when it is applied to an instance of a class or a user-defined data type.

The problem

For example, what happens if we have two instances of a class and we try to add one with another? The compiler in that case doesn't know what to do, then will throw an error.


class Color {
public:
    Color(name) 
        : name(name) {}

    std::string name;
};

int main() {
    Color green("Green");
    Color red("Red");

    Color yellow = green + red;
    // error: no match for 'operator+' (operand types are 'Color' and 'Color')
    return 0;
}

Have you seen it? We are not able to add the colors because the compiler doesn't know the operator's behavior.

Different operators can be overloaded, here are a few:

Addition: +
Subtraction: -
Multiplication: *
Division: /
Equality: ==
Addition assignment: +=
Logical AND: &&

How does it work?

Well, let me give you an example.

Do you remember Cell from Dragonball Z? With his Absorption technique, he can absorb an opponent and his strength.

We can try to replicate the Cell Absorption Technique in code by overloading the plus (+) operator.

enum Kind {
    Human,
    Android
};

class Character {
public: 

    Character(string name, Kind kind, float strength)
        : name(name), kind(kind), strength(strength) {}

    string name;
    Kind kind;
    float strength;
    bool isAlive{true};
};

int main() {
    return 0;
}

In the code above we have an Enum, which helps to identify the Character Kind,

and a Character Class with its constructor and some member variables.

Now we can write the operator function inside the class

Character operator+ (Character& c) {
    if(kind == Kind::Android) {
        c.isAlive = false;
        // Here we simply return a Character, but with the strength addition
        return Character(name, kind, strength + c.strength);
    } else {
        // If the charactor is not an Android, just return it.
        return Character(name, kind, strength);
    }
}

🧐
As we can observe, the syntax is the following

return_type operator symbol (arguments) {
    // ....
}

Let's initialize two characters

int main() {
    Character Cell("Cell", Kind::Android, 9000.0);
    // Name: Cell
    // Kind: Android
    // Strength: 9000.0
    // isAlive: true

    Character Krillin("Krillin", Kind::Human, 750.0);
    // Name: Krillin
    // Kind: Human
    // Strength: 750.0
    // isAlive: true

    return 0;
}

Now Cell can use his technique on Krillin!

int main() {
    Character Cell("Cell", Kind::Android, 9000.0);
    Character Krillin("Krillin", Kind::Human, 750.0);

    // Absorption!
    Cell = Cell + Krillin;

    Cell.name; // Cell
    Cell.kind; // Android
    Cell.strength; // 9750.0
    Cell.isAlive; // true

    Krillin.name; // Krillin
    Krillin.kind; // Human
    Krillin.strength; // 750.0
    Krillin.isAlive; // false

    return 0;
}

Pretty straightforward right?

As you can see, the Cell's strength has increased to 9750.0. This was achieved by "absorbing" Krillin's strength with the help of the overloaded plus operator!

Let's put it all together 👇

#include <iostream>
#include <string>
using std::string;

enum Kind {
    Human,
    Android
};

class Character {
public: 

    Character(string name, Kind kind, float strength)
        : name(name), kind(kind), strength(strength) {}

    Character operator+ (Character& c) {
        if(kind == Kind::Android) {
            c.isAlive = false;
            // Here we simply return a Character, but with the strength addition
            return Character(name, kind, strength + c.strength);
        } else {
            // If the charactor is not an Android, just return it.
            return Character(name, kind, strength);
        }
    }

    string name;
    Kind kind;
    float strength;
    bool isAlive{true};
};

int main() {
    Character Cell("Cell", Kind::Android, 9000.0);
    Character Krillin("Krillin", Kind::Human, 750.0);

    // Absorption!
    Cell = Cell + Krillin;

    Cell.name; // Cell
    Cell.kind; // Android
    Cell.strength; // 9750.0
    Cell.isAlive; // true

    Krillin.name; // Krillin
    Krillin.kind; // Human
    Krillin.strength; // 750.0
    Krillin.isAlive; // false

    return 0;
}

Implementing a Vector2

We can write another more practical example by making a simple implementation of a Vector2, let's do it!

(For those who don't know, a Vector2 defines a position in space)

Here we have a class called Vector2

class Vector2 {
public:
    Vector2()
        : x(0.0), y(0.0) {}

    Vector2(int x, int y)
        : x(x), y(y) {}

    // Vector2 + Vector2
    Vector2 operator+ (Vector2 const& _vec2) {
        return Vec2(x + _vec2.x, y + _vec2.y);
    }

    // Vector2 += Vector2
    Vector2& operator+= (Vector2 const& _vec2) {
        x += _vec2.x;
        y += _vec2.y;

        // Return the left-hand Vector2
        return *this;
    }

    // Vector2 == Vector2
    bool operator== (Vector2 const& _vec2) {
        if (x == _vec2.x && y == _vec2.y)
            return true;
        else
            return false;
    }

    float x, y;
};

Now that we have written the behavior of those operators let's see what happens in the code. Assume that we are making a videogame and there are two Actor:

AHero
AMonster

Those Actors have different positions.

// Initialize actors
Vector2D AHero(3.0, 1.0);
Vector2D AMonster(5.0, -3.0);

Using the + operator

AHero = AHero + Vector2(1.0, 1.0);
// AHero now has a new position

std::cout << AHero.x << " : " << AHero.y << std::endl;
// 4.0 : 5.0

Using the += operator

AHero += Vector2(3.0, -5.0);
// AHero now has a new position

std::cout << AHero.x << " : " << AHero.y << std::endl;
// 6.0 : -4.0

Using the == operator

// Initialize actors
Vector2D AHero(3.0, 1.0);
Vector2D AMonster(5.0, -3.0);

// The hero moves
AHero += Vector2(1.0, 1.0); // 4.0, 2.0

// The monster moves to the hero position
AMonster = AMonster + Vector2(-1.0, 5.0);

// Now we check if the two actor are in the same position.
// In this case, the hero dies.
if (AHero == AMonster) {
    // The monster kills the hero.
    // ...    
} else {
    // The hero will live.
    // ...
}