C++ 赋值运算符'='的重载（浅拷贝、深拷贝）

01 赋值运算符重载的需求

有时候但愿赋值运算符两边的类型能够不匹配，好比：把一个 int 类型变量赋值给一个Complex（复数）对象，或把一个 char* 类型的字符串赋值给一个字符串对象，此时就须要重载赋值运算符‘=’。

须要注意的是：赋值运算符 = 只能重载为成员函数。

---

02 赋值运算符重载的例子

下面咱们以自定义一个本身的字符串类代码的例子，讲解赋值运算符的重载函数。

class MyString // 字符串类
{
public:
    // 构造函数，默认初始化1个字节的字符
    MyString ():m_str(new char[1])
    {
        m_str[0] = 0;
    }
    
    // 析构函数，释放资源
    ~MyString()
    {
        delete [] m_str;
    }
    
    const char* c_str()
    {
        return m_str;
    }
    
    // 赋值运算符重载函数
    // 重载=号使得 obj = "Hello" 可以成立
    MyString & operator= (const char *s)
    {
        // 释放旧字符串资源
        delete [] m_str;
        
        // 生成新字符串的空间大小，长度多+1的目的是存放\0
        m_str = new char[strlen(s) +1 ];
        
        // 拷贝新字符串的内容
        strcpy(m_str, s);
        
        // 返回该对象
        return *this;
    }
    
private:
    char * m_str; // 字符串指针
};

int main() {
    
    MyString s;
    
    s = "Hello~"; // 等价于s.operator=("Hello~");
    std::cout << s.c_str()  << std::endl;
    
    // MyString s2 = "Hello!"; // 这条语句要是不注释就会编译报错
    
    s = "Hi~"; // 等价于s.operator=("Hi~");
    std::cout << s.c_str()  << std::endl;

    return 0;
}

输出结果：

Hello~
Hi~

重载=号运算符函数后，s = "Hello~"; 语句就等价于 s.operator=("Hello~");。

须要注意的一点是：上面的MyString s2 = "Hello!";语句其实是初始化语句，而不是赋值语句，由于是初始化语句，因此须要调用构造函数进行初始化，那么这时就须要有char*参数的构造函数，因为咱们没有定义此构造函数，因此就会编译出错。

---

03 浅拷贝和深拷贝

仍是依据上面的例子，假设咱们要实现最后一个语句的方式：

MyString s1,s2;
s1 = "this"; // 调用重载的赋值语句
s2 = "that"; // 调用重载的赋值语句
s1 = s2; // 如何实现这个？？

s1 = s2;语句目的但愿是s1对象放的字符串和s2对象放的字符串象要同样，因为 = 号两边的相似都是对象，编译器会用原生的赋值运算符函数，可是这个原生的赋值运算符函数对于有指针成员变量的对象来讲，是很是危险的！

浅拷贝

若是用原生的赋值运算符函数去赋值有指针成员变量的对象，就会使得两个对象的指针地址也是同样的，也就是两个对象的指针成员变量指向的地址是同一个地方，这种方式就是浅拷贝。

这时当一个对象释放了指针成员变量时，那么另一个对象的指针成员变量指向的地址就是空的了，再次使用这个对象时，程序就会奔溃了，由于该对象的指针成员函数已是个不合法的指针了！

深拷贝

若是对象里面有指针成员变量，则咱们须要对原生的赋值运算符函数，防止出现程序出错现象的发生。

所以要在 class MyString 类里加上以下成员函数：

MyString & operator=(const MyString & s)
{
    // 释放旧字符串资源
    delete [] m_str;
    
    // 生成新字符串的空间大小，长度多+1的目的是存放\0
    m_str = new char[strlen(s.m_str) +1 ];
    
    // 拷贝新字符串的内容
    strcpy(m_str, s.m_str);
    
    // 返回该对象
    return *this;
}

这么作就够了吗？还有什么须要改进的地方吗？

咱们在考虑下面的语句：

MyString s;
s = "Hello";
s = s; // 是否会有问题？

最后一个语句是否会有问题？

s = s;等价于s.operator=(s)，因为s和s是相同的对象，那么就不必彻底执行重载的赋值 = 的函数了，咱们再加个判断，当左右两边是相同对象时，就直接返回该对象就好：

MyString & operator=(const MyString & s)
{
    // 当左右两边是相同对象时，就直接返回该对象就
    if(this == &s)
        return *this;

    delete [] m_str;
    m_str = new char[strlen(s.m_str) +1 ];
    strcpy(m_str, s.m_str);
    return *this;
}

---

对operator=返回值类型的讨论

• void 好很差？
• MyString 好很差？
• 为何是MyString &？

当咱们重载一个运算符的时候，好的风格应该是尽可能保留运算符本来的特性

考虑：

• a = b = c; 这个赋值语句的顺序是先b = c，而后在a = (b = c)。若是返回的void类型，那么a = (void)显然是不成立的；
• (a = b) = c; 这个赋值语句会修改a的值，若是返回的类型是MyString对象，那么就没法修改a的值了。

分别等价于：

• a.operator=(b.operator=(c));
• (a.operator=(b)).operator=(c);

因此综上考虑，operator=返回值类型是MyString &是比较好的。

04 复制（拷贝）构造函数

上面的MyString类是否就没有问题了？

MyString s;
s = "Hello";
MyString s1(s); // 要考虑这种状况，那就要重载复制（拷贝）构造函数

若是使用默认的复制（拷贝）构造函数，那就对有指针成员变量的对象会有问题，由于会默认的复制（拷贝）构造函数会致使两个对象的指针成员变量指向同一个的空间。

因此须要对复制（拷贝）构造函数重载，并实现深拷贝的方式：

MyString (const MyString &s)
{
    m_str = new char[strlen(s.m_str) + 1];
    strcpy(m_str, s.m_str);
}

05 小结

最后的全部代码，以下：

class MyString // 字符串类
{
public:
    // 构造函数，默认初始化1个字节的字符
    MyString ():m_str(new char[1])
    {
        m_str[0] = 0;
    }
    
    // 复制（拷贝）构造函数
    MyString (const MyString &s)
    {
        m_str = new char[strlen(s.m_str) + 1];
        strcpy(m_str, s.m_str);
    }
    
    // 析构函数，释放资源
    ~MyString()
    {
        delete [] m_str;
    }
    
    const char* c_str()
    {
        return m_str;
    }
    
    // 赋值运算符重载函数
    // 重载=号使得 obj = "Hello" 可以成立
    MyString & operator= (const char *s)
    {
        // 释放旧字符串资源
        delete [] m_str;
        
        // 生成新字符串的空间大小，长度多+1的目的是存放\0
        m_str = new char[strlen(s) +1 ];
        
        // 拷贝新字符串的内容
        strcpy(m_str, s);
        
        // 返回该对象
        return *this;
    }
    
    // 赋值运算符重载函数
    // 重载=号使得 obj1 = obj2 可以成立
    MyString & operator=(const MyString & s)
    {
        // 当左右两边是相同对象时，就直接返回该对象就
        if(this == &s)
            return *this;
    
        delete [] m_str;
        m_str = new char[strlen(s.m_str) +1 ];
        strcpy(m_str, s.m_str);
        return *this;
    }
    
private:
    char * m_str; // 字符串指针
};

int main() 
{
    
    MyString s1,s2;
    
    s1 = "Hello~"; // 等价于s1.operator=("Hello~");
    std::cout << s1.c_str()  << std::endl;
    
    
    s2 = "Hi~"; // 等价于s2.operator=("Hi~");
    std::cout << s2.c_str()  << std::endl;
    
    s1 = s2;   // 等价于s1.operator=(s2);
    std::cout << s1.c_str()  << std::endl;
    
    MyString s3(s1);  // 复制构造函数
    std::cout << s3.c_str()  << std::endl;

    return 0;
}

输出以下：

Hello~
Hi~
Hi~
Hi~