NO.10: 在operator=中处理 "自我赋值"

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

2.确定任何函数执行操作一个以上对象时，而其中多个对象是同一个对象时，其行为任然正确

 #include <iostream>

 //1.0
 class CopySwap1_0
 {
 private:
     int *value;
 public:
     CopySwap1_0() : value(new int())
     {}

     ~CopySwap1_0()
     { delete value; };

     //不符合 "C++异常安全" 1.没有考虑自赋值情况. 2.new抛出异常的话，原数据销毁
     CopySwap1_0 &operator=(const CopySwap1_0 &rhs)
     {
         delete value;
         value = new int(*rhs.value);
         return *this;

     }

 };

 //2.0
 class CopySwap2_0
 {
 private:
     int *value;
 public:
     CopySwap2_0() : value(new int())
     {}

     ~CopySwap2_0()
     { delete value; };

     //保证异常安全,和自赋值情况,但执行效率可以提高
     CopySwap2_0 &operator=(const CopySwap2_0 &rhs)
     {
         if (this == &rhs) return *this;

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

 };

 //3.0
 class CopySwap3_0
 {
     friend void swap(CopySwap3_0& lhs,CopySwap3_0& rhs);
 private:
     int *value;
 public:
     CopySwap3_0() : value(new int())
     {}

     ~CopySwap3_0()
     { delete value; };

     CopySwap3_0(const CopySwap3_0& rhs)
     {
         value=new int(*rhs.value);
         //other work
     }

     //这样做我们会失去一个重要的优化机会
     //通常，我们最好遵循比较有用的规则是：不要拷贝函数参数。你应该按值传递参数，让编译器来完成拷贝工作。

 //    CopySwap3_0 &operator=(const CopySwap3_0 &rhs)
 //    {
 //        CopySwap3_0 lhs(rhs);
 //        std::swap(*this, lhs);
 //        return *this;
 //
 //    }

 //    这种管理资源的方式解决了代码冗余的问题，我们可以用拷贝构造函数完成拷贝功能，而不用按位拷贝。拷贝功能完成后，我们就可以准备交换了。
 //    注意到，上面一旦进入函数体，所有新数据都已经被分配、拷贝，可以使用了。这就提供了强烈的异常安全保证：如果拷贝失败，我们不会进入到函数体内，
 //    那么this指针所指向的内容也不会被改变。（在前面我们为了实施强烈保证所做的事情，现在编译器为我们做了）。
 //    swap函数时non-throwing的。我们把旧数据和新数据交换，安全地改变我们的状态，旧数据被放进了临时对象里。这样当函数退出时候，旧数据被自动释放。
 //    因为copy-and-swap没有代码冗余，我们不会在这个而操作符里面引入bug。我们也避免了自我赋值检测。

     CopySwap3_0 &operator=(CopySwap3_0 rhs)
     {
         swap(*this, rhs);
         return *this;

     }

 };

 void swap(CopySwap3_0& lhs,CopySwap3_0& rhs)
 {
     //using声明现在当前作用域寻找swap，没有则使用std::swap
     using std::swap;
     swap(lhs.value,rhs.value);
     //其他指针/值操作
 }

 int main(int argc, char **argv)
 {
     CopySwap3_0 A, B;
     A = B;
     return ;
 }

Toal:一般具有管理资源分配的类使用copy and swap,效益是最好的，copy and swap 使用一次拷贝构造和析构操作换取一次拷贝赋值操作(往往拷贝赋值操作也是执行析构和拷贝操作),对于数据变量结点少的情况copy and swap是最好的,也防止自赋值和异常问题，对于资源分配的类最好实现自己的swap函数，防止循环调用赋值运算符- -;