C++中的三/五/零法则解析

技术背景

在C++中，用户自定义类型的变量遵循值语义，这意味着对象在各种上下文中会被隐式复制。理解“复制对象”的实际含义对于编写正确、高效的代码至关重要。当类管理资源时，如动态分配的内存、文件句柄或互斥锁，复制对象的默认行为（成员逐个复制）可能会导致问题，如内存泄漏、悬空指针和未定义行为。因此，需要明确处理复制构造函数、复制赋值运算符和析构函数。

实现步骤

特殊成员函数的隐式定义

当没有显式声明复制构造函数、复制赋值运算符和析构函数时，编译器会隐式定义它们。例如，对于一个简单的person类：

#include <string>

class person
{
    std::string name;
    int age;

public:
    person(const std::string& name, int age) : name(name), age(age)
    {
    }
};

编译器隐式定义的特殊成员函数如下：

// 1. 复制构造函数
person(const person& that) : name(that.name), age(that.age)
{
}

// 2. 复制赋值运算符
person& operator=(const person& that)
{
    name = that.name;
    age = that.age;
    return *this;
}

// 3. 析构函数
~person()
{
}

管理资源时的显式定义

当类管理资源时，如动态分配的内存，需要显式定义复制构造函数和复制赋值运算符，以实现深拷贝。例如：

#include <cstring>

class person
{
    char* name;
    int age;

public:
    // 构造函数获取资源
    person(const char* the_name, int the_age)
    {
        name = new char[strlen(the_name) + 1];
        strcpy(name, the_name);
        age = the_age;
    }

    // 析构函数释放资源
    ~person()
    {
        delete[] name;
    }

    // 复制构造函数
    person(const person& that)
    {
        name = new char[strlen(that.name) + 1];
        strcpy(name, that.name);
        age = that.age;
    }

    // 复制赋值运算符
    person& operator=(const person& that)
    {
        if (this != &that)
        {
            delete[] name;
            name = new char[strlen(that.name) + 1];
            strcpy(name, that.name);
            age = that.age;
        }
        return *this;
    }
};

异常安全的复制赋值运算符

为了处理内存分配失败的异常情况，可以引入局部变量并重新排序语句：

person& operator=(const person& that)
{
    char* local_name = new char[strlen(that.name) + 1];
    strcpy(local_name, that.name);
    delete[] name;
    name = local_name;
    age = that.age;
    return *this;
}

禁止对象复制

对于一些不能或不应该复制的资源，如文件句柄或互斥锁，可以将复制构造函数和复制赋值运算符声明为private或使用C++11的delete关键字：

class person
{
    // ...
private:
    person(const person& that) = delete;
    person& operator=(const person& that) = delete;
};

核心代码

以下是一个完整的示例，展示了三法则的应用：

#include <iostream>
#include <cstring>

class person
{
    char* name;
    int age;

public:
    // 构造函数
    person(const char* the_name, int the_age)
    {
        name = new char[strlen(the_name) + 1];
        strcpy(name, the_name);
        age = the_age;
    }

    // 析构函数
    ~person()
    {
        delete[] name;
    }

    // 复制构造函数
    person(const person& that)
    {
        name = new char[strlen(that.name) + 1];
        strcpy(name, that.name);
        age = that.age;
    }

    // 复制赋值运算符
    person& operator=(const person& that)
    {
        if (this != &that)
        {
            delete[] name;
            char* local_name = new char[strlen(that.name) + 1];
            strcpy(local_name, that.name);
            name = local_name;
            age = that.age;
        }
        return *this;
    }

    void print() const
    {
        std::cout << "Name: " << name << ", Age: " << age << std::endl;
    }
};

int main()
{
    person a("John", 30);
    person b(a);
    person c("Jane", 25);
    c = a;

    a.print();
    b.print();
    c.print();

    return 0;
}