《Effective C艹》读书笔记（7）

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

    一个包含指针变量的类，我们在为其写赋值函数（深复制）的时候可能会这样写

class base{
public:
    int data;
    double* p;
    base& operator=(const base& a){
        this->data = a.data;
        delete p;                             //首先删除自身的内容，再写入新的内容
        p = new double(*a.p);
        return *this;
    }
};

 这段代码看似很完美但是当我们进行下面操作的时候，明显就会出错。

base a;
a = a;  //p所指向的内容在赋值之前就被删除了！

我们对此进行了第一步的修改，增加了一步判断，如果左侧变量右侧变量值相等，则直接返回*this

class base{
public:
    int data;
    double* p;
    base& operator=(const base& a){
        if(this == &a)return *this;
        this->data = a.data;
        delete p;
        p = new double(*a.p);
        return *this;
    }
};

     这样就可以解决自我赋值的问题。但是接下来的问题又出现了，如果new这个步骤失败了，那么p所指向的原来的内容也丢失了。 

   为了解决以上问题，有两种解决方法可供选择。

class base{
public:
    int data;
    double* p;
    base& operator=(const base& a){
        if(this == &a)return *this;     //可以删除
        this->data = a.data;
        float* tmp = p;                //首先定义一个备份指针
        p = new double(*a.p);          //再申请新的空间，如果申请失败，p仍然会指向原来的内容
        delete tmp;
        return *this;
    }
};

 第二种：

class base{
public:
    int data;
    double* p;
    base& operator=(const base& a){
        if(this == &a)return *this;                     //可以删除
        this->data = a.data;
        double* tmp = new double(*a.p);                //首先用临时指针申请空间
        delete p;                                      //如果走到这里说明申请成功，则释放this的空间
        p = tmp;
        return *this;
    }
};

 其实，上面两种方法中，最开始判断两个变量是否为同一个的语句可以删除，因为让operator具备异常安全往往自动获得自我赋值安全的回报