第五节 · 换一种变脸的方式 · 类型转换运算符定义

赋值运算符决定了对象如何被复制或移动。正确实现它们对于管理资源至关重要。

---

复制赋值运算符

class String
{
private:
    char* data;
    size_t length;
    
public:
    String(const char* s = "")
    {
        length = strlen(s);
        data = new char[length + 1];
        strcpy(data, s);
    }
    
    ~String()
    {
        delete[] data;
    }
    
    // 复制赋值运算符
    String& operator=(const String& other)
    {
        if (this != &other)  // 自赋值检查
        {
            delete[] data;   // 释放旧资源
            
            length = other.length;
            data = new char[length + 1];
            strcpy(data, other.data);
        }
        return *this;
    }
};

---

copy-and-swap 惯用法

更安全的实现方式：

class String
{
private:
    char* data;
    size_t length;
    
    void swap(String& other) noexcept
    {
        std::swap(data, other.data);
        std::swap(length, other.length);
    }
    
public:
    String(const char* s = "")
    {
        length = strlen(s);
        data = new char[length + 1];
        strcpy(data, s);
    }
    
    // 复制构造函数
    String(const String& other)
    {
        length = other.length;
        data = new char[length + 1];
        strcpy(data, other.data);
    }
    
    ~String()
    {
        delete[] data;
    }
    
    // copy-and-swap
    String& operator=(String other)  // 注意：按值传递
    {
        swap(other);
        return *this;
    }  // other 析构时释放旧数据
};

优点：

• 自动处理自赋值

• 异常安全

• 代码简洁

---

移动赋值运算符

class String
{
private:
    char* data;
    size_t length;
    
public:
    // ... 构造函数等 ...
    
    // 移动构造函数
    String(String&& other) noexcept
        : data(other.data), length(other.length)
    {
        other.data = nullptr;
        other.length = 0;
    }
    
    // 移动赋值运算符
    String& operator=(String&& other) noexcept
    {
        if (this != &other)
        {
            delete[] data;
            
            data = other.data;
            length = other.length;
            
            other.data = nullptr;
            other.length = 0;
        }
        return *this;
    }
};

int main()
{
    String s1 = "hello";
    String s2;
    
    s2 = move(s1);  // 移动赋值
    // s1 现在是空的
    
    return 0;
}

---

五法则（Rule of Five）

如果定义了以下任何一个，通常需要定义全部：

1. 析构函数

2. 复制构造函数

3. 复制赋值运算符

4. 移动构造函数

5. 移动赋值运算符

class Resource
{
private:
    int* data;
    
public:
    // 1. 构造函数
    Resource(int value = 0) : data(new int(value)) {}
    
    // 2. 析构函数
    ~Resource() { delete data; }
    
    // 3. 复制构造函数
    Resource(const Resource& other) : data(new int(*other.data)) {}
    
    // 4. 复制赋值运算符
    Resource& operator=(const Resource& other)
    {
        if (this != &other)
        {
            *data = *other.data;
        }
        return *this;
    }
    
    // 5. 移动构造函数
    Resource(Resource&& other) noexcept : data(other.data)
    {
        other.data = nullptr;
    }
    
    // 6. 移动赋值运算符
    Resource& operator=(Resource&& other) noexcept
    {
        if (this != &other)
        {
            delete data;
            data = other.data;
            other.data = nullptr;
        }
        return *this;
    }
};

---

零法则（Rule of Zero）

如果类不直接管理资源，就不需要定义任何特殊成员函数。

class Person
{
    string name;        // string 管理自己的资源
    vector<int> scores; // vector 管理自己的资源
    
public:
    Person(string n) : name(move(n)) {}
    
    // 不需要析构函数、复制/移动构造函数和赋值运算符
    // 编译器生成的版本就很好
};

---

default 和 delete

class Widget
{
public:
    // 使用默认实现
    Widget() = default;
    Widget(const Widget&) = default;
    Widget& operator=(const Widget&) = default;
    
    // 禁用移动
    Widget(Widget&&) = delete;
    Widget& operator=(Widget&&) = delete;
};

class Singleton
{
public:
    // 禁用复制和移动
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;
    
    static Singleton& instance()
    {
        static Singleton inst;
        return inst;
    }
    
private:
    Singleton() = default;
};

---

复合赋值运算符

class Vector2D
{
    double x, y;
    
public:
    Vector2D(double x = 0, double y = 0) : x(x), y(y) {}
    
    // 复合赋值
    Vector2D& operator+=(const Vector2D& v)
    {
        x += v.x;
        y += v.y;
        return *this;
    }
    
    // 基于复合赋值实现普通运算
    friend Vector2D operator+(Vector2D lhs, const Vector2D& rhs)
    {
        lhs += rhs;
        return lhs;
    }
};

---

自赋值安全

class Array
{
    int* data;
    size_t size;
    
public:
    // 不安全的赋值
    Array& operator=(const Array& other)
    {
        delete[] data;  // 如果 this == &other，这里就删除了源数据！
        data = new int[other.size];
        // ...
        return *this;
    }
    
    // 安全的赋值
    Array& operator=(const Array& other)
    {
        if (this != &other)  // 自赋值检查
        {
            delete[] data;
            data = new int[other.size];
            // ...
        }
        return *this;
    }
};

---

统一赋值运算符

使用 copy-and-swap，可以用一个运算符同时处理复制和移动：

class String
{
    char* data;
    
    void swap(String& other) noexcept
    {
        std::swap(data, other.data);
    }
    
public:
    // 统一赋值（按值传递）
    String& operator=(String other)  // 自动选择复制或移动构造
    {
        swap(other);
        return *this;
    }
};

int main()
{
    String s1 = "hello";
    String s2 = "world";
    
    s2 = s1;         // 复制构造 other，然后交换
    s2 = move(s1);   // 移动构造 other，然后交换
    
    return 0;
}

---

习题

• 解释 copy-and-swap 惯用法的优点。

• 什么是五法则和零法则？

• 为什么移动赋值运算符要标记 noexcept？