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

Answer 1

For example if you write an operator=() you must check for self assignment.

class C {
public:
    const C& operator=(const C& rhs)
    {
        if(this==&rhs) // <-- check for self assignment before anything
            return *this;
        // algorithm of assignment here
        return *this; // <- return a reference to yourself
    }
};

Answer 2

Two main uses:

1. To pass *this or this as a parameter to other, non-class methods.

   void do_something_to_a_foo(Foo *foo_instance);
   
   void Foo::DoSomething()
   {
       do_something_to_a_foo(this);
   }
   

2. To allow you to remove ambiguities between member variables and function parameters. This is common in constructors.

   MessageBox::MessageBox(const string& message)
   {
     this->message = message;
   }

   (Although an initialization list is usually preferable to assignment in this particular example.)

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

Answer 5

One more purpose is to chaining object: Consider the following class:

class Calc{
private:
    int m_value;

public:
    Calc() { m_value = 0; }

    void add(int value) { m_value += value; }
    void sub(int value) { m_value -= value; }
    void mult(int value) { m_value *= value; }

    int getValue() { return m_value; }
};

If you wanted to add 5, subtract 3, and multiply by 4, you’d have to do this: #include int main() { Calc calc; calc.add(5); // returns void calc.sub(3); // returns void calc.mult(4); // returns void

    std::cout << calc.getValue() << '\n';
    return 0;
}

However, if we make each function return *this, we can chain the calls together. Here is the new version of Calc with “chainable” functions:

class Calc
{
private:
    int m_value;

public:
    Calc() { m_value = 0; }

    Calc& add(int value) { m_value += value; return *this; }
    Calc& sub(int value) { m_value -= value; return *this; }
    Calc& mult(int value) { m_value *= value; return *this; }

    int getValue() { return m_value; }
};

Note that add(), sub() and mult() are now returning *this. Consequently, this allows us to do the following:

#include <iostream>
int main()
{
    Calc calc;
    calc.add(5).sub(3).mult(4);

    std::cout << calc.getValue() << '\n';
    return 0;
}

We have effectively condensed three lines into one expression.

Copied from :http://www.learncpp.com/cpp-tutorial/8-8-the-hidden-this-pointer/

Answer 6

The this pointer is a way to access the current instance of particular object. It can be used for several purposes:

• as instance identity representation (for example in comparison to other instances)
• for data members vs. local variables disambiguation
• to pass the current instance to external objects
• to cast the current instance to different type