学完Efficient c++ (11-12)

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

自我赋值指的是将自己赋给自己，这是一种看似愚蠢无用但却在代码中出现次数比任何人想象的多得多的操作。

*pa = *pb;		 		//pa和pb指向同一对象，便是自我赋值。
arr[i] = arr[j];		//i和j相等，便是自我赋值

那么对于管理一定资源的对象重载的operator = 中，一定要对是不是自我赋值格外小心并且增加预判，因为无论是深拷贝还是资源所有权的转移，原先的内存或所有权一定会被清空才能被赋值，如果不加处理，这套逻辑被用在自我赋值上会发生——先把自己的资源给释放掉了，然后又把已释放掉的资源赋给了自己——出错了。

例如下面的代码，若rhs和*this指向的是相同的对象，就会导致访问到已删除的数据。

Widget& Widget::operator=(const Widget& rhs) {
    delete pRes;                          // 删除当前持有的资源
    pRes = new Resource(*rhs.pRes);       // 复制传入的资源
    return *this;
}

• 第一种做法是在赋值前增加预判（在执行后续语句前先进行证同测试（Identity test）），但是这种做法没有异常安全性，试想如果在删除掉原指针指向的内存后，在ptr重新赋值之前任何一处出了异常或者new时出了异常（分配时内存不足或copy构造函数抛出异常），那么原指针就指向了一块已经被删除的内存。

Widget& Widget::operator=(const Widget& rhs) {
  if (this == &rhs) return *this;
  
  delete pRes;	
  pRes = new Resource(*rhs.pRes);				//如果此处抛出异常，pRes将指向一块已经被删除的内存。
  return *this;
}

• 另一个常见的做法是只关注异常安全性，而不关注是否自我赋值。如果我们把异常安全性也考虑在内，那么我们就会得到如下方法，令人欣慰的是这个方法也解决了自我赋值的问题。

Widget& Widget::operator=(const Widget& rhs) {
  Resource* pOrg = pRes;
  pRes= new Resource(*rhs.pRes);				//如果此处抛出异常，pRes仍然指向之前的内存。
  delete pOrg;
  return *this;
}

• 还有一种取巧的做法是使用 copy and swap 技术，这种技术聪明地利用了栈空间会自动释放的特性，这样就可以通过析构函数来实现资源的释放：

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

• 上述做法还可以写得更加巧妙，就是利用按值传参，自动调用构造函数：

void Widge::swap(Widget& rhs){
...
};
Widget& Widget::operator=(Widget rhs) {
    swap(rhs);
    return *this;
}

条款12：复制对象时勿忘其每一个成分

当你决定手动实现拷贝构造函数或拷贝赋值运算符时，忘记复制任何一个成员都可能会导致意外的错误。

所谓“每一个成分”，作者在这里其实想要提醒大家两点：

• 当你给类多加了成员变量时，请不要忘记在拷贝构造函数和赋值操作符中对新加的成员变量进行处理。如果你忘记处理，编译器也不会报错。

• 如果你的类有继承，那么在你为子类编写拷贝构造函数时一定要格外小心复制基类的每一个成分，这些成分往往是private的，所以你无法访问它们，你应该让子类使用子类的拷贝构造函数去调用相应基类的拷贝构造函数：

  class PriorityCustomer : public Customer {
  public:
      PriorityCustomer(const PriorityCustomer& rhs);
      PriorityCustomer& operator=(const PriorityCustomer& rhs);
      ...
  
  private:
      int priority;
  }
  
  PriorityCustomer::PriorityCustomer(const PriorityCustomer& rhs)
      : Customer(rhs),                // 调用基类的拷贝构造函数
        priority(rhs.priority) {
      ...
  }
  
  PriorityCustomer::PriorityCustomer& operator=(const PriorityCustomer& rhs) {
      Customer::operator=(rhs);       // 调用基类的拷贝赋值运算符
      priority = rhs.priority;
      return *this;
  }

  除此之外，拷贝构造函数和拷贝赋值操作符，他们两个中任意一个不要去调用另一个，这虽然看上去是一个避免代码重复好方法，但是是荒谬的。其根本原因在于拷贝构造函数在构造一个对象——这个对象在调用之前并不存在；而赋值操作符在改变一个对象——这个对象是已经构造好了的。因此前者调用后者是在给一个还未构造好的对象赋值；而后者调用前者就像是在构造一个已经存在了的对象。