C++避坑---赋值运算符函数中的自我赋值和异常控制

文章首发公众号：iDoitnow

在定义某个类的赋值运算符函数的时候，如果涉及到动态内存分配，我们首先会考虑到深拷贝和浅拷贝这种容易犯错的问题。但有些时候容易忽略自我赋值的风险和异常控制方面的问题。我们先看一个例子，如下：

#include <iostream>
#include <string>

class A {
    public:
    A(std::string s) : str(s) {}

    std::string str;
};

class B {
    public:
    B(const A& a) { pA = new A(a.str); }
    B(const B& b) { pA = new A(b.pA->str); }
    ~B() {
        delete pA;
        pA = nullptr;
    }

    B& operator=(const B& b) {
        delete pA;
        pA = new A(*b.pA);

        return *this;
    }

    A* pA;
};

int main() {
    using std::cout;
    using std::endl;

    A a1("a1"), a2("a2");
    B b1(a1), b2(a2);
    cout << "B b1(a1), b2(a2)--->b1 = " << b1.pA->str << ", b2 = " << b2.pA->str
        << endl;
    b2 = b1;
    cout << "b2 = b1------------>b1 = " << b1.pA->str << ", b2 = " << b2.pA->str
        << endl;
    b1 = b1;
    cout << "b1 = b1------------>b1 = " << b1.pA->str << endl;
    b2 = b2;
    cout << "b2 = b2------------>b2 = " << b2.pA->str << endl;

    return 0;
}

输出结果：

B b1(a1), b2(a2)--->b1 = a1, b2 = a2
b2 = b1------------>b1 = a1, b2 = a1
b1 = b1------------>b1 = 
b2 = b2------------>b2 = 

从输出结果可以看出，当类B的对象自我赋值的时候，就会出现问题，相信大家一眼就能看出，是由于在赋值运算符函数中未进行自我赋值检测，直接先销毁当前对象中pA指向的数据导致的。当B& operator=(const B& b)中的b与赋值运算符函数中的*this（赋值的目的端）为同一对象的时候，语句delete pA;销毁当前对象中pA指向的数据，同时也销毁了b中的pA指向的数据，导致接下语句中的*b.pA内容也为空，最终造成类B对象赋值给自己的时候出现未知的异常。

自我赋值检测

针对上述例子出现的问题，我们很容易的想象到的解决办法就是添加自我赋值的安全检测，防止对象自己赋值给自己，类B的赋值运算符函数可以更改为：

B& operator=(const B& b) {
    if (this == &b) return *this;
    
    delete pA;
    pA = new A(*b.pA);
    
    return *this;
}

更改完后，代码输出结果如下：

B b1(a1), b2(a2)--->b1 = a1, b2 = a2
b2 = b1------------>b1 = a1, b2 = a1
b1 = b1------------>b1 = a1
b2 = b2------------>b2 = a1

在赋值运算符函数中添加自我检测机制，避免了”在停止使用资源之前意外释放了它“的陷阱，确保了类的自我赋值的安全性。但不知道你有没有注意到，在B& operator=(const B& b)中，如果new A(*b.pA)发生了异常（例如分配时内存不足或者A的构造函数抛出异常），B将持有一个指针指向一块已经被删除的A，这样的指针将可能导致我们无法安全的删除它们，甚至无法安全的读取它们，给我们的程序带来未知的风险。那如何让我们的赋值运算符函数既能规避自我赋值可能带来的风险，又能防止这种未知风险的发生呢？

确保异常安全

针对上述可能出现的异常，我们分析发现，更多的是因为我们在没有十足把握确认赋值操作能够成功的情况下，过早的delete掉了*this中的pA指向的内容，那如果我们将pA原始指向的数据先保存下来，等一切“水到渠成”了再进行相关的释放操作，是否可以解决上述的异常问题，具体实现如下：

B& operator=(const B& b) {
    A* tmp_pA = pA; //记住原来的pA
    pA = new A(*b.pA); //令pA指向*b.pA的副本，如果new失败，pA指向的内容仍是原来的pA
    delete tmp_pA; //当程序运行到这里，证明new A(*b.pA)操作未出现异常，可以通过tmp_pA将原来的pA指向的数据删除
    
    return *this;
}
/*注：上述实现未进行自我赋值检测，主要原因有两个：
1）主要原因：不加检测也能实现自我赋值的安全。
2）关键原因：虽然增加自我检测判断，可以让代码在自我赋值的情况下及时返回，
提高运行速度，但实际中自我赋值的情况很少发生，所以大部分时间是无用的，
因此综合考虑，程序没有它可能会更好。*/

运行结果：

B b1(a1), b2(a2)--->b1 = a1, b2 = a2
b2 = b1------------>b1 = a1, b2 = a1
b1 = b1------------>b1 = a1
b2 = b2------------>b2 = a1

上述实现，通过使用*tmp_pA保存*pA的原始数据，在给*pA赋值完新的数据后，再通过tmp_pA进行原始数据的释放，现在即使new A(*b.pA)抛出异常，pA也可以维持原来的状态。该实现不仅规避了异常带来的风险，而且也规避掉了自我赋值带来的风险。但是上述代码也重复了构造函数和析构函数中的操作（如new、delete），产生了代码冗余。试想一下，如果类B的成员更多，或者涉及到更加复杂的资源操作，可能会使我们的上述代码量暴增，而且相关操作与其构造函数和析构函数中的高度重复，这样使得我们的代码变得很臃肿。那有没有更好的办法呢？

拷贝交换带来的方便

沿用上面异常安全性的实现思路，我们可以将整个B的对象先保持不变，将要赋值的内容存入一个新的临时对象tmpB中，然后在交换原来B对象和对象tmpB，最终达到实现赋值的效果。这就涉及到所谓的拷贝交换（copy and swap）技术，其原理就是通过使用拷贝构造函数（或移动构造函数）来创建数据的本地副本，然后调用交换函数（一般需要自己定义）交换新数据与旧数据的内容。

void swap(B& b) { std::swap(pA, b.pA); }

/*方法1*/
B& operator=(const B& b) {
    B tmpB(b); //为b创建一个副本tmpB
    swap(tmpB); //将*this的数据与tmpB的数据进行交换
    return *this;
}

/*方法2*/
B& operator=(B b) { //此处的b是被传入对象的一个副本
    swap(b); //将*this的数据与b的数据进行交换
    return *this;
}

上述实现中，swap(B& b)函数内部只涉及到了指针的交换，而不是分配和拷贝整个对象，且没有重复的代码。方法2是在方法1的基础上的进一步简化，方法2通过使用按值传递的方式，在调用参数的时候自动生成一份参数的副本b，然后将其与目标对象进行交换。通过拷贝构造函数和交换函数完成了赋值运算符函数的实现，其中交换函数swap(B& b)还可以为其他函数（如移动赋值运算符等）共用，进一步降低重复代码的编写。如果后续需要在类B中添加新的成员，只需要修改构造函数、析构函数和交换函数即可完成相应的扩展。

总 结

在定义类的赋值运算符函数的时候，根据当前的类采取适当高效的措施，如：

• 比较源对象和目标对象的地址。
• 适当的调整相关的语句顺序，避开风险。
• 使用copy-and-swap。

来防止自我赋值风险的产生和提高赋值运算符函数的异常控制能力。

参考文献

《Effective C++ 第三版》