What is meant by this pointer in C plus plus?

Answer 1

The this pointer is a hidden argument that is automatically generated by the compiler to refer to the current instance of an object.

Consider the following snippet:

class foo{};

void bar(foo* f){

std::cout<

}

int main()

{

foo f;

bar(&f);

return(0);

}

The function, bar, knows which instance of foo it is working on because we must explicitly pass a pointer to that instance (the address of f). However, if bar were a member of foo, we do not need to pass a pointer to the instance because the compiler does it automatically for us:

class foo {

void bar(){std::cout<

};

int main()

{

foo f;

f.bar();

return(0);

}

Although the second example is what we would physically write, it's really just sugar-coating. Behind the Scenes, it's as if bar() were a non-member function and is actually implemented as per the first example, where we passed the address of the instance into the function. This is because there is only ever one instance of the bar function (regardless of how many instances of foo we create), and the compiler needs some way of determining which instance of foo the bar function should work with -- thus it generates a this pointer for us and hides the actual implementation behind sugar-coated code.

The hidden this pointer is also used implicitly (behind the scenes) whenever you call member methods from within other member methods of the same class. However, you can invoke methods explicitly by dereferencing the this pointer if you want to. For instance, to invoke the bar() method from within another method of foo, you'd use the following call:

(*this).bar();

More typically, you'd use the points-to operator instead:

this->bar();

But since the this pointer is implicit, you don't need to explicitly dereference members like this unless it helps to clarify your code (such as when a member method operates upon other instances of the same class, and specifying this helps to clarify exactly which members you are invoking upon which instances).

However, the this pointer really comes into its own when you actually need to refer to the current instance, such as when performing self-reference checks and returning references to the current instance. A classic example is the assignment operator which typically requires both:

class foo {

public:

foo& operator=(const foo& rhs) {

if( this != &rhs ) {

// perform assignment

}

return(*this);

}

};