Overloading Unary Operators in C++

In the previous lesson, we saw examples on how we could overload operators like + and *.

These are known as binary operators, as they have two operands - something to the left of the operator, and something to the right.

We've also seen examples of built-in types unary operators. Unary operators only have one operand.

Examples include the ++ operator to increment a number, and the ! operator to invert a boolean.

Unsurprisingly, we can also overload those operators on our custom types.

First, though, we should note something interesting - some operators can be either unary or binary.

The Unary - Operator

The - symbol is that it could represent a binary or a unary operation.

For example, when used with two integers, it performs subtraction:

1int x { 3 };
2int y { 2 };
3x - y; // 1
4

But we can use it with a single integer, it changes the sign:

1int x { 3 };
2-x; // 3
3

Lets see how we can make this operator work with our custom type.

Overloading Unary Operators

As you may have predicted, we can overload unary operators in the same way we do binary operators. The only difference is our operator function will have one fewer parameter.

That means, as a standalone function, it will only have one parameter:

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

And as a member function, it would have no parameters:

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

Prefix and Postfix Operators - What's the Difference?

We have previously seen the increment operator ++ in action with built in types like integers. After running the following code, MyNumber will be 6:

1int MyNumber { 5 };
2MyNumber++;
3

Specifically, this is called the postfix increment operator, because the ++ appears after the operand. There is also the prefix increment operator:

1int MyNumber { 5 };
2++MyNumber;
3

After running the above code, MyNumber will also be 6, just like when we used the postfix operator.

The difference is the value that is returned from each operator. The postfix operator will return the value of the int before it was incremented.

The prefix operator will return the value of the int after it was incremented.

This is relevant if we're immediately using the operator within an expression, such as a call to a function.

In the following example, both of our integers will eventually have a value of 11 but, on line 4 we call MyFunction with 10 whilst on line 5 we call it with 11.

1int MyNumber { 10 };
2int AnotherNumber { 10 };
3
4MyFunction(MyNumber++);
5MyFunction(++AnotherNumber);
6

Overloading C++ Prefix Operators

Overloading prefix operators work exactly like we've seen before. However, unlike with previous operators, something like ++ is expected to modify its operand.

Therefore, we will pass it as a reference that is not const.

As a standalone function, we could do something like this:

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

And as a member function:

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

Something to note about the previous examples is that they could also use the prefix operator on our floats to implement our function more concisely:

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

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

1(++MyVector) *= 5;
2

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

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

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

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

Overloading Postfix Operators

When we have a function called operator++, C++ has a very crude way of letting us specifiy that we're overloading the postfix operator.

We need to include an additional int parameter in our function. This int has no purpose, other than to tell the compiler that we're overloading the postfix operator. Conventionally, this int isn't even given a name:

1Vector3 operator++ (Vector3& a, int) {
2  // implementation here
3}
4

Lets implement our operator. To make the postfix ++ operator work in the way people would expect, we want it to increment our variable, but to return the value of the variable before it was incremented.

As long as we can do this in a single expression, we can just rely on the fact that the integer postfix ++ works that way by default:

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

Often though, our real world use cases won't be possible in a single line of code.

For those scenarios, we might want to start off by create a copy of our original object, modify the original object, and then return the copy:

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

Lets see how we could create this as a member function. Remember, we need the additional int parameter to flag that we're overloading the postfix operator:

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

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

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

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

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

The this Pointer in C++

So far, our ++ and -- operators have been modifying our original object, but then returning a copy of it. This is somewhat functional, but not ideal.

Lets imagine we wanted to chain operators. That might look something like this:

1Vector3 MyVector { 1.0, 2.0, 3.0 };
2(++MyVector) *= 2;
3

After we run this code, we might expect our vector to be { 4.0, 6.0, 8.0 }.

Unfortunately, it will be { 2.0, 3.0, 4.0 }.

Our ++ operator will increment it successfully. However, the ++ operator returns a copy rather than the original MyVector. The *= operator will then act on that copy, leaving MyVector unaffected.

Fortunately, our class and struct functions have access to a special variable, called this. This variable stores a pointer to the specific object that the function was invoked from.

1struct Vector3 {
2  float x;
3  Vector3* GetPointer() {
4    return this;
5  }
6  Vector3 GetObject() {
7    // We can dereference the pointer to get to the object
8    return *this;
9  }
10}
11
12Vector3 MyVector { 5 };
13Vector3* Pointer { MyVector.GetPointer() };
14int Five { Pointer->x };
15

Within our class functions, this pointer does not tend to be useful. After all, class code can access the variables on our object directly.

However, the this pointer is useful when our class functions are calling non-class functions, and those non-class functions need access to our object.

1class Vector3 {
2  int x;
3  void Act() {
4    LogX(this);
5  }
6};
7
8void LogX(Vector3* Vector) {
9  cout << Vector->x;
10}
11
12Vector3 MyVector { 5 };
13MyVector.Act();
14

Additionally, the this pointer is often useful as a return value from our class methods. This allows code outside our class to get access to our objects.

This is exactly what we need to solve our chained operator problem. Our operator functions need to return a reference to themselves, so we update the return type to be Vector3&.

To access the current object and return that reference, we use the this pointer:

1struct Vector3 {
2  float x;
3  float y;
4  float z;
5
6  Vector3& operator++ () {
7    x++;
8    y++;
9    z++;
10    return *this;
11  }
12
13  Vector3& operator*= (int Multiplier) {
14    x *= Multiplier;
15    y *= Multiplier;
16    z *= Multiplier;
17    return *this;
18  }
19}
20

When we create our operators this way, they can be chained as expected. After running the following code, MyVector will be { 4.0, 6.0, 8.0 }

1Vector3 MyVector { 1.0, 2.0, 3.0 };
2(++MyVector) *= 2;
3

Up next, we'll learn how to use automatic type deduction, which asks the compiler to figure out our data types for us!