1
2
3
4
5
6

int main()
{
    MyClass a;
    MyClass b;
    a = b; // 调用赋值运算符, b.operator=(a)
}

1
2
3
4
5

struct MyClass {
    int a;
    std::string b; // std::string 已支持深拷贝
    MyClass& operator=(const MyClass&) = default; // 默认生成赋值运算符
};

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

class MyClass {
public:
    int* data;
    size_t size;

    // 构造函数
    MyClass(size_t s = 0) : size(s), data(new int[s]()) {}

    // 拷贝赋值运算符
    MyClass& operator=(const MyClass& other) {
        if (this != &other) {   // 防止自赋值
            delete[] data;      // 释放已有资源

            size = other.size;
            data = new int[size]; // 分配新资源
            std::copy(other.data, other.data + size, data); // 深拷贝数据
        }
        return *this; // 返回赋值后的结果
    }


    ~MyClass() {
        delete[] data;
    }
};

1
2
3
4

struct MyClass {
    std::vector<int> vec; // 支持移动语义
    MyClass& operator=(MyClass&& other) = default; // 默认生成移动赋值
};

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

class MyClass {
public:
    int* data;
    size_t size;

    // 构造函数
    MyClass(size_t n = 0) : data(new int[n]), size(n) {}

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

    // 移动赋值运算符重载
    MyClass& operator=(MyClass&& other) noexcept {
        if (this != &other) {
            delete[] data;             // 释放当前对象拥有的资源
            data = other.data;         // 转移 other 的资源
            size = other.size;

            other.data = nullptr;      // 防止 other 在析构时释放资源
            other.size = 0;
        }
        return *this;
    }
};