C++类缺省函数的重载规则

一、缺省函数概述

在C++ 中，缺省函数是指类中编译器会自动生成的一些特殊成员函数，当程序员没有显式定义这些函数时，编译器会为类提供默认实现。这些缺省函数主要包括：默认构造函数、析构函数、拷贝构造函数、拷贝赋值运算符重载函数、移动构造函数以及移动赋值运算符重载函数。了解这些缺省函数的重载规则对于编写高效、正确且符合现代C++ 编程习惯的代码至关重要。

二、默认构造函数

2.1 默认构造函数的生成规则

默认构造函数是在没有提供任何实参的情况下用于创建对象的构造函数。当类中没有定义任何构造函数时，编译器会生成一个默认构造函数。例如：

class MyClass {
    int data;
public:
    // 这里没有定义构造函数，编译器会生成默认构造函数
    int get_data() const {
        return data;
    }
};

在上述代码中，MyClass 类没有定义构造函数，编译器会生成一个默认构造函数。这个默认构造函数会执行默认初始化，对于 int 类型的成员变量 data，它的值是未定义的。

2.2 自定义默认构造函数与编译器生成的区别

如果我们显式定义了一个默认构造函数，情况就会有所不同。例如：

class MyClass {
    int data;
public:
    MyClass() : data(0) {
        // 自定义默认构造函数，将data初始化为0
    }
    int get_data() const {
        return data;
    }
};

此时，程序员定义的默认构造函数会按照代码逻辑对 data 进行初始化。与编译器生成的默认构造函数相比，自定义构造函数可以进行更复杂的初始化操作，确保对象在创建时处于一个合理的初始状态。

2.3 特殊情况：类成员的初始化要求

如果类中有成员变量是 const 类型或者引用类型，编译器生成的默认构造函数就无法满足初始化要求。因为 const 成员和引用成员必须在初始化列表中进行初始化。例如：

class MyClass {
    const int id;
    int& ref;
public:
    // 下面这种情况编译器不会生成默认构造函数，因为id和ref需要初始化
    MyClass(int i, int& r) : id(i), ref(r) {
    }
};

在这个例子中，MyClass 类包含一个 const int 类型的成员 id 和一个 int& 类型的成员 ref。由于这两个成员需要在初始化列表中初始化，编译器不会为该类生成默认构造函数，程序员必须显式定义构造函数来满足初始化要求。

三、析构函数

3.1 析构函数的生成规则

析构函数用于在对象销毁时执行清理工作，例如释放动态分配的内存。当类中没有定义析构函数时，编译器会生成一个默认析构函数。例如：

class MyClass {
    int data;
public:
    // 未定义析构函数，编译器生成默认析构函数
    ~MyClass() = default;
};

这里显式使用 = default 来告诉编译器使用默认生成的析构函数，这与隐式生成的效果是一样的。默认析构函数会按成员声明的相反顺序调用成员的析构函数。

3.2 自定义析构函数的必要性

如果类中包含动态分配的资源，如使用 new 分配的内存或者打开的文件句柄等，就需要自定义析构函数来释放这些资源，以避免内存泄漏。例如：

class MyClass {
    int* data;
public:
    MyClass() {
        data = new int[10];
    }
    ~MyClass() {
        delete[] data;
    }
};

在上述代码中，MyClass 类在构造函数中使用 new 分配了一个包含 10 个 int 的数组。在析构函数中，通过 delete[] 释放了这块内存，确保资源得到正确释放。

3.3 析构函数的调用时机

析构函数在对象生命周期结束时被调用，这包括以下几种情况：

局部对象：当函数执行结束，局部对象的作用域结束，其析构函数会被调用。
动态分配的对象：当使用 delete 操作符释放通过 new 分配的对象时，析构函数会被调用。
对象数组：当对象数组的生命周期结束时，数组中每个对象的析构函数会按顺序被调用。

四、拷贝构造函数

4.1 拷贝构造函数的生成规则

拷贝构造函数用于通过另一个同类型对象来创建新对象，进行深拷贝操作。当类中没有定义拷贝构造函数时，编译器会生成一个默认拷贝构造函数。例如：

class MyClass {
    int data;
public:
    // 未定义拷贝构造函数，编译器生成默认拷贝构造函数
    MyClass(const MyClass& other) = default;
};

默认拷贝构造函数会执行成员变量的逐成员拷贝，对于基本数据类型，这种拷贝方式是合适的。但对于包含动态分配资源的类，默认拷贝构造函数可能会导致问题。

4.2 浅拷贝与深拷贝问题

考虑以下包含动态分配内存的类：

class MyClass {
    int* data;
public:
    MyClass() {
        data = new int(0);
    }
    // 未定义拷贝构造函数，编译器生成默认拷贝构造函数（浅拷贝）
    ~MyClass() {
        delete data;
    }
};

如果使用默认拷贝构造函数，会出现浅拷贝问题。即新对象和原对象的 data 指针指向同一块内存。当其中一个对象销毁时，释放了这块内存，另一个对象的 data 指针就变成了野指针，可能导致程序崩溃。为了避免这种情况，需要自定义深拷贝的拷贝构造函数：

class MyClass {
    int* data;
public:
    MyClass() {
        data = new int(0);
    }
    MyClass(const MyClass& other) {
        data = new int(*other.data);
    }
    ~MyClass() {
        delete data;
    }
};

在这个自定义拷贝构造函数中，为新对象分配了新的内存，并将原对象 data 指向的值复制到新内存中，实现了深拷贝。

4.3 拷贝构造函数的调用场景

显式初始化：当使用一个已存在的对象来显式初始化另一个对象时，拷贝构造函数会被调用。例如：MyClass obj1; MyClass obj2(obj1);
函数参数传递：当对象作为函数参数按值传递时，会调用拷贝构造函数创建一个副本传递给函数。例如：void func(MyClass obj) { /*... */ }
函数返回值：当函数按值返回对象时，会调用拷贝构造函数创建一个临时对象返回给调用者。例如：MyClass func() { MyClass obj; return obj; }

五、拷贝赋值运算符重载函数

5.1 拷贝赋值运算符重载函数的生成规则

拷贝赋值运算符 operator= 用于将一个对象的值赋给另一个同类型的对象。当类中没有定义拷贝赋值运算符重载函数时，编译器会生成一个默认的拷贝赋值运算符重载函数。例如：

class MyClass {
    int data;
public:
    // 未定义拷贝赋值运算符重载函数，编译器生成默认版本
    MyClass& operator=(const MyClass& other) = default;
};

默认拷贝赋值运算符重载函数会执行成员变量的逐成员赋值，与默认拷贝构造函数类似，对于包含动态分配资源的类，这种默认实现可能会导致问题。

5.2 自定义拷贝赋值运算符重载函数的实现

同样以包含动态分配内存的类为例，默认的拷贝赋值运算符重载函数会出现浅拷贝问题。为了实现深拷贝，需要自定义拷贝赋值运算符重载函数：

class MyClass {
    int* data;
public:
    MyClass() {
        data = new int(0);
    }
    MyClass& operator=(const MyClass& other) {
        if (this != &other) {
            delete data;
            data = new int(*other.data);
        }
        return *this;
    }
    ~MyClass() {
        delete data;
    }
};

在这个自定义实现中，首先检查是否是自赋值（this != &other），如果不是，则释放原对象的内存，然后为新值分配内存并复制数据，最后返回 *this 以支持链式赋值。

5.3 拷贝赋值运算符重载函数与拷贝构造函数的区别

拷贝构造函数用于创建新对象并初始化，而拷贝赋值运算符重载函数用于将已存在对象的值赋给另一个已存在的对象。例如：

MyClass obj1;
MyClass obj2(obj1); // 调用拷贝构造函数
MyClass obj3;
obj3 = obj1; // 调用拷贝赋值运算符重载函数

六、移动构造函数

6.1 移动构造函数的生成规则

移动构造函数用于从一个即将销毁的对象中“窃取”资源，而不是进行深拷贝。当类中没有定义移动构造函数，且满足一定条件时，编译器会生成一个默认移动构造函数。这些条件包括：类中没有显式声明的移动构造函数、移动赋值运算符重载函数、拷贝构造函数和拷贝赋值运算符重载函数，并且类的所有非静态数据成员都可以进行移动构造。例如：

class MyClass {
    int* data;
public:
    MyClass() {
        data = new int(0);
    }
    // 未定义移动构造函数，满足条件时编译器生成默认移动构造函数
    ~MyClass() {
        delete data;
    }
};

6.2 自定义移动构造函数的实现

当类中包含动态分配的资源时，自定义移动构造函数可以提高性能。例如：

class MyClass {
    int* data;
public:
    MyClass() {
        data = new int(0);
    }
    MyClass(MyClass&& other) noexcept {
        data = other.data;
        other.data = nullptr;
    }
    ~MyClass() {
        delete data;
    }
};

在这个自定义移动构造函数中，将 other 对象的 data 指针直接拿过来，然后将 other.data 设为 nullptr，这样 other 对象在销毁时不会释放已经被“窃取”的资源。noexcept 说明这个函数不会抛出异常，有助于编译器进行优化。

6.3 移动构造函数的调用场景

移动构造函数主要在以下场景被调用：

右值作为参数传递：当一个右值（临时对象）作为函数参数传递时，移动构造函数可能会被调用。例如：MyClass func() { MyClass obj; return obj; } MyClass newObj(func());
容器操作：在容器插入、删除等操作中，如果涉及到对象的移动，移动构造函数会被调用。例如，std::vector<MyClass> vec; MyClass obj; vec.push_back(std::move(obj));

七、移动赋值运算符重载函数

7.1 移动赋值运算符重载函数的生成规则

移动赋值运算符 operator= 用于将一个即将销毁的对象的资源移动到另一个对象中。当类中没有定义移动赋值运算符重载函数，且满足与默认移动构造函数类似的条件时，编译器会生成一个默认移动赋值运算符重载函数。例如：

class MyClass {
    int* data;
public:
    MyClass() {
        data = new int(0);
    }
    // 未定义移动赋值运算符重载函数，满足条件时编译器生成默认版本
    ~MyClass() {
        delete data;
    }
};

7.2 自定义移动赋值运算符重载函数的实现

与移动构造函数类似，对于包含动态分配资源的类，自定义移动赋值运算符重载函数可以提高性能。例如：

class MyClass {
    int* data;
public:
    MyClass() {
        data = new int(0);
    }
    MyClass& operator=(MyClass&& other) noexcept {
        if (this != &other) {
            delete data;
            data = other.data;
            other.data = nullptr;
        }
        return *this;
    }
    ~MyClass() {
        delete data;
    }
};

在这个自定义实现中，首先检查是否是自赋值，然后释放原对象的资源，将 other 对象的资源“窃取”过来，并将 other.data 设为 nullptr，最后返回 *this 以支持链式赋值。

7.3 移动赋值运算符重载函数与拷贝赋值运算符重载函数的区别

移动赋值运算符重载函数处理的是右值，将资源从一个即将销毁的对象移动过来，而拷贝赋值运算符重载函数处理的是左值，进行深拷贝操作。例如：

MyClass obj1;
MyClass obj2;
obj2 = std::move(obj1); // 调用移动赋值运算符重载函数
MyClass obj3;
obj3 = obj2; // 调用拷贝赋值运算符重载函数

八、缺省函数之间的相互影响

显式定义构造函数对默认构造函数的影响：一旦类中显式定义了任何构造函数（非默认构造函数也算），编译器就不会再生成默认构造函数。例如：

class MyClass {
    int data;
public:
    MyClass(int value) : data(value) {
    }
    // 这里编译器不会生成默认构造函数
};

显式定义析构函数对其他缺省函数的影响：显式定义析构函数通常会阻止编译器生成移动构造函数和移动赋值运算符重载函数。这是因为编译器认为程序员可能在析构函数中有特殊的资源清理逻辑，移动操作可能会干扰这种逻辑。例如：

class MyClass {
    int* data;
public:
    MyClass() {
        data = new int(0);
    }
    ~MyClass() {
        delete data;
    }
    // 编译器通常不会生成移动构造函数和移动赋值运算符重载函数
};

显式定义拷贝构造函数或拷贝赋值运算符重载函数对移动构造函数和移动赋值运算符重载函数的影响：如果显式定义了拷贝构造函数或拷贝赋值运算符重载函数，编译器通常也不会生成移动构造函数和移动赋值运算符重载函数。这是因为编译器认为程序员可能有特殊的拷贝逻辑，移动操作可能不符合预期。例如：

class MyClass {
    int* data;
public:
    MyClass() {
        data = new int(0);
    }
    MyClass(const MyClass& other) {
        data = new int(*other.data);
    }
    // 编译器通常不会生成移动构造函数和移动赋值运算符重载函数
};

九、总结缺省函数重载规则的重要性

遵循C++ 类缺省函数的重载规则对于编写高质量、高效且无错误的代码至关重要。合理定义默认构造函数、析构函数、拷贝构造函数、拷贝赋值运算符重载函数、移动构造函数和移动赋值运算符重载函数，可以确保对象的正确初始化、资源的合理管理以及在不同场景下对象的高效操作。在现代C++ 编程中，理解并正确应用这些规则是编写性能良好、可维护性强的代码的基础。同时，注意缺省函数之间的相互影响，避免因编译器行为不符合预期而导致的潜在错误。通过深入理解这些规则，开发者能够更好地控制对象的生命周期和资源管理，编写出健壮的C++ 程序。

在实际编程中，应根据类的具体需求来决定是否需要自定义这些缺省函数。对于简单的类，编译器生成的默认实现可能已经足够；但对于包含动态分配资源、复杂数据结构或特殊逻辑的类，必须仔细考虑并正确实现这些函数，以保证程序的正确性和高效性。同时，随着C++ 标准的不断发展，这些规则也可能会有一些细微的变化，开发者需要持续关注并学习新的特性和规则，以适应不断变化的编程环境。

以上对C++ 类缺省函数的重载规则进行了全面且深入的阐述，希望能帮助读者在实际编程中更好地运用这些知识，编写出更优秀的C++ 代码。