Operators are a fundamental part of programming languages. They allow us to perform operations on `operands` by using a symbol. If you have ever written code, you probably know what this snippet does:

``````1
int a = 3 + 1;
``````

Variable `a` will be initialized to 4. It is initialized to this value, because the `+` operator has been used to add the values of 3 and 1. The `=` sign, is also an operator that assigns the value of the addition to the variable `a`.

We use these operators without thinking too much about them, but they are just symbols that perform a certain action, like any function we could define.

It turns out we can override the behavior of an existing operator. That’s what this article will focus on.

Overloading operators

The language doesn’t allow us to overload operators for primitive types, so we can’t make `3 + 1` give a different value. This is a good thing, because everybody would be very confused if they saw `3 + 1` is not `4`.

What we can do is define operators for our own custom types. Let’s look at an example:

``````1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#include <iostream>

class Counter {
public:
Counter operator+(const Counter& other) {
Counter result;
result.value = value + other.value;
return result;
}

int value = 0;
};

int main() {
Counter one;
one.value = 1;
Counter two;
two.value = 2;

std::cout << (one + two).value << std::endl;
}
``````

Running this code will print `3` to the console. Let’s take a closer look at `operator+` function:

``````1
2
3
4
5
Counter operator+(const Counter& other) {
Counter result;
result.value = value + other.value;
return result;
}
``````

To begin, we need to look at this as any other function. The return type is `Counter` and it takes a single argument of `Counter` type. The name of the function is `operator+`.

One way to overload an operator is to create a member function on a class and add a method prefixed with `operator` and then the operator we want to overload. Even though `+` is a binary operator, it takes a single argument. In the example above we are calling `one + two`. This is equivalent to calling `one.operator+(two)`.

The body of the function is very simple. It creates a new `Counter` and initializes its value to the sum of `one` and `two`.

The same code can be rewritten using an external function:

``````1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#include <iostream>

class Counter {
public:
int value = 0;
};

Counter operator+(const Counter& lhs, const Counter& rhs) {
Counter result;
result.value = lhs.value + rhs.value;
return result;
}

int main() {
Counter one;
one.value = 1;
Counter two;
two.value = 2;

std::cout << (one + two).value << std::endl;
}
``````

This is useful when the class has already been defined, but we still want to overload an operator for it.

We can also overload unary operators like `++`:

``````1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#include <iostream>

class Counter {
public:
void operator++() {
value++;
}

int value = 0;
};

int main() {
Counter c;
std::cout << c.value << std::endl;
++c;
std::cout << c.value << std::endl;
}
``````

This code will print `0` and `1` to the console.

One interesting thing about the previous example is that `++c` works, but `c++` doesn’t. To define the postfix version we need to have our function accept an `int`:

``````1
2
3
void operator++(int) {
value++;
}
``````

I’m not sure what’s the reason for this, but it allows for different implementations of the prefix and postfix versions if desired.

The last operator I want to show is the `[]` operator. This is often used by container types (like `vector`):

``````1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#include <iostream>

class Counter {
public:
int operator[](int index) {
return squares[index];
}

private:
int squares[3] = {1, 4, 9};
};

int main() {
Counter c;
std::cout << c[1] << std::endl;
}
``````

The function `operator[]` get’s called when we try to perform an array-like access to our custom object. In this example, the function only supports receiving an int, but we could potentially accept any type.

Conclusion

As you can see, overloading operators is not very complicated. Nevertheless, this functionality should be used with care. If we are going to overload an operator we should make an effort to make obvious what the operator will do for our custom type. In a lot of cases it is a lot clearer to just create a member function and call that function instead.