this pointer in C++ programming with some example code

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