C++ Operator Overloading

In the previous lesson, we created a simple Vector3 struct to hold 3 numbers, represending a 3D position:

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

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 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 };
6

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

We'd also like to be able to do the following, to update the CurrentPosition vector directly:

1Vector3 CurrentPosition { 1.0, 2.0, 3.0 };
2Vector3 Movement { 4.0, 5.0, 6.0 };
3
4// Update an existing object using the += operator
5CurrentPosition += Movement;
6

For this, we need to overload operators.

C++ 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 a name of operator+
• Accepts an int as the first argument
• Accepts an int as the second argument

With that in mind, lets create a function to be the + operator that can be used with two Vector3 objects:

1void operator+ (Vector3 a, Vector3 b) {
2
3}
4

With those additions, we can now write the following code, and have our program compile successfully:

1CurrentPosition + Movement;
2

Of course, we want that expression to actually return a useful value. So, lets implement our function, by updating its return type, and adding an appropriate return statement:

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

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

There are some improvements we can make. Our function is currently accepting the structs by value. We can change this to be pass by reference instead, as we have no need to create a copy of our incoming objects.

Further, since our operator is not modifying the input objects, we can make those references const.

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

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

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

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

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

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

Overloading C++ Operators with Member Functions

The previous examples implemented operator overloading using a standalone function. However, it is also possible to implement it by having our function be a member of our struct or class.

Lets 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+ (const Vector3& Other) {
7    return Vector3 {
8      x + Other.x,
9      y + Other.y,
10      z + Other.z
11    };
12  }
13};
14

1Vector3 MyVector { 1.0, 2.0, 3.0 };
2Vector3 OtherVector { 1.0, 2.0, 3.0 };
3Vector3 CombinedVector { MyVector + OtherVector };
4

The key thing to note in the declaration of operator+ within the struct is that there is only one parameter.

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

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

However, when when we overload the operator as a member function, the function is called within the context of the left operand. Therefore, there is no need to have the left operand be provided as an argument - we can just access its class members in the same way we would 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 };
11

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

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

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

Like any other class or struct function, we can declare and define them in different locations, if we want. This would be useful if we want to have a seperate .h and .cpp file:

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

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

This lesson focused on overloading binary operators. Binary operators are those that take two operands - a left and a right.

We've also seen unary operators in the past, like ++, *= and !. These operators only operate on one object.

We'll see how we can overload those in the next lesson!