Back to all concepts
Intermediate 11 min

this Pointer

Understand the this pointer that every member function receives and learn when to use it explicitly

Learn about the implicit this pointer that every member function receives and how to use it for method chaining and resolving name conflicts.

A Simple Example 

#include <iostream>
#include <string>

class Player {
private:
    std::string name;
    int health;
    int maxHealth;

public:
    Player(std::string name, int maxHealth)
        : name{name}, health{maxHealth}, maxHealth{maxHealth} {
        std::cout << "Player created: " << this->name << "\n";
    }

    void displayInfo() {
        std::cout << "Player: " << this->name
                  << " (HP: " << this->health << "/" << this->maxHealth << ")"
                  << "\n";
    }

    Player& takeDamage(int damage) {
        this->health -= damage;
        if (this->health < 0) {
            this->health = 0;
        }
        std::cout << this->name << " took " << damage << " damage" << "\n";
        return *this;  // Return reference to this object
    }

    Player& heal(int amount) {
        this->health += amount;
        if (this->health > this->maxHealth) {
            this->health = this->maxHealth;
        }
        std::cout << this->name << " healed " << amount << " HP" << "\n";
        return *this;
    }

    void showAddress() {
        std::cout << "This object is at address: " << this << "\n";
    }
};

int main() {
    Player hero{"Aria", 100};

    hero.showAddress();

    // Method chaining - possible because methods return *this
    hero.takeDamage(30).heal(20).takeDamage(10);

    hero.displayInfo();

    return 0;
}

Breaking It Down

What is this?

  • Implicit pointer: Every non-static member function receives a hidden this pointer
  • Points to current object: this holds the address of the object the function was called on
  • Type: For class Player, this has type Player* (pointer to Player)
  • Remember: You rarely need to write this-> explicitly, but it's always there

When to Use this Explicitly

  • Name conflicts: When parameter names match member names: this->name = name;
  • Method chaining: Return *this to enable obj.func1().func2()
  • Comparing addresses: Check if two references point to same object
  • Remember: Most of the time you don't need explicit this->

Method Chaining with return *this;

  • How it works: Return reference to current object with return *this;
  • Return type: Use ClassName& not void to enable chaining
  • Fluent interface: Allows readable code like player.heal(10).attack().move()
  • Remember: *this dereferences the pointer to get a reference to the object

this is a Pointer, Not a Reference

  • Access with arrow: Use this->member, not this.member
  • Can get address: this itself is the address of the object
  • Dereference for reference: *this gives you the object itself
  • Remember: this is a const pointer - you can't make it point elsewhere

Why This Matters

  • Every time you call a member function, C++ secretly passes a pointer to the object you called it on.
  • This `this` pointer is how member functions know which object's data to work with.
  • Understanding `this` unlocks advanced patterns like method chaining (think `cout << x << y << z`) and fluent interfaces that make code more readable and elegant.
  • It's also essential for avoiding naming conflicts and returning references to objects.

Critical Insight

When you write object.method(), C++ secretly calls it as method(&object) and the this parameter receives that address! So inside a member function, writing memberVariable is actually shorthand for this->memberVariable. The this pointer is always there, even when you don't see it.

This is why member functions can access member variables - they have a pointer to the object!

Best Practices

Avoid unnecessary this->: Only use explicit this-> when needed for clarity or resolving conflicts. Most of the time it's implied.

Return *this for fluent APIs: Enable method chaining by returning *this from methods that modify the object.

Use this for name conflicts: When constructor parameters match member names, use this->member = param;.

Check this carefully in callbacks: When passing member functions as callbacks, ensure proper object context.

Common Mistakes

Returning this instead of *this: Returning this gives a pointer, but for chaining you need a reference (*this).

Using this in static functions: Static member functions don't have a this pointer because they're not called on any specific object.

Confusion between -> and . with this: Remember this is a pointer, so use this->member, not this.member.

Unnecessary explicit this->: Writing this-> everywhere makes code verbose. Only use it when actually needed.

Debug Challenge

This constructor has a parameter name conflict. Click the highlighted line to fix it using this:

1 #include <string>
2
3 class Player {
4 std::string name;
5 int health;
6 public:
7 Player(std::string name, int health) {
8 name = name;
9 health = health;
10 }
11 };

Quick Quiz

  1. What type is the this pointer in a Player class?
`Player*`
`Player`
`Player&`
  1. What should a method return to enable method chaining?
`*this`
`void`
`this`
  1. Can you use this in a static member function?
No, static functions have no `this` pointer
Yes, always available
Yes, but only in C++17

Practice Playground

Time to try out what you just learned! Play with the example code below, experiment by making changes and running the code to deepen your understanding.

Lesson Progress

  • Fix This Code
  • Quick Quiz
  • Practice Playground - run once