What is purpose of a “this” pointer in C++? [dupli

Question

This question already has answers here:

When should I make explicit use of the `this` pointer? (12 answers)

Closed 3 years ago.

What is purpose of this keyword. Doesn't the methods in a class have access to other peer members in the same class ? What is the need to call a this to call peer methods inside a class?

Answer 1

• Helps in disambiguating variables.
• Pass yourself as a parameter or return yourself as a result

Example:

struct A
{
    void test(int x)
    {
        this->x = x;                 // Disambiguate. Show shadowed variable.
    }
    A& operator=(A const& copy)
    {
        x = copy.x;
        return *this;                // return a reference to self
    }

    bool operator==(A const& rhs) const
    {
         return isEqual(*this, rhs); // Pass yourself as parameter.
                                     // Bad example but you can see what I mean.
    }

    private:
        int x;
};

Answer 2

1. Resolve ambgiguity between member variables/functions and those defined at other scopes
2. Make explicit to a reader of the code that a member function is being called or a member variable is being referenced.
3. Trigger IntelliSense in the IDE (though that may just be me).

Answer 3

Sometimes you want to directly have a reference to the current object, in order to pass it along to other methods or to store it for later use.

In addition, method calls always take place against an object. When you call a method within another method in the current object, is is equivalent to writing this->methodName()

You can also use this to access a member rather than a variable or argument name that "hides" it, but it is (IMHO) bad practice to hide a name. For instance:

void C::setX(int x) { this->x = x; }

Answer 4

It lets you pass the current object to another function:

class Foo;

void FooHandler(Foo *foo);

class Foo
{
    HandleThis()
    {
       FooHandler(this);
    }  
};

Answer 5

It also allows objects to delete themselves. This is used in smart pointers implementation, COM programming and (I think) XPCOM.

The code looks like this (excerpt from some larger code):

class counted_ptr
{
private:
    counted_ptr(const counted_ptr&);
    void operator =(const counted_ptr&);

    raw_ptr_type            _ptr;
    volatile unsigned int   _refcount;
    delete_function         _deleter;
public:

    counted_ptr(raw_ptr_type const ptr, delete_function deleter)
        : _ptr(ptr), _refcount(1), _deleter(deleter) {}
    ~counted_ptr() { (*_deleter)(_ptr); }
    unsigned int addref() { return ++_refcount; }
    unsigned int release()
    {
        unsigned int retval = --_refcount;
        if(0 == retval)
>>>>>>>>        delete this;
        return retval;
    }
    raw_ptr_type get() { return _ptr; }
};