Now it’s time to see some important points related to this pointer. We will also see where we should use this pointer in code.

1. In C++, “this” keyword is a prvalue expression. Which means “this pointer” is nonmodifiable, and assignment to this pointer is not allowed. ( Note: Earlier implementations of C++ allowed assignment to this).

2. “this pointer” isn’t part of the object itself. It’s not reflected in the result of a sizeof statement on the object. 

3. Friend functions do not have “this pointer”, because friends are not members of a class.

4. Nonstatic member functions of a class, struct, or union type only has the this pointer.

5. The type of this pointer in a member function of a class X is X*.

6. If the member function is declared const, the type of this is const X*, if the member function is declared volatile, the type of this is volatile X*, and if the member function is declared const volatile,the type of this is const volatile X*.

class X
{
    void test() const
    {
        // Type of this is const X*
    }
};


class X
{
    void test() volatile
    {
        // Type of this is volatile X*
    }
};


class X
{
    void test() const volatile
    {
        // Type of this is const volatile X*
    }
};

7. this pointer mostly use implicitly. But it’s legal to use this pointer explicitly when referring to members of the class. Let’s see an example,

class Test
{
    //member variable
    int m_data;
    
public:
    //non-static member function
    void value(int a);
};


void Test::value( int a )
{
    m_data = a;            // These three statements
    this->m_data = a;      // are equivalent
    (*this).m_data = a;
}

Thus in a const member function, the object for which the function is called is accessed through a const access path. Let’s see an example,

class Test
{
    int m_data;
public:
    //constructor
    Test():m_data(0)
    {

    }
    //non-const member function
    int g()
    {
        return m_data++;
    }

    //const member function
    int h() const
    {
        return m_data++;    // error
    }
};

The m_data++ in the body of Test::h is ill-formed because it tries to modify (a part of) the object for which Test::h() is called. This is not allowed in a const member function because this is a pointer to const( type of this pointer is const Test *)

8. When the local variable’s name is the same as the member’s name, then to avoid ambiguity we can use “this pointer”. 

#include 
using namespace std;


//class
class Test
{
    //member variable
    int m;
public:
    //non-static member function
    void value(int m)
    {
        // The 'this' pointer is used to
        //retrieve the object's m
        this->m = m;
    }

    void print()
    {
        cout << "m = " << m << endl;
    }
};


int main()
{
    Test testObj;

    testObj.value(6);

    testObj.print();

    return 0;
}

Output: m = 6

9. “this pointer” is also used to guard against self-reference. See the below expression.

// do not execute in cases of self-reference
if (&Object != this) 
{

}

10. Sometimes we use the expression *this to return the current object from a member function.

Test& Test::testFun ()
{
    // Some processing
    return *this;
}