copying 函数

痛定思痛。 2022-05-17 03:10 210阅读 0赞

# 1. 概述 #

copying函数包括copy构造函数和copy assignment 操作符。

# 2. copying函数注意事项 #

## 2.1 令operator= 返回一个 reference to \*this ##

令operator= 返回一个 reference to \*this，可以更好实现连续赋值。

如果operator= 返回的不是引用类型, 但是照样能实现a = b = c; 这种 "连锁赋值"。只是比operator=返回的是引用类型情况下多调用两次copy构造函数。 a = b = c;被解析为 a = (b = c)， 那么b = c时返回值必须通过copy构造函数来初始化临时对象termporary。 然后termporary通过操作符号operator=赋值给a，即a = termporary, operator=返回时同样会调用copy构造函数来初始化另外一个临时对象。故多调用两次copy构造函数而已。

所以，只是说从效率上来说， operator=返回引用比返回值类型要高效。

另外， 如果想要支持另外一种 "连锁赋值"，如 (a = b) = c; 那么就必须要operator=返回引用类型。即 a = b 返回的是 a的一个引用类型临时对象termporary，那么将c赋值给这个a的引用，即可正确地实现表达式的含义。 如果operator=返回值类型呢? 那么a = b 返回的是a的一个值类型临时对象termporary， 那么c赋值给这个临时对象termporary后，根本没有改变a的值，也就没有正确地实现表达式的含义。

所以，综上两点， operator=还是老老实实地返回一个reference to \*this吧。

## 2.2 在operator= 中处理“自我赋值” ##

当你重新定义copying函数，此时对象需要考虑资源释放时，那么在进行赋值操作时需要考虑“自我赋值”的情况。

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

问题代码：

#include <iostream>
    using namespce std;
    
    class TestOne
    {
    
        TestOne()
        {
            
        }
    
    }
    
    
    class TestTwo
    {
    
        TestTwo()
        {
            m_testOne = new TestOne();
        }
        
        ~TestTwo()
        {
            detele m_testOne
        }
        
        TestTwo& operator=(const TestTwo& rhs)
        {
            //存在问题, 不仅不具备"自我赋值安全性",而且不具备"异常安全性"
            
            delete m_testOne;
            m_testOne = new TestOne(*rhs.m_testOne);
            return *this;
        }
    
    private:
        TestOne* m_testOne;
    }

(1) 证同测试

具备"自我赋值安全性",不具备"异常安全性",如果new出现异常,m\_testOne最终指向一块被删除的内存。

TestTwo& operator=(const TestTwo& rhs)
    {
        //存在问题, 具备"自我赋值安全性",不具备"异常安全性"
        if(this == &rhs)
        {
            return *this;
        }
    
        delete m_testOne;
        m_testOne = new TestOne(*rhs.m_testOne);
        return *this;
    }

(2) 精心周到的语句顺序

TestTwo& operator=(const TestTwo& rhs)
    {
        //具备"自我赋值安全性"和"异常安全性"
        TestOne* testOne = m_testOne;
            
        m_testOne = new TestOne(*rhs.m_testOne);
        delete testOne;
        return *this;
    }

## 2.3 复制对象时勿忘其每一个成分 ##

(1) copying函数应该确保复制 “对象体内的所有成员变量” 及“所有基类成分”。

(2) 不要尝试以某个copying函数实现另外一个copying函数(即，不要尝试copy assignment 操作符和copy构造函数相互调用)。应该将共同机能放进第三个函数中，并由两个copying函数共同调用。

案例

#include <iostream>
    using namespace std;
    
    class Test
    {
    public:
            Test()
            {
    
            }
    
            Test(const Test& test):
            m_a(test.m_a)
            {
    
            }
    
            Test& operator=(const Test& rhs)
            {
                    this->m_a = rhs.m_a;
                    
                    //赋值返回引用
                    return *this;
            }
    
    private:
    
            int m_a;
    
    };
    
    class TestTwo : public Test
    {
    public:
            TestTwo()
            {
            }
    
            TestTwo(const TestTwo& rhs):
            Test(rhs),
            m_b(rhs.m_b)
            {
    
            }
    
            TestTwo& operator=(const TestTwo& rhs)
            {
                    //调用基类赋值操作符,赋值操作符调用基类赋值操作符(不会去混用基类拷贝构造函数)
                    Test::operator=(rhs);
                    
                    //本类成员赋值
                    m_b = rhs.m_b;
                    
                    //赋值返回引用
                    return *this;
            }
            
    private:
        int m_b;
    };
    
    
    int main()
    {
            Test test;
            Test test2(test);
    
            Test testTwo;
            Test testTwo2(testTwo);
            return 0;
    }