operator=处理自我赋值

有许多时候，我们自己编写类的operator=函数（例如，当类中包含指针时）。

考虑如下的一个类：

class Widget {
public:
Widget(int x=0): val(new int(x)) {}
~Widget() { delete val; }
Widget(const Widget &rhs): val(new int(*rhs.val)) {}
//operator =
Widget& operator=(const Widget &rhs);

void print() const { cout << *val << endl; }
private:
int *val;
};

错误版本：

当自我赋值的时候，下面的代码是不安全的。如果*this 和 rhs 是同一个对象，那么第一句 delete val；

不仅仅删除了当前对象的val, 也删除了rhs 的 val. 那么 rhs.val 指向的就是一个已经被删除的int. 这必然产生诡异的问题。

/** wrong version
* not-safe when self-assignment occurs.
*/
Widget& Widget::operator=(const Widget &rhs) {
delete val;
val = new int(*rhs.val);
return *this;
}

改进版本1：

阻止此类错误的传统做法是加一个证同测试（identity test）。

Widget& Widget::operator=(const Widget &rhs) {
if(this == &rhs) return;

delete val;
val = new int(*rhs.val);
return *this;
}

但是上述做法，虽然具有自我复制安全性，但是不具有异常安全性。

如果 new int 抛出异常的时候，this->val 指向的就是一个已经删除的int

改进版本2：

异常安全性与自我复制安全性兼具

Widget& Widget::operator=(const Widget &rhs) {
int *pOld = val;
val = new int(*rhs.val);
delete pOld;
return *this;
}

改进版本3:

copy and swap 技术

Widget& Widget::operator=(const Widget &rhs) {
Widget temp(rhs);
swap(temp);
return *this;
}

改进版本4:

通过传值来实现 copy and swap

Widget& Widget::operator=(Widget rhs) { //yes, copy by value
swap(rhs);
return *this;
}