C++中的Implicitly-Defined Special Member Functions：编译器自动生成规则与陷阱 - 智猿学院-前后端，数据库，人工智能，云计算等领域前沿技术讲座

C++中的隐式定义特殊成员函数：编译器自动生成规则与陷阱

大家好，今天我们来深入探讨C++中一个非常重要但又容易被忽视的特性：隐式定义的特殊成员函数 (Implicitly-Defined Special Member Functions)。C++为了简化代码编写，在某些特定情况下，会自动为类生成一些特殊的成员函数。这些函数在类的生命周期中扮演着关键角色，理解它们的生成规则和潜在陷阱对于编写健壮、高效且易于维护的C++代码至关重要。

什么是特殊成员函数？

特殊成员函数是指在C++类中具有特殊含义的成员函数。它们通常与对象的创建、复制、移动和销毁相关。C++标准定义了以下六种特殊成员函数：

默认构造函数 (Default Constructor): 没有参数或者所有参数都有默认值的构造函数。
析构函数 (Destructor): 用于清理对象资源，在对象销毁时调用。
拷贝构造函数 (Copy Constructor): 用于创建一个现有对象的副本。
拷贝赋值运算符 (Copy Assignment Operator): 用于将一个现有对象的值赋值给另一个现有对象。
移动构造函数 (Move Constructor): 用于将一个对象的资源“移动”到另一个对象，而不再进行深拷贝。
移动赋值运算符 (Move Assignment Operator): 用于将一个对象的资源“移动”到另一个对象，而不再进行深拷贝。

编译器何时以及如何生成这些函数？

C++编译器并非总是会为每个类生成所有六个特殊成员函数。编译器会根据类的定义和使用情况，有选择性地生成这些函数。理解编译器的生成规则是避免潜在问题的关键。

下面是一个总结编译器生成规则的表格：

特殊成员函数	编译器生成条件
默认构造函数	1. 类中没有声明任何构造函数 (包括拷贝构造函数、移动构造函数等)。
析构函数	1. 总是会被声明 (可以是隐式声明的或用户声明的)。
拷贝构造函数	1. 类中没有声明拷贝构造函数。
拷贝赋值运算符	1. 类中没有声明拷贝赋值运算符。
移动构造函数	1. 类中没有声明拷贝构造函数、拷贝赋值运算符、移动赋值运算符或析构函数。
移动赋值运算符	1. 类中没有声明拷贝构造函数、拷贝赋值运算符、移动构造函数或析构函数。

默认生成行为 (Default Behavior)

当编译器需要生成特殊成员函数时，默认情况下它会执行“浅拷贝 (Shallow Copy)”或“浅移动 (Shallow Move)”。

浅拷贝: 浅拷贝意味着简单地复制对象中的所有成员变量的值。对于指针成员变量，浅拷贝只会复制指针的值，而不会复制指针指向的内存。这意味着原始对象和副本对象将指向相同的内存地址。
浅移动: 浅移动与浅拷贝类似，但是它会将原始对象中的指针成员变量设置为 nullptr，以防止原始对象在析构时释放已经被移动的资源。

代码示例：默认构造函数

#include <iostream>

class MyClass {
public:
  int x;
  double y;
};

int main() {
  MyClass obj; // 使用编译器生成的默认构造函数
  std::cout << "x: " << obj.x << ", y: " << obj.y << std::endl; // 输出未初始化的值
  return 0;
}

在这个例子中，MyClass 没有声明任何构造函数，因此编译器会自动生成一个默认构造函数。这个默认构造函数不会初始化 x 和 y 成员变量，因此它们的值是未定义的。

代码示例：拷贝构造函数和拷贝赋值运算符

#include <iostream>

class MyString {
public:
  MyString(const char* str) {
    size_t len = strlen(str);
    data = new char[len + 1];
    strcpy(data, str);
    std::cout << "Constructor called" << std::endl;
  }

  ~MyString() {
    delete[] data;
    std::cout << "Destructor called" << std::endl;
  }

  char* getData() const { return data; }

private:
  char* data;
};

int main() {
  MyString str1("Hello");
  MyString str2 = str1; // 调用编译器生成的拷贝构造函数
  std::cout << "str1 data: " << str1.getData() << std::endl;
  std::cout << "str2 data: " << str2.getData() << std::endl;

  // 内存泄漏和 double free 错误
  return 0;
}

在这个例子中，MyString 类有一个字符指针 data，指向动态分配的内存。当使用编译器生成的拷贝构造函数时，str2 的 data 指针会简单地复制 str1 的 data 指针的值。这意味着 str1 和 str2 的 data 指针指向相同的内存地址。当 str1 和 str2 对象销毁时，它们会尝试释放相同的内存，导致 double free 错误。此外，原始的 str2 所分配的内存也发生了泄漏。

代码示例：移动构造函数和移动赋值运算符

#include <iostream>
#include <utility>

class MyString {
public:
  MyString(const char* str) {
    size_t len = strlen(str);
    data = new char[len + 1];
    strcpy(data, str);
    std::cout << "Constructor called" << std::endl;
  }

  MyString(MyString&& other) noexcept {
    data = other.data;
    other.data = nullptr;
    std::cout << "Move constructor called" << std::endl;
  }

  MyString& operator=(MyString&& other) noexcept {
    if (this != &other) {
      delete[] data;
      data = other.data;
      other.data = nullptr;
      std::cout << "Move assignment operator called" << std::endl;
    }
    return *this;
  }

  ~MyString() {
    delete[] data;
    std::cout << "Destructor called" << std::endl;
  }

  char* getData() const { return data; }

private:
  char* data;
};

int main() {
  MyString str1("Hello");
  MyString str2 = std::move(str1); // 调用移动构造函数
  std::cout << "str1 data: " << str1.getData() << std::endl; // str1.data is nullptr
  std::cout << "str2 data: " << str2.getData() << std::endl; // str2.data points to "Hello"
  return 0;
}

在这个例子中，我们定义了移动构造函数和移动赋值运算符。移动构造函数将 other 对象的 data 指针移动到当前对象，并将 other 对象的 data 指针设置为 nullptr。这样可以避免深拷贝，提高效率。

何时需要自定义特殊成员函数？

当类中包含以下情况时，通常需要自定义特殊成员函数：

拥有资源: 类管理动态分配的内存、文件句柄、网络连接等资源。
需要深拷贝: 默认的浅拷贝不能满足需求，需要复制资源的内容。
类中有const或引用成员: 编译器隐式生成的赋值操作符往往不能处理const成员或引用成员的赋值。

禁用特殊成员函数

有时候，我们希望禁止编译器生成某些特殊成员函数。可以使用 = delete 关键字来显式地禁用它们。

class Uncopyable {
public:
  Uncopyable() = default;
  Uncopyable(const Uncopyable&) = delete;
  Uncopyable& operator=(const Uncopyable&) = delete;
};

在这个例子中，我们禁用了拷贝构造函数和拷贝赋值运算符，这意味着 Uncopyable 类的对象不能被复制。

规则的优先级：定义与隐式生成

需要特别注意的是，用户自定义的特殊成员函数会阻止编译器生成对应的隐式版本。例如，如果你显式定义了拷贝构造函数，编译器就不会再自动生成拷贝构造函数，但是仍然可能生成移动构造函数（如果满足生成条件）。

示例：更复杂的资源管理

#include <iostream>

class FileHandler {
public:
  FileHandler(const char* filename) : file(fopen(filename, "r")) {
    if (!file) {
      throw std::runtime_error("Failed to open file");
    }
    std::cout << "File opened" << std::endl;
  }

  FileHandler(const FileHandler& other) : file(nullptr) { // 拷贝构造函数
        if (other.file) {
            // 安全地拷贝文件句柄 (例如，通过创建临时文件)
            // 这里为了简化，我们直接抛出异常，表示不支持拷贝
            throw std::runtime_error("Copying FileHandler is not allowed.");
        }
        std::cout << "Copy constructor called (but disabled)" << std::endl;
    }

    FileHandler& operator=(const FileHandler& other) {  // 拷贝赋值运算符
        if (this != &other) {
            // 同样，为了简化，我们抛出异常，表示不支持赋值
            throw std::runtime_error("Assignment of FileHandler is not allowed.");
        }
        std::cout << "Copy assignment operator called (but disabled)" << std::endl;
        return *this;
    }

  FileHandler(FileHandler&& other) noexcept : file(other.file) { // 移动构造函数
    other.file = nullptr;
    std::cout << "Move constructor called" << std::endl;
  }

  FileHandler& operator=(FileHandler&& other) noexcept { // 移动赋值运算符
    if (this != &other) {
      fclose(file);
      file = other.file;
      other.file = nullptr;
      std::cout << "Move assignment operator called" << std::endl;
    }
    return *this;
  }

  ~FileHandler() {
    if (file) {
      fclose(file);
      std::cout << "File closed" << std::endl;
    }
  }

private:
  FILE* file;
};

int main() {
  try {
    FileHandler file1("test.txt");

    //FileHandler file2 = file1; // 拷贝构造函数 (会抛出异常)
    //FileHandler file3("another.txt");
    //file3 = file1; // 拷贝赋值运算符 (会抛出异常)

    FileHandler file4 = std::move(file1); // 移动构造函数
    // file1不再拥有资源，file4拥有资源
    std::cout << "Moving successful." << std::endl;

  } catch (const std::exception& e) {
    std::cerr << "Exception: " << e.what() << std::endl;
  }

  return 0;
}

在这个例子中，FileHandler 类管理一个文件句柄。我们自定义了拷贝构造函数和拷贝赋值运算符，并抛出异常，表示不支持拷贝。我们还自定义了移动构造函数和移动赋值运算符，用于将文件句柄的所有权从一个对象转移到另一个对象。

需要考虑的陷阱

Rule of Zero/Five: 如果你的类不需要自定义任何特殊成员函数，那么就不要自定义它们。让编译器自动生成默认版本。如果需要自定义析构函数，则很可能需要自定义拷贝构造函数、拷贝赋值运算符、移动构造函数和移动赋值运算符 (Rule of Five)。C++11引入了Rule of Zero，建议尽可能的使用RAII手法管理资源，让类不需要自定义析构函数，从而也不需要定义拷贝/移动构造和赋值函数。
编译器优化: 编译器可能会优化掉一些拷贝或移动操作。不要依赖于拷贝构造函数或移动构造函数中的副作用。
异常安全: 自定义特殊成员函数时，要特别注意异常安全。确保在发生异常时，资源不会泄漏，对象的状态保持一致。
noexcept 说明符: 移动构造函数和移动赋值运算符应该声明为 noexcept，以允许编译器进行更多的优化。
继承和多态: 在继承体系中，特殊成员函数的行为可能会变得复杂。需要仔细考虑基类和派生类的特殊成员函数之间的关系。

避免资源泄漏和悬挂指针

理解浅拷贝和浅移动的局限性，并采取适当的措施来避免资源泄漏和悬挂指针是至关重要的。始终确保你的类正确地管理资源，并在对象销毁时释放所有已分配的资源。

总结关键点

编译器会自动生成一些特殊的成员函数，以简化代码编写。
默认情况下，编译器会执行浅拷贝或浅移动。
当类管理资源或需要深拷贝时，需要自定义特殊成员函数。
可以使用 = delete 关键字来禁用特殊成员函数。
需要注意异常安全和编译器优化。
理解 Rule of Zero/Five，选择合适的资源管理策略。

理解编译器行为，编写更健壮的代码

掌握C++中隐式定义特殊成员函数的规则对于写出更健壮、可维护的代码至关重要。理解编译器何时生成这些函数，以及它们的默认行为，能帮助我们避免潜在的错误，并编写出更高效的代码。

更多IT精英技术系列讲座，到智猿学院

C++中的隐式定义特殊成员函数：编译器自动生成规则与陷阱

发表回复 取消回复

发表回复取消回复