The this Pointer

Within our member functions, we have access to a specific keyword: this.

The this keyword stores a pointer to the object that our member function was called on.

For example, if we were to call SomeObject.SomeFunction(), within the body of SomeFunction(), the this keyword would contain a pointer to SomeObject.

Below, we show this in action. We’re logging out the address of SomeObject using the address-of operator, &.

Then we’re calling SomeFunction() on that same object, which is logging out the value of this:

1#include <iostream>
2using namespace std;
3
4struct SomeType {
5  void SomeFunction(){
6    cout << this;
7  }
8};
9
10int main(){
11  SomeType SomeObject;
12  cout << &SomeObject << '\n';
13  SomeObject.SomeFunction();
14}

We can see from the output that both of the memory addresses are the same:

1000000C05694FBF4
2000000C05694FBF4

Dereferencing this

We can use this like any pointer. We can store it in a variable or use it as an argument to a different function call.

We can also dereference it using the * operator to access the object itself. In the following example:

• the Pointer function returns a pointer to the current object, using this and a return type of SomeType*
• the Reference function returns a reference to the current object, using *this and a return type of SomeType&
• the Copy function returns a copy of the current object, using *this and a return type of SomeType

1struct SomeType {
2  SomeType* Pointer(){ return this; }
3  SomeType& Reference(){ return *this; }
4  SomeType  Copy(){ return *this; }
5};

There are many scenarios where the this pointer is useful. The rest of this lesson will focus on some applications.

Use Case 1: Identifying the Caller

Sometimes, our functions need to know who called them.

For example, let's imagine we have a Character class, where objects can Attack() each other.

When a character is attacked, they will likely want to know who attacked them, so they can react accordingly.

The this pointer can help us achieve that:

1#include <iostream>
2using namespace std;
3
4class Character {
5public:
6  Character(string Name) : mName{Name}{}
7
8  void Attack(Character& Target){
9    Target.TakeDamage(*this); 
10  }
11
12  void TakeDamage(Character& Attacker){
13    cout << Attacker.mName
14      << " has attacked me!";
15  }
16
17  string mName;
18};
19
20int main(){
21  Character Player{"Player One"};
22  Character Monster{"Goblin"};
23
24  Player.Attack(Monster);
25}

1Player One has attacked me!

Use Case 2: Chaining Function Calls

Another scenario where we might want to use this is to return the object that the method was called on.

This allows us to create APIs where member functions can be chained together. We show an example of this below, where we have two setters, each returning a Character&, that is, a reference to a Character.

We generate these by dereferencing the this pointer using the * operator:

1#include <iostream>
2using namespace std;
3
4class Character {
5public:
6  Character& SetName(string Name){
7    mName = Name;
8    return *this;
9  }
10
11  Character& SetLevel(int Level){
12    mLevel = Level;
13    return *this;
14  }
15
16  Character& Log(){
17    cout << "I am a " << mName
18      << " and I am level " << mLevel;
19    return *this;
20  }
21
22private:
23  string mName;
24  int mLevel;
25};
26
27int main(){
28  Character Enemy;
29
30  Enemy
31    .SetName("Goblin Warrior")
32    .SetLevel(10)
33    .Log();
34}

1I am a Goblin Warrior and I am level 10

Use Case 3: Overloading Operators

A final use case for the this pointer that is worth highlighting is related to chaining functions. Operators are functions too, and we sometimes want to chain them.

For example, operators such as ++ and *= are generally expected to be chainable. If our custom type supports these operators, an expression like this should be possible:

1(++x) *= 2;

The expectation here would be that x be incremented, and then its value doubled. For this to work correctly, the prefix ++ operator would need to return a reference to its operand - x in this case.

Therefore, if we wanted to implement these operators correctly for our custom type, we need to use the this keyword.

The following example is overloading the prefix form of the ++ operator, for use in expressions like ++SomeVector. We cover the postfix variation (to enable SomeVector++) later in the lesson.

1#include <iostream>
2using namespace std;
3
4struct Vector3 {
5  float x;
6  float y;
7  float z;
8
9  Vector3& operator++(){
10    ++x;
11    ++y;
12    ++z;
13    return *this;
14  }
15
16  Vector3& operator*=(int Multiplier){
17    x *= Multiplier;
18    y *= Multiplier;
19    z *= Multiplier;
20    return *this;
21  }
22};
23
24int main(){
25  Vector3 SomeVector{1.0, 2.0, 3.0};
26
27  (++SomeVector) *= 2;
28
29  cout << "x = " << SomeVector.x
30    << ", y = " << SomeVector.y
31    << ", z = " << SomeVector.z;
32}

1x = 4, y = 6, z = 8

1int main(){
2  Vector3 A{1.0, 2.0, 3.0};
3  Vector3 B{0.0, 0.0, 2.0};
4
5  A -= B;
6}

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

1struct Vector3 {
2  float x;
3  float y;
4  float z;
5
6  Vector3 operator-=(Vector3 Other){
7    x -= Other.x;
8    y -= Other.y;
9    z -= Other.z;
10    return *this;
11  }
12};

1struct Vector3 {
2  float x;
3  float y;
4  float z;
5
6  Vector3& operator-=(Vector3 Other){
7    x -= Other.x;
8    y -= Other.y;
9    z -= Other.z;
10    return *this;
11  }
12};

1#include <iostream>
2using namespace std;
3
4struct Vector3 {
5  float x;
6  float y;
7  float z;
8};
9
10Vector3& operator++(Vector3& vec){ 
11  ++vec.x;
12  ++vec.y;
13  ++vec.z;
14  return vec; 
15}
16
17Vector3& operator*=(Vector3& vec, int mult){ 
18  vec.x *= mult;
19  vec.y *= mult;
20  vec.z *= mult;
21  return vec; 
22}
23
24int main(){
25  Vector3 SomeVector{1.0, 2.0, 3.0};
26
27  (++SomeVector) *= 2;
28
29  cout << "x = " << SomeVector.x
30    << ", y = " << SomeVector.y
31    << ", z = " << SomeVector.z;
32}

1x = 4, y = 6, z = 8

Prefix and Postfix Operators

We have previously seen the increment operator ++ in action with built-in types like integers. Earlier in the course, we mentioned that the operator can go either before or after the operand.

These are two different operators, but there is a subtle difference in how they’re expected to work. Let's go through an example with the built-in int type.

After running the following code, MyNumber will be 6:

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

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;

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 is incremented. The prefix operator will return the value of the int after it is incremented.

This is relevant if we're immediately using the operator within an expression:

1#include <iostream>
2using namespace std;
3
4int main(){
5  int x{5};
6  cout << "x++: " << x++;
7  cout << " (x is now " << x << ")\n";
8
9  int y{5};
10  cout << "++y: " << ++y;
11  cout << " (y is now " << y << ")\n";
12}

Both operands eventually have the same value, but the postfix variant x++ returned the old value, whilst the prefix variant ++y returned the new value:

1x++: 5 (x is now 6)
2++y: 6 (y is now 6)

1void MyFunction(int x){};
2
3int main(){
4  int x{1};
5  MyFunction(x++);
6  MyFunction(++x);
7}

Overloading Postfix Operators

As we’ve seen above, we can overload the prefix operators in the same way we overload any other operator.

To overload a postfix operator, the syntax is a little inelegant. We need to specify an additional, unused int parameter in our function prototype. We typically don’t give this extra parameter a name.

So, to override the postfix ++ operator as a free function, it would look like this:

1Vector3 operator++(Vector3 Vec, int){
2  // ...
3}

Using a member function, it looks like this:

1struct Vector3 {
2  Vector3 operator++(int){
3    // ...
4  }
5};

The expected behavior of the postfix ++ operator is to increment the operand, but to return an object that had the original value, before the increment was applied.

To do this, we typically have three steps:

1. Create a copy of the object with its current value
2. Modify the object to increment it
3. Return the original copy

It looks like this:

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

Typically when we’re implementing the postfix operator, we’ve also implemented the prefix operator.

So our postfix operator can make use of it, allowing our code to be simplified to something like this:

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

1struct Vector3 {
2  float x;
3  float y;
4  float z;
5
6  // Prefix -- operator
7  Vector3& operator--(){
8    --x;
9    --y;
10    --z;
11    return *this;
12  }
13
14  // Postfix -- operator
15  // ???
16};

1Vector3 operator--(){
2  Vector3 temp{*this};
3  (*this)--;
4  return temp;
5}

1Vector3 operator--(int){
2  Vector3 temp{*this};
3  (*this)--;
4  return temp;
5}

1Vector3 operator--(int){
2  Vector3 temp{*this};
3  --(*this);
4  return temp;
5}

1Vector3 operator--(int){
2  --(*this);
3  return *this;
4}

Summary

In this lesson, we explored the this pointer, a fundamental concept for understanding object-oriented programming in this language.

We began by explaining what the this pointer is — a special pointer that points to the object for which a member function is called. We then delved into various practical applications:

1. Dereferencing this: We discussed how this can be dereferenced to access the object itself and how it can be used to access a pointer, a reference, or a copy of the object.
2. Identifying the Caller: We examined a use case where this helps in identifying which object called a member function, allowing our objects to interact with each other in more complex ways.
3. Chaining Function Calls: We showed how this can be used to return the current object, enabling the chaining of member function calls for more fluent and readable code.
4. Overloading Operators: We also covered how this plays a crucial role in overloading operators like ++ and *= to ensure our custom types are consistent with built-in types.

Preview: Returning References and Pointers from Functions

In the next lesson, we delve into pointers and references to local variables. Key focus areas will include:

• Understanding the lifespan of local variables and the risks associated with returning pointers or references to them.
• Exploring scenarios where returning a pointer or reference to a local variable can lead to undefined behavior.
• Learning best practices to avoid common pitfalls when dealing with pointers and references to local variables.

This lesson will equip you with the knowledge to write bug-free code, especially when dealing with functions and their return values.

Next Lesson

Dangling Pointers and References

Learn about an important consideration when returning pointers and references from functions

ContinueView Course