C++类拷贝赋值运算符怎么重载

拷贝赋值运算符重载，简单来说，就是让你能用=给一个已经存在的C++对象赋值。它和拷贝构造函数不太一样，拷贝构造函数是用来创建一个新的对象，而拷贝赋值是修改一个已有的对象。

拷贝赋值运算符重载

想要搞定拷贝赋值运算符重载，主要得注意这几点：自赋值的处理、释放旧资源、分配新资源、以及返回对象的引用。

为什么要重载拷贝赋值运算符？

默认情况下，C++会提供一个拷贝赋值运算符，它会简单地将源对象的所有成员变量复制到目标对象。但如果你的类里有动态分配的内存，比如用new分配的，那默认的拷贝赋值运算符就只会复制指针，而不会复制指针指向的内容，这就是浅拷贝。浅拷贝会导致多个对象指向同一块内存，当其中一个对象释放了这块内存，其他的对象就变成了悬挂指针，访问就会出错。所以，当你的类里有动态分配的内存或者其他需要特殊处理的资源时，就需要重载拷贝赋值运算符，实现深拷贝，确保每个对象都有自己独立的资源。

如何编写一个安全的拷贝赋值运算符？

一个安全的拷贝赋值运算符需要考虑以下几个方面：

1. 自赋值检查：首先要检查是不是自己给自己赋值，如果是，直接返回*this，避免不必要的资源释放和分配。

2. 释放旧资源：在赋值之前，先释放目标对象已经拥有的资源，防止内存泄漏。

3. 分配新资源并复制数据：分配足够的内存，然后将源对象的数据复制到目标对象。

4. 异常安全：确保在分配资源或复制数据时发生异常，对象的状态仍然是有效的，不会出现资源泄漏或数据损坏。一种常见的做法是先创建一个临时对象，将源对象的数据复制到临时对象，然后再将临时对象的数据交换到目标对象。

5. 返回对象的引用：返回*this的引用，这样可以支持链式赋值，比如a = b = c;。

下面是一个示例代码：

#include 
#include 

class MyString {
private:
    char* data;
    size_t length;

public:
    // 构造函数
    MyString(const char* str = nullptr) : data(nullptr), length(0) {
        if (str) {
            length = std::strlen(str);
            data = new char[length + 1];
            std::strcpy(data, str);
        }
    }

    // 拷贝构造函数
    MyString(const MyString& other) : data(nullptr), length(0) {
        length = other.length;
        data = new char[length + 1];
        std::strcpy(data, other.data);
    }

    // 拷贝赋值运算符
    MyString& operator=(const MyString& other) {
        // 自赋值检查
        if (this == &other) {
            return *this;
        }

        // 释放旧资源
        delete[] data;
        data = nullptr; // 重要：避免悬挂指针

        // 分配新资源并复制数据
        length = other.length;
        data = new char[length + 1];
        std::strcpy(data, other.data);

        // 返回对象的引用
        return *this;
    }

    // 析构函数
    ~MyString() {
        delete[] data;
    }

    // 打印字符串
    void print() const {
        if (data) {
            std::cout << data << std::endl;
        } else {
            std::cout << "(null)" << std::endl;
        }
    }
};

int main() {
    MyString str1("Hello");
    MyString str2("World");
    str2 = str1; // 使用拷贝赋值运算符
    str1.print(); // 输出 "Hello"
    str2.print(); // 输出 "Hello"

    return 0;
}

拷贝赋值运算符和移动赋值运算符有什么区别？

拷贝赋值运算符和移动赋值运算符都是用来给对象赋值的，但它们的应用场景和实现方式有所不同。拷贝赋值运算符用于源对象仍然需要保持有效的情况，它会复制源对象的数据到目标对象。而移动赋值运算符用于源对象不再需要保持有效的情况，它会将源对象的资源“移动”到目标对象，避免了不必要的复制，提高了效率。移动赋值运算符通常用于处理临时对象或者即将销毁的对象。移动赋值运算符的参数是一个右值引用，用&&表示。

如何处理拷贝赋值运算符中的异常？

在拷贝赋值运算符中，如果分配内存失败或者复制数据时发生异常，可能会导致资源泄漏或者数据损坏。为了保证异常安全，可以使用以下几种方法：

1. 先分配再释放：先分配新的资源，然后再释放旧的资源。如果在分配新资源时发生异常，旧的资源仍然是有效的。

2. 使用std::unique_ptr或std::shared_ptr：这些智能指针可以自动管理资源，即使发生异常，也能保证资源被正确释放。

3. Copy-and-Swap：创建一个临时对象，将源对象的数据复制到临时对象，然后将临时对象的数据和目标对象的数据进行交换。这种方法可以保证即使在复制数据时发生异常，目标对象的状态仍然是有效的。

下面是一个使用Copy-and-Swap的示例代码：

#include 
#include 
#include 

class MyString {
private:
    char* data;
    size_t length;

public:
    // 构造函数
    MyString(const char* str = nullptr) : data(nullptr), length(0) {
        if (str) {
            length = std::strlen(str);
            data = new char[length + 1];
            std::strcpy(data, str);
        }
    }

    // 拷贝构造函数
    MyString(const MyString& other) : data(nullptr), length(0) {
        length = other.length;
        data = new char[length + 1];
        std::strcpy(data, other.data);
    }

    // 移动构造函数
    MyString(MyString&& other) noexcept : data(other.data), length(other.length) {
        other.data = nullptr;
        other.length = 0;
    }

    // 拷贝赋值运算符
    MyString& operator=(const MyString& other) {
        MyString temp(other); // 创建临时对象
        std::swap(data, temp.data); // 交换数据
        std::swap(length, temp.length);
        return *this;
    }

    // 移动赋值运算符
    MyString& operator=(MyString&& other) noexcept {
        if (this != &other) {
            delete[] data;
            data = other.data;
            length = other.length;
            other.data = nullptr;
            other.length = 0;
        }
        return *this;
    }

    // 析构函数
    ~MyString() {
        delete[] data;
    }

    // 打印字符串
    void print() const {
        if (data) {
            std::cout << data << std::endl;
        } else {
            std::cout << "(null)" << std::endl;
        }
    }
};

int main() {
    MyString str1("Hello");
    MyString str2("World");
    str2 = str1; // 使用拷贝赋值运算符
    str1.print(); // 输出 "Hello"
    str2.print(); // 输出 "Hello"

    MyString str3("Move");
    str3 = std::move(str1); // 使用移动赋值运算符
    str3.print(); // 输出 "Hello"
    str1.print(); // 输出 "(null)"

    return 0;
}