条款11： 在operator= 中处理“自我赋值”

在实现operator=时考虑自我赋值是必要的就像 x=y 。我们不知道变量x与y代表的值是否为同一个值（把x和y说成是一个指针更恰当一点）。

例如以下

第一版：

#include <iostream>

using namespace std;

class bitmap
{
public:
	bitmap()
	{
		cout<<"调用bitmap()无參构造函数"<<endl;
	}
	bitmap(const bitmap& bt)
	{
		this->i = bt.i;
		cout<<"调用bitmap()拷贝构造函数"<<endl;
	}
	~bitmap()
	{
	}
private:
	int i;
};
class Widget
{
public:
	Widget()
	{
		pb = new bitmap();
	}
	Widget(const Widget& wd)
	{
		this->pb = wd.pb;
	}
public:
	Widget& operator=(const Widget& rhs);
private:
	bitmap* pb; //定义一个从heap分配而得的对象
};

//第一版赋值函数：
Widget& Widget::operator=(const Widget& rhs)
{
	delete pb;
	pb = new bitmap(*rhs.pb);
	return *this;
}
//这一版函数的pb在使用前清理掉之前的pb指向。再接受一个new出来的新对象，看着非常顺理成章，可是
//当this与函数參数rhs相等的时候，pb = new bitmap(*rhs.pb);由于我们已经把*rhs.pb delete掉了。


int main()
{

	Widget w1;
	Widget w2;
	w1 = w2;
	return 0;
}
/*
调用bitmap()无參构造函数
调用bitmap()无參构造函数
调用bitmap()拷贝构造函数
Press any key to continue
*/

第二版：

//第二版赋值函数：
Widget& Widget::operator=(const Widget& rhs)
{
	if (this == &rhs)
	{
		return *this;
	}

	delete pb;
	pb = new bitmap(*rhs.pb);
	return *this;
}
//这个版本号行的通，赋值函数基本上是能够接受的，可是不见得是安全的，由于当new产生异常时pb依旧是一个
//不确定的指针。

第三版：

//第三版赋值函数：
Widget& Widget::operator=(const Widget& rhs)
{
	bitmap *pOrig = pb;
	pb = new bitmap(*rhs.pb);
	delete pOrig;
	return *this;
}
//第三版函数在開始的时候用pOrig记录了pb。当new没有异常时我们再把pb原来的指向空间释放掉
//从而提高了安全性。这样的方法也相同可以处理自我赋值。假如这里rhs=*this。我们先对原来的
//bitmap做了一份备份，删除原bitmap后，指向了我们的那一份备份，也许这样的处理自我赋值的方法
//不是非常好。可是行的通，在保证安全性的情况下採用这样的办法非常不错。

第四版：

#include <iostream>

using namespace std;

class bitmap
{
public:
	bitmap()
	{
		cout<<"调用bitmap()无參构造函数"<<endl;
	}
	bitmap(const bitmap& bt)
	{
		this->i = bt.i;
		cout<<"调用bitmap()拷贝构造函数"<<endl;
	}
	~bitmap()
	{
	}
private:
	int i;
};
class Widget
{
public:
	Widget()
	{
		cout<<"调用Widget()无參构造函数"<<endl;
		pb = new bitmap();
	}
	Widget(const Widget& wd)
	{
		cout<<"调用Widget()拷贝參构造函数"<<endl;
		this->pb = wd.pb;
	}
	void my_swap(Widget& rhs);
public:
	Widget& operator=(const Widget& rhs);
private:
	bitmap* pb; //定义一个从heap分配而得的对象
};

//第四版赋值函数：

void Widget::my_swap( Widget& rhs)
{
	pb = rhs.pb;
}

Widget& Widget::operator=(const Widget& rhs)
{
	Widget temp(rhs);//防止改变rhs
	my_swap(temp);
	return*this;
}
//第四版赋值函数利用的是copy and swap技术，这个技术在条款29其中
//有具体说明。还没认真看，这里就不解释了。

//第四版也能够这样用：
Widget& Widget::operator=(Widget rhs)
{
	my_swap(rhs); //事实上本质上是一样的，由于传递的參数是值传递，所以这里传递的是rhs的一个副本。相当于Widget temp(rhs);主要就是防止rhs被改变。
	return*this;
}


int main()
{
	
	Widget w1;
	Widget w2;
	w1 = w2;
	return 0;
}
/*
调用Widget()无參构造函数
调用bitmap()无參构造函数
调用Widget()无參构造函数
调用bitmap()无參构造函数
调用Widget()拷贝參构造函数
Press any key to continue
*/

总结：

1：确保当对象自我赋值时 operator= 有良好行为，当中技术包含比較“原来对象”和“目标对象”的地址。、精心周到的语句顺序，以及copy and swap

2：确定不论什么函数假设操作一个以上的对象，而当中多个对象是同一个对象时，其行为仍然正确。