Thread: this pointer

The 'this' pointer refers to whatever instance of the class you are working with.

Code:

class Foo
{
    public:
        Foo( ) { x = 10; }
        void Bar( ) { cout << this->x; }

    private:
        int x;
};

If you create an instance:

Foo FooBar;

The "this" pointer refers to FooBar.

Quzah.

Thanks Quzah.
What about in the following code:

Code:

//copy constructor
Person::Person (Person const &other)
{
    //unconditionally copy other's data
   copy(other);
}
//destructor
Person::~Person()
{
    //unconditionally deallocate
    destroy();
}
//overloaded assignment
Person const &Person :: operator=(Person const &other)
{
    //only take action if no auto-assignment
    if(this != &other);
   {
         destroy();
         copy(other);
   }
    // return (reference to) current object for
    // chain-assignments
    return (*this);  
}

"This" refers to "other". Is that right?

>> "This" refers to "other". Is that right?

No. As stated, the 'this' pointer was invented for the necesity of referring to the object itself when writing member function code. Nothing else.

Now when you see:

>> if(this != &other)

...you are just verifying that something like this didn't happen:

Person x;

x = x;

That's it.

OK, after more reading of the book the code came from and others and after some more pondering...
'this' refers to 'operator' (the current object) and 'other' refers to an actual Person object. '&other' is a reference to or 'alias' to an actual Person object.
'*this' refers to the left hand operand of the overloaded '=' operator.
I'll assume this is correct if I'm not contradicted.

Think of an ordinary pointer, and how it is dereferenced to obtain the value it points to:

int num = 10;
int * ptr = #
cout << *ptr << endl; // prints '10'

So 'this' is a pointer to the current object, and '*this' is the current object.

Originally posted by kes103
OK, after more reading of the book the code came from and others and after some more pondering...
'this' refers to 'operator' (the current object) and 'other' refers to an actual Person object. '&other' is a reference to or 'alias' to an actual Person object.
'*this' refers to the left hand operand of the overloaded '=' operator.
I'll assume this is correct if I'm not contradicted.

No. Say I have this:

Code:

class C{
public:
  int f();
  const C& operator=(const C&);
};

int main(){
  C obj1, obj2, obj3;

  obj1.f(); // inside this call, this points at obj1
  obj3.f(); // inside this call, this points at obj3
  obj2 = obj3; // inside this call, this points at obj2
  obj2.operator=(obj3); // this is exactly the same as the line above.

}

this is a pointer to the current object. It's the object upon which the method is being called. Operators, functions, etc. are not objects. An object is an instance of a class, just as a traditional variable is an instance of a primitive (int, bool, etc.). In the above code, there are only three objects -- obj1, obj2, and obj3. f() is a method, not an object. Similarly, the operator is not an object either.

Thanks, ygfperson, but were you aware that I was referring to the code I posted on 7/23/03 and not operator=() in general.
As another example, consider this code from another book:
"The definition of += follows below. Notice how *this is used in the return statement. It is the object that will be the left-hand operand of the operator +=."

Code:

Rational& Rational :: operator += (const Rational &r)
{
    num_ = r.num_ + denom_ + r.denom_ * num_;
    denom_ *= r.denom_;
    reduce();
    return *this;
}

So, 'this' points to the object that will be the left operand or the current object and '*this' is the object that will be the left-hand operand of the += operater or the current object.
Also, thanks, Sebastiani for your post. I didn't see it before.

I read the replies in this topic and it was all about operators and complicated code etc. Not sure why you bring operators up. As far as I understand your problem, it's pretty simple to explain "this". The fact that most of the replies are that complicated makes me wonder if I maybe misunderstand your question. Anyway, I'll give it a try.

If the 'this pointer' is a variable that refers to the current object within a class, then what is the current object?

The 'this pointer' refers to the current instance (the object) of a class. It does not refer to the class itself nor does it refer to anything "within" a class.

Since you talk about objects as if you were thinking they were code structures "within" the class, I'll give a short explanation of what the difference between objects and classes is:

Imagine a class as the blueprint for all objects of the same type. A class defines which methods (hopefully thats the right term in C++) and variables are available to all objects that are built with this particular "blueprint". Each of these object's has a "this pointer" that points to the object itself, therefore every object's "this pointer" points to a different location in memory than the other objects their "this pointers". this is only available from within the objects. (Of course you use it in the classdefinition, but like anything else there, it doesn't hold any information. It's just a piece of the blueprint.)

So whats the use of of a pointer to oneself?

There isn't *that* much use for it, but it isn't useless either. Sometimes you just need it.

This Webpage explains it quite good and gives examples. The first one is pretty cool. Good way to produce code nobody understands and - as a note for cat - ugly code