#关于C++中this指针#不能用this指针给对象赋值吗

不是one没赋给three,而是num three = oneequal()这句调用的是拷贝构造函数num(num&);

网上搜一下初始化与赋值的区别吧

而你拷贝构造函数num(num&)里并没有给内部成员初始化或者赋值。

顺便说一句，正确的拷贝构造函数是num(const num& ); const最好要有。

num(const num& pr):n(prn)
{
}

this指针是一个隐含于每一个成员函数中的特殊指针。它是一个指向正在被该成员函数 *** 作的对象,也就是要 *** 作该成员函数的对象。
它是一个指针，它绝对不能被当作类的实例。例如this并不是在所有类函数中都有效比如构造函数。
当对一个对象调用成员函数时，编译程序先将对象的地址赋给this指针，然后调用成员函数，每次成员函数存取数据成员时，由隐含作用this指针。而通常不去显式地使用this指针来引用数据成员。同样也可以使用this来标识调用该成员函数的对象。
这些都是由编译器隐式完成的，程序员一般不关心。
常见用法有：
1
CXXX::Func()
{
m_pObject->SetParent(this);
}
2
CXXX::Func()
{
this-> // then you will see all the members in CXXX
}
3
CXXX::Sucide()
{
delete this;
}
4
CXXX& operator =(CXXX &xxx)
{

楼上的回答的很好，另外加一点，对于非静态成员函数，他有一个隐含的参数就是this指针。
所以如果有A::b(int,int)这个函数，系统调用时，其实会这样调用b(int,int,this)，其中this就是指向A类的一个对象的指针。static成员函数是没有隐含this指针这个参数的，原因是static函数是类的函数，与类的具体对象无关，所以自然不会传this指针给这种类型的函数。

this指针是一个隐含于每一个成员函数中的特殊指针。它是一个指向正在被该成员函数 *** 作的对象,也就是要 *** 作该成员函数的对象。
当对一个对象调用成员函数时，编译程序先将对象的地址赋给this指针，然后调用成员函数，每次成员函数存取数据成员时，由隐含作用this指针。而通常不去显式地使用this指针来引用数据成员。同样也可以使用this来标识调用该成员函数的对象。下面举一例子说明this指针的应用。
#include <iostreamh>
class A
{
public:
A() { a=b=0; }
A(int a, int b) { thisa=a; thisb=b; }
void copy(A &aa); //对象引用作函数参数
void print() {cout<<a<<","<<b<<endl; }
private:
int a, b;
};
void A::copy(A &aa)
{
if (this == &aa) return; //这个this是 *** 作该成员函数的对象的地址，在这里是对象a1的地址
this = aa; //this是 *** 作该成员函数的对象，在这里是对象a1。
//此语句是对象aa赋给a1，也就是aa具有的数据成员的值赋给a1的数据成员
}
void main()
{
A a1, a2(3, 4);
a1copy(a2);
a1print();
}
再具一个C++primer上的例子
class screen
{


screen &move(x,y);
screen& print();


}
screen& screen::move(x,y)
{


return this;
}
这样在使用这个类的时候可以这样用：
screen myscreen;
myscreenmove(50,50)print();
不知道这样说你能了解多少？

有点意思，举个例子：
int i;
如上，随便定义一个变量，现在，你能改变变量i的地址么？原则上，从高级语言的角度来说，改变i的地址是不可能的，因为i的地址是编译器设定的。同样，如果i是某个类的对象，一样不能改变i的地址，而this指针就是对象地址的别名，因此通常无法改变。我说“通常”是指在C++语言这个层面上是无法改变的，除非你对C++编译器编译完的目标代码进行修改。另外，如果你想改变this的指向，也不需要直接修改this，而只需要将this加上某个偏移值就行了，比如(this+12)->funname();但是要考虑到指针的安全性问题。希望回答对你有帮助。

你的代码写的没有问题，主要是你没有理解c++的拷贝构造函数的原理，存在深拷贝和浅拷贝。

oldday = newday = birthday;这一连串的赋值语句，中间执行是非常的复杂的。

我们一个个分析下，newday=birthday这句赋值语句首先会产生个临时的对象。birthday会将其值赋值给临时对象。然后临时对象将将赋值给newday然后临时对释放掉等。之后 的赋值 *** 作也一致。我新增了拷贝构造函数实现深拷贝。如果不加的话，只是浅拷贝。

class Date

{

int mo,da,yr;

char month;

public:

Date(int m=0, int d=0, int y=0);

Date(const Date&);                //新装拷贝构造函数，实现深拷贝。

~Date();

Date operator = (const Date&);

void display() const;

};

Date::Date(int m, int d, int y)

{

static char mos[] =

{

"January","February","March","April","May","June",

"July","August","September","October","November","December"

};

mo = m;

da = d;

yr = y;

if (m != 0)

{

month = new char[strlen(mos[m-1])+1];

strcpy(month, mos[m-1]);

}

else

month = 0;

}

Date::Date(const Date& dt) //  //新装拷贝构造函数，实现深拷贝。

{

if (this != &dt)

{

this->mo = dtmo;

this->da = dtda;

this->yr = dtyr;

if (dtmonth != NULL)

{

this->month = new char [strlen(dtmonth)+1];

memset(this->month,0,strlen(dtmonth)+1);

strcpy(this->month, dtmonth);

}

else

month = NULL;

}

}

Date::~Date()

{

delete [] month;

}

void Date::display() const

{

if (month!=0)

cout<<month<<' '<<da<<","<<yr<<endl;

}

Date Date::operator=(const Date& dt)

{

if (this != &dt)

{

mo = dtmo;

da = dtda;

yr = dtyr;

delete [] month;

if (dtmonth != 0)

{

month = new char [strlen(dtmonth)+1];

strcpy(month, dtmonth);

}

else

month = 0;

}

return this;  //this是这指针，this就是对指针解引用，就是返回指针所指向的对象，而这个指针所指向的对象就是调用这个类成员函数的对象本身。

}

int main(int argc, char argv[])

{

Date birthday(8,11,1979);

Date oldday,newday;

oldday = newday = birthday;

birthdaydisplay();

olddaydisplay();

newdaydisplay();

system("pause");

return 0;

}

this作用域是在类内部，当在类的非静态成员函数中访问类的非静态成员的时候，编译器会自动将对象本身的地址作为一个隐含参数传递给函数。也就是说，即使你没有写上this指针，编译器在编译的时候也是加上this的，它作为非静态成员函数的隐含形参，对各成员的访问均通过this进行。

---