《Effective C++》item11：在operator=中处理“自我赋值”
“自我赋值”是个看似不可能但却又让人望而生畏的东西，貌似几乎不会有人写出
Point p;
p = p;
这样的二逼程序，虽然不会出现编译错误，但确实是个能造成异常的语句！What‘s more，这样的“自我赋值”的机会并不少见，我们来看下面这个例子：
#include "stdafx.h"
#include <iostream>
using namespace std;
class Point{
private:
int x,y;
public:
Point():x(0),y(0){};
void Print(){
cout<< x <<" "<< y <<endl;
}
};
class Line{
private:
Point *p1;
public:
Line(Point *p):p1(p){};
Line& operator=(const Line& line){
delete p1;
p1 = new Point(*line.p1);
return *this;
}
Point* getPoint(){
return p1;
}
};
int main()
{
Point p;
Line l1(&p), l2(&p);
l1 = l2;
l1.getPoint()->Print();
return 0;
}
这是一个典型的“自我赋值”！
首先用p来初始化l1和l2，l1和l2中都有一个Point类型的指针，这个时候他们都指向内存中的同一块内存单元，在接下来执行l1 = l2的时候，会把l2.p1赋值给l1.p1，这就是“自我赋值”了！而Line的copy构造函数的实现过程通常是没有过错的，对指针赋新值的时候先把旧的值给free掉，然后正是这个free确带来了灾难性的后果，程序执行的时候会死掉！
出错的原因很简单，关键是怎么去解决！有三种解决方案：
方案一：
比较来源对象和目标对象的地址。
#include "stdafx.h"
#include <iostream>
using namespace std;
class Point{
private:
int x,y;
public:
Point():x(0),y(0){};
void Print(){
cout<< x <<" "<< y <<endl;
}
};
class Line{
private:
Point *p1;
public:
Line(Point *p):p1(p){};
Line& operator=(const Line& line){
if (this->p1 == line.p1) //比较来源对象和目标对象的地址来避免“自我赋值”
{
return *this;
}
delete p1;
p1 = new Point(*line.p1);
return *this;
}
Point* getPoint(){
return p1;
}
};
int main()
{
Point p;
Line l1(&p), l2(&p);
l1 = l2;
l1.getPoint()->Print();
return 0;
}
这种方式的确可以解决“自我赋值”的问题，但是有可能带来新的问题：如果在p1 = new Point（*line.p1）这句出现了exception的话，p1已经给delete掉了，却没有赋予新的值，那么p1最终会持有一个指针指向一块被删除的Point。而方案二却可以很好的解决这个问题。
方案二：
先记住目标指针，等到他被成功的赋值之后再去删除。
这种方式可以有效的解决“自我赋值安全性”和“异常安全性”，值得推荐！
#include "stdafx.h"
#include <iostream>
using namespace std;
class Point{
private:
int x,y;
public:
Point():x(0),y(0){};
void Print(){
cout<< x <<" "<< y <<endl;
}
};
class Line{
private:
Point *p1;
public:
Line(Point *p):p1(p){};
Line& operator=(const Line& line){
Point* p = p1; //记住原来的p1
p1 = new Point(*line.p1); //令p1指向*p1的一个副本
delete p; //删除原来的值
return *this;
}
Point* getPoint(){
return p1;
}
};
int main()
{
Point p;
Line l1(&p), l2(&p);
l1 = l2;
l1.getPoint()->Print();
return 0;
}
然而，这个程序并未运行通过，结果死掉了！why？
困惑ing.......................
纠结了一个下午，晚上跟海云同志共同探讨了下这个问题，在大神的火眼金睛下，终于发现了问题：delete只能删除对分配的内存空间，不能针对栈内存！
而程序中的delete p；p是在函数内部定义的，当然不能用delete释放了！
修改了一下程序：
#include "stdafx.h"
#include <iostream>
using namespace std;
class Point{
private:
int x,y;
public:
Point():x(0),y(0){};
void Print(){
cout<< x <<" "<< y <<endl;
}
};
class Line{
private:
Point *p1; //p1一定要指向堆分配的对象
public:
Line(Point *p):p1(p){};
Line& operator=(const Line& line){
Point *p = p1; //记住原来的p1
p1 = new Point(*line.p1); //令p1指向*p1的一个副本
delete p; //删除原来的值
return *this;
}
Point* getPoint() const
{
return p1;
}
};
int main()
{
Point *p = new Point(); //p指向堆分配而来的对象
Line l1(p), l2(p);
l1 = l1;
l1.getPoint()->Print();
return 0;
}
完美运行！同时，前面那个程序也有同样的问题，必须用delete释放堆空间！
方案三：
使用copy-and-swap技术
#include "stdafx.h"
#include <iostream>
using namespace std;
class Point{
private:
int x,y;
public:
Point():x(0),y(0){};
void Print(){
cout<< x <<" "<< y <<endl;
}
};
class Line{
private:
Point *p1; //p1一定要指向堆分配的对象
public:
Line(Point *p):p1(p){};
Line& operator=(const Line& line){
Line temp(line); // 将line的数据制作一份副本
swap(temp); // 将*this数据和temp的数据交换
return *this;
}
Point* getPoint() const
{
return p1;
}
void swap(Line& li)
{
Point *pp;
pp = p1;
p1 = li.p1;
li.p1 = pp;
}
};
int main()
{
Point *p = new Point(); //p指向堆分配而来的对象
Line l1(p), l2(p);
l1 = l1;
l1.getPoint()->Print();
return 0;
}
这种方式巧妙的运用的对栈内存在函数调用返回时自动释放的原理，也是值得推荐的！
Remember：
（1）确保当对象自我赋值时operator=有良好行为。其中技术包括：
a.) 比较“来源对象”和“目标对象”的地址）；
b.) 精心周到的语句顺序；
c.) 以及copy-and-swap；
（2）确定任何函数如果操作一个以上的对象，而其中多个对象是同一个对象时，其行为仍然正确。