Item11:　Handle assignment to self in operator=

来源：互联网发布：hdtv直播软件编辑：程序博客网时间：2024/05/16 19:15

Widget& Widget::operator=(Widget rhs) // rhs is a copy of the object{ // passed in — note pass by val swap(rhs); // swap *this's data with // the copy's return *this;} “自我赋值”发生在对象被赋值给自己时：

class Widget { ... };Widget w;...w = w; // assignment to self

这看起来有点傻，但它合法，所以不要认定用户绝不会那么做。此外，赋值动作并不总是一眼就被认出来，例如：

a[i] = a[j]; // potential assignment to self

如果i和j有相同的值，这便是个自我赋值。再看：

*px = *py; // potential assignment to self

如果px和py恰巧指向同一个东西，这也是自我赋值。这些并不明显的自我赋值，是“别名（aliasing）”带来的后果：所谓“别名”就是“有一个以上的方法指称（指涉）某对象”。实际上两个对象只要来自同一个继承体系，它们甚至不需声明为相同类型就可能造成“别名”，因为一个base class的reference或pointer可以指向一个derived class对象：

class Base { ... };class Derived: public Base { ... };void doSomething(const Base& rb, // rb and *pd might actually be Derived* pd); // the same object

如遵守条款13和条款14的忠告，你会用对象来管理资源，而且你可以确定所谓“资源管理对象”在copy发生时有正确的举措。这种情况下你的赋值操作符或许是“自我赋值安全的”（self-assignment-safe），不需要额外操心。然而如果你尝试自行管理资源（如果你打算写一个用于资源管理的class就得这样做），可能会掉进“在停止使用资源之前意外释放了它”的陷阱。假设你建立一个class用来保存一个指针指向一块动态分配的位图（bitmap）：

class Bitmap { ... };class Widget { ...private: Bitmap *pb; // ptr to a heap-allocated object

下面是operator=实现代码，表面上看起来合理，但自我赋值出现时并不安全（它也不具备异常安全性，但我们稍后才讨论这个主题）。

Widget&Widget::operator=(const Widget& rhs) // unsafe impl. of operator={ delete pb; // stop using current bitmap pb = new Bitmap(*rhs.pb); // start using a copy of rhs's bitmap return *this; // see Item 10}

这里的自我赋值问题是，operator=函数内*this（赋值的目的端）和rhs有可能是同一个对象。果真如此delete就不只是销毁当前对象的bitmap，它也销毁rhs的bitmap。在函数末尾，Widget——它原本不该被自我赋值动作改变的——发现自己持有一个指针指向一个已被对象！

欲阻止这种错误，传统的做法是藉由operator=最前面的一个“认同测试（identity test）”达到“自我赋值”的检验目的：

Widget& Widget::operator=(const Widget& rhs){ if (this == &rhs) return *this; // identity test: if a self-assignment, // do nothing delete pb; pb = new Bitmap(*rhs.pb); return *this;}

这样做行得通。前一个版本operator=不仅不具备“自我赋值安全性”，也不具备“异常安全性”，这个新版本仍然存在异常方面的麻烦。更明确地说，如果“new Bitmap”导致异常（不论是因为分配时内存不中或因为Bitmap的copy构造函数抛出异常），Widget最终会持有一个指针指向一块被删除的Bitmap。这样的指针是有害。你无法安全地删除它们，甚至无法安全地读取它们。

怎么办呢？

看如下代码，只需注意在复制pb所指东西之前别删除pb：

Widget& Widget::operator=(const Widget& rhs){ Bitmap *pOrig = pb; // remember original pb pb = new Bitmap(*rhs.pb); // make pb point to a copy of *pb delete pOrig; // delete the original pb return *this;}

现在，如果“newBitmap”抛出异常，pb（及其栖身的那个Widget）保持原状。

如果你很关心效率，可以把“认同测试（identity test）”再次放回函数起始处。然而这样做之前先问问自己，你估计“自我赋值”的发生频率有多高？因为这项测试也需要成本。它会使代码变大一些（包括源文件和目标文件）并导入一个新的控制流（control flow）分支。而两者都会降低执行速度。

还有一种copy and swap技术。

class Widget { ... void swap(Widget& rhs); // exchange *this's and rhs's data; ... // see Item 29 for details};Widget& Widget::operator=(const Widget& rhs){ Widget temp(rhs); // make a copy of rhs's data swap(temp); // swap *this's data with the copy's return *this;}

A variation on this theme takes advantage of the facts that （1）某class的copy assignment操作符可能被声明为“以by value方式接受实参”；（2）以by value方式传递东西会造成一份副本：

Widget& Widget::operator=(Widget rhs) // rhs is a copy of the object{ // passed in — note pass by val swap(rhs); // swap *this's data with // the copy's return *this;}

请记住：

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

2、确定任何函数如果操作一个以上的对象，而其中多个对象是同一个对象时，其行为仍然正确。

Item11: Handle assignment to self in operator=

Item11:　Handle assignment to self in operator=