Operator Overloading

In the previous lesson, we created a simple Vector3 struct to hold 3 numbers, which we could use to represent concepts like a position in a 3D world:

1struct Vector3 {
2  float x;
3  float y;
4  float z;
5}

It would be nice if we were able to use operators like + and += with our new custom type, in much the same way we were able to do with built-in types like int and float.

For example, we would like to be able to do things like this:

1Vector3 CurrentPosition { 1.0, 2.0, 3.0 };
2Vector3 Movement { 4.0, 5.0, 6.0 };
3
4// Create a new object using the + operator
5Vector3 NewPosition { CurrentPosition + Movement };

After running the above code, we'd want NewPosition to be a Vector3 with the values 5.0, 7.0, and 9.0.

For this, we need to overload operators.

Operators are Functions

In C++, operators are simply functions that have a specific name and parameter list.

When we write code like 1 + 2, the compiler is going to try to call a function with the following properties:

• Has the name of operator+
• Accepts an int as the first argument
• Accepts an int as the second argument

With that in mind, the function prototype that allows two our our Vector3 objects to use the + operator could have this prototype:

1void operator+(Vector3 a, Vector3 b);

It is up to us to define what an operator does, and what it returns. Naturally, when we see +, we’d expect that operator to add the two operands together, and return the result.

So let's update the function’s return type and body to do that:

1Vector3 operator+(Vector3 a, Vector3 b){
2  return Vector3{
3    a.x + b.x,
4    a.y + b.y,
5    a.z + b.z
6  };
7}

With that, we can now easily add our Vector3 objects together:

1#include <iostream>
2using namespace std;
3
4struct Vector3 {
5  float x;
6  float y;
7  float z;
8};
9
10Vector3 operator+(Vector3 a, Vector3 b){
11  return Vector3{
12    a.x + b.x,
13    a.y + b.y,
14    a.z + b.z
15  };
16}
17
18int main(){
19  Vector3 CurrentPosition{1.0, 2.0, 3.0};
20  Vector3 Movement{4.0, 5.0, 6.0};
21  Vector3 NewPosition{
22    CurrentPosition + Movement
23  };
24
25  std::cout
26    << "x= " << NewPosition.x
27    << ", y = " << NewPosition.y
28    << ", z = " << NewPosition.z;
29}

1x= 5, y = 7, z = 9

1Vector3 operator+(Vector3& a, Vector3& b){
2  return Vector3{
3    a.x + b.x,
4    a.y + b.y,
5    a.z + b.z
6  };
7}

Operand Order Matters

C++ does not consider an expression like A * B to be equivalent to B * A.

This has implications for our operator overloading. For example, if we wanted to give our Vector3 the ability to be multiplied by an int, we typically need to implement two variations.

We need to implement one where the int is the left operand, to support expressions like 2 * MyVector:

1// int * Vector3
2Vector3 operator*(int num, Vector3 vec) {
3  return Vector3{
4    vec.x * num, vec.y * num, vec.z * num
5  };
6}

And we need to implement a variation where the int is the right operand, to support expressions like MyVector * 2:

1// Vector3 * int
2Vector3 operator*(Vector3 vec, int num) {
3  return Vector3{
4    vec.x * num, vec.y * num, vec.z * num
5  };
6}

In situations like this, where the parameter order doesn’t change the output of our operation (that is, our operation is commutative), we can implement one function in terms of the other.

That is, if someone calls the Vector3 * int variation, we simply defer to the int * Vector3 implementation:

1// int * Vector3
2Vector3 operator*(int num, Vector3 vec) {
3  return Vector3{
4    vec.x * num, vec.y * num, vec.z * num
5  };
6}
7
8// Vector3 * int
9Vector3 operator*(Vector3 vec, int num) {
10  return num * vec;
11}

1Vector3 CurrentPosition { 1.0, 2.0, 3.0 };
2Vector3 Reverse { 4.0, 5.0, 6.0 };
3
4Vector3 NewPosition{CurrentPosition - Reverse};

1Vector3 CurrentPosition { 1.0, 2.0, 3.0 };
2
3Vector3 NewPosition { CurrentPosition * 5 };

1Vector3 operator* (Vector3 a, int b) {
2  return Vector3 {
3    a.x * b, a.y * b, a.z * b
4  };
5}

1Vector3 operator* (Vector3 a, Vector3 b) {
2  return Vector3 {
3    a.x * b, a.y * b, a.z * b
4  };
5}

1Vector3 operator* (int a, Vector3 b) {
2  return Vector3 {
3    b.x * a, b.y * a, b.z * a
4  };
5}

Overloading Operators with Member Functions

The previous examples implemented operator overloading using a standalone function, outside of any class or struct. These are sometimes referred to as free functions.

However, it is also possible to implement operators as a member function, within the relevant class or struct.

Let's see what the + operator might look like using that method:

1struct Vector3 {
2  float x;
3  float y;
4  float z;
5
6  Vector3 operator+ (Vector3 Other) {
7    return Vector3 {
8      x + Other.x,
9      y + Other.y,
10      z + Other.z
11    };
12  }
13};

The key thing to note in the declaration of operator+ as a member function is that there is only one parameter.

This might be confusing, as the + operator has two operands - a left and a right. When we created this as a free function earlier, we needed to have two parameters:

1Vector3 operator+ (Vector3 a, Vector3 b);

However, when we overload the operator as a member function, the function is called within the context of the left operand. So for example, an expression like x is accessing the x member of the left operand.

Therefore, there is no need to have the left operand be provided as an argument - we can just access its state in the same way we would from any other class function.

1struct Vector3 {
2  float x;
3  float y;
4  float z;
5
6  // Add a function here
7};
8
9Vector3 MyVector { 4.0, 5.0, 6.0 };
10Vector3 BigVector { MyVector * 3.0 };

1Vector3 operator* (float Other) {
2  return Vector3 {
3    x * Other,
4    y * Other,
5    z * Other
6  };
7}

1Vector3 operator* (Vector3 this, float Other) {
2  return Vector3 {
3    this.x * Other,
4    this.y * Other,
5    this.z * Other
6  };
7}

1Vector3 operator* (float Other) {
2  x *= Other;
3  y *= Other;
4  z *= Other;
5};

Unary Operators

The previous sections are all examples of binary operators. Binary operators have two operands - a left, and a right.

1// Add LeftOperand and RightOperand
2LeftOperand + RightOperand;

Some operators take only one operand - these are called unary operators. ++ is an example of a unary operand.

1// Increment SomeNumber
2SomeNumber++;

Some symbols, such as - can be used either as a unary or binary operand. The unary - is generally used to get the negative form of an operand, whilst the binary - is used to subtract the right operand from the left:

1int Number{5};
2
3-Number; // Return -5
4Number - Number; // Return 0

We implement unary and binary operators in exactly the same way. The only difference is the number of parameters our function will have:

• Overloading a binary operator as a standalone function will use 2 parameters
• Overloading a binary operator as a member function will use 1 parameter
• Overloading a unary operator as a standalone function will use 1 parameter
• Overloading a unary operator as a member function will use no parameters

Below, we overload the unary - operator using a member function:

1struct Vector3 {
2  float x;
3  float y;
4  float z;
5  
6  Vector3 operator-() {
7    return Vector3 { -x, -y, -z };
8  }
9};

1Vector3 operator-() {
2  return Vector3 { -this.x, -this.y, -this.z };
3}

1Vector3 operator-(Vector3) {
2  return {-Vector3.x, -Vector3.y, -Vector3**.**z};
3}

1Vector3 operator-(Vector3 a) {
2  return Vector3 { -a.x, -a.y, -a.z };
3}

Operator Prototypes and Definitions

Like any other member function, we can declare and define our prototypes in different locations, if we prefer:

1struct Vector3 {
2  float x;
3  float y;
4  float z;
5
6  // prototype
7  Vector3 operator+ (const Vector3& Other);
8};

1// definition
2Vector3 Vector3::operator+ (Vector3 Other) {
3  return Vector3 {
4    x + Other.x,
5    y + Other.y,
6    z + Other.z
7  };
8}

1--Position *= 2;

Summary

In this lesson, we introduced operator overloading, allowing us to extend the capability of our user-defined types, and interact with them in more expressive ways.

The key learnings are:

• Operators are implemented as simple functions in C++, with a specific naming convention using the word operator
• Operator overloads can be implemented using free functions or member functions, and which approach we choose has implications on what our function parameters will be
• Operators can be defined and declared in different locations, just like any other function

Next Lesson: Structured Binding

The upcoming lesson will introduce structured binding. This feature, a part of C++17, offers a more concise and readable way to handle simple types, such as the Vector3 we’ve been using in this lesson.

We’ll cover:

• Basics and syntax of structured binding.
• Practical application and examples of structured binding.
• Limitations on when it can be used.

Next Lesson

Structured Binding

This lesson introduces Structured Binding, a handy tool for quickly unpacking simple data structures

ContinueView Course