Person::name and this->name difference?

Code:

void Person::setname(string name)
{

    Person::name = name;
    cout<<Person::name;
}

Code:

void Person::setname(string name)
{

    this->name = name;
    cout<<Person::name;
}

I know this(keyword) is a pointer that points to the current object that has called setname function.

But I want to know what's the difference between using
Person::name and this->name.

In this case, there is no difference. If you had a class that was derived from class Person and that adds an additional attribute also called "name" and you wanted to get access to the Person class's "name" attribute, then you could only do it via Person::name. If you just said "this->name", you'd get the derived class's "name" attribute instead.

Wow, 16 hours have passed, and nobody has corrected the above posted. Heck, there's even a "like" on it!

No, they are not the same. Person::name refers to a static class member. Being static means that there is only one name in the entire program. Every Person object would be associated with the name "Bob" for example.

this->name refers to a normal class member. In this case there is a separate name for each instance of the Person class.

You cannot use the two interchangably.

Originally Posted by iMalc

Wow, 16 hours have passed, and nobody has corrected the above posted. Heck, there's even a "like" on it!

I did not bother checking since I vaguely recalled something about this kind of disambiguation being used similiar to what antred mentioned.

Originally Posted by iMalc

No, they are not the same.

Because of the caveat "in this case", antred does not appear to dispute that.

EDIT:

Originally Posted by iMalc

Person::name refers to a static class member. Being static means that there is only one name in the entire program. Every Person object would be associated with the name "Bob" for example. (...) You cannot use the two interchangably.

g++ 4.6.3 and the Comeau online compiler compile this test program without any warnings:

Code:

#include <iostream>

class X
{
public:
    X() : n(1) {}

    virtual ~X() {}

    virtual void foo() const
    {
        std::cout << n << std::endl;
    }
protected:
    int n;
};

class Y : public X
{
public:
    Y() : n(2) {}

    void setN(int n)
    {
        Y::n = n;
    }

    virtual void foo() const
    {
        std::cout << X::n << ',' << Y::n << std::endl;
    }
private:
    int n;
};

int main()
{
    Y y;
    y.foo();
    y.setN(3);
    y.foo();
}

When run after being compiled by g++ 4.6.3, the output is:

Code:

1,2
1,3

EDIT #2:
Oh, but of course, one oft-cited case of the use of this is when a name foo in a derived class D hides members of the same name in the base class B. A using declaration like using B::foo; in the definition of D would then be appropriate, even if the members named foo in the base class are non-static.

Person::name refers to a static class member.

In my class. I have not declared name as static. But it still both code compiles fine?

Originally Posted by freiza

In my class. I have not declared name as static. But it still both code compiles fine?

The point of Person::name when name is static is so you can access the variable without an object, but if you access name through an object there is no difference.

Originally Posted by iMalc

Wow, 16 hours have passed, and nobody has corrected the above posted. Heck, there's even a "like" on it!

No, they are not the same. Person::name refers to a static class member.

Not in this case, iMalc. Specifying a fully qualified name merely distinguishes between several attributes that happen to have the same name. It does not say anything about whether that attribute is necessarily static or not.

Please, try to for yourself.

Code:

#include <iostream>

class Person
{
public:
    Person() : age( 40 ) {}

protected:
    const int age;
};

class Student : public Person
{
public:
    Student() : age( 16 ) {}

    void print() const;

private:
    const int age;
};

void Student::print() const
{
    std::cout << "Person::age = " << Person::age << std::endl;
    std::cout << "Student::age = " << Student::age << std::endl;
    std::cout << "age = " << age << std::endl;
}


int main()
{
    const Student a;
    a.print();
}

Output:

Person::age = 40
Student::age = 16
age = 16


EDIT: Nevermind, I see laserlight has already posted a very similar test program.

Yeah alright, I simply forgot for a moment that it didn't necessarily mean that it was static.
On the plus side, we now have a lot more informative information in this thread.