C++拷贝构造函数与移动构造函数 讲解

注：本文讲解以游戏开发应用为例。

1.拷贝构造函数

在 C++ 中，拷贝构造函数用于创建对象的副本。在游戏开发中，拷贝构造函数的正确使用或禁用对于资源管理至关重要，特别是在处理动态分配的内存或与硬件相关的资源（如纹理、音效）时。

默认拷贝构造函数

如果类没有定义拷贝构造函数，编译器会生成一个默认的拷贝构造函数，它执行浅拷贝，即简单地复制对象的每个成员（包括指针的地址）。这在某些情况下会导致问题，例如两个对象共享同一块动态内存时，修改一个对象会影响另一个，或导致内存释放冲突。

自定义拷贝构造函数（深拷贝）

当类中有指针或动态资源时，通常需要手动实现拷贝构造函数以执行深拷贝。在游戏开发中，这通常应用于管理动态资源的类。

假设我们有一个 Texture 类，负责加载和管理纹理。为了避免资源冲突或重复释放内存，我们可能需要定义一个深拷贝的拷贝构造函数。以下为实例代码：

class Texture {
private:
    char* data;
    int size;
public:
    // 构造函数：分配动态内存来存储纹理数据
    Texture(int s) : size(s) {
        data = new char[size];
        std::cout << "Texture created with size " << size << std::endl;
    }

    // 自定义拷贝构造函数，实现深拷贝
    Texture(const Texture& other) : size(other.size) {
        data = new char[size];
        std::memcpy(data, other.data, size);
        std::cout << "Texture copied with size " << size << std::endl;
    }

    // 析构函数：释放动态内存
    ~Texture() {
        delete[] data;
        std::cout << "Texture destroyed\n";
    }
};

在这个例子中，我们手动实现了拷贝构造函数以执行深拷贝，确保每个 Texture 对象都有自己独立的内存空间。如果我们使用默认的拷贝构造函数，将导致两个对象共享同一块内存，释放资源时可能引发崩溃。

禁用拷贝构造函数

在某些情况下，禁止对象被复制是合理的。例如，当对象管理独占资源时（如文件句柄、硬件资源等），我们通常会禁用拷贝构造函数和赋值操作符，确保对象不能被不安全地复制。

假设我们的 Texture 类管理 GPU 上的纹理资源，复制对象可能导致不必要的资源重复分配或冲突。在这种情况下，我们可以禁用拷贝构造函数和赋值操作符：

class Texture {
public:
    // 禁用拷贝构造函数
    Texture(const Texture&) = delete;

    // 禁用赋值操作符
    Texture& operator=(const Texture&) = delete;

    Texture() {
        std::cout << "Texture created\n";
    }

    ~Texture() {
        std::cout << "Texture destroyed\n";
    }
};

这样，任何复制该类对象的操作都会被编译器阻止：

Texture texture1;
// Texture texture2 = texture1;  // 错误，拷贝构造函数被禁用

2.移动构造函数

移动构造函数是一种特殊的构造函数，用于实现对象的所有权转移，而不是像拷贝构造函数那样复制数据。在现代 C++（尤其是 C++11）中，移动语义被引入以提高程序性能，尤其是在管理动态内存或大数据对象时。通过移动构造函数，可以避免不必要的资源复制，直接“移动”资源的所有权，从而提升效率。

移动构造函数的工作机制

当对象被移动时，其资源（例如内存、文件句柄等）不会被复制，而是直接将源对象的资源转移到目标对象。源对象的资源指针会被置空或重置，以防止两个对象同时指向同一块资源，避免资源冲突。移动构造函数的签名如下：

ClassName(ClassName&& other) noexcept;

• ClassName&&：右值引用，表示临时对象或即将销毁的对象。
• noexcept：表明移动构造函数不会抛出异常（可选，但推荐）。

我们以游戏中的资源管理为例，假设有一个 Texture 类，用于管理动态分配的纹理数据。为了避免频繁的深拷贝带来的性能开销，我们实现一个移动构造函数。

#include <iostream>

class Texture {
private:
    char* data;
    int size;
public:
    // 构造函数：分配资源
    Texture(int s) : size(s) {
        data = new char[size];
        std::cout << "Texture created with size " << size << std::endl;
    }

    // 移动构造函数：移动资源而不是复制
    Texture(Texture&& other) noexcept : data(nullptr), size(0) {
        std::cout << "Texture moved\n";
        
        // 转移所有权
        data = other.data;
        size = other.size;
        
        // 将源对象重置
        other.data = nullptr;
        other.size = 0;
    }

    // 析构函数：释放资源
    ~Texture() {
        if (data) {
            delete[] data;
            std::cout << "Texture destroyed\n";
        } else {
            std::cout << "Texture already moved, no need to destroy\n";
        }
    }
};

int main() {
    Texture texture1(100);  // 创建一个Texture对象
    Texture texture2 = std::move(texture1);  // 使用移动构造函数，移动资源

    return 0;
}

//运行结果
Texture created with size 100
Texture moved
Texture already moved, no need to destroy
Texture destroyed

为什么要使用移动构造函数？

在游戏开发中，许多对象涉及到大量的数据或资源管理（如纹理、网格、音效）。频繁的对象拷贝可能导致性能下降，尤其是在容器（如 std::vector）中频繁插入和删除元素时。如果使用移动语义，对象的资源可以高效地转移，而不会多次复制大块数据。

例如：

在游戏中，加载一个大文件（如地图或场景）时，如果使用拷贝构造函数，会耗费大量时间来复制数据；而使用移动构造函数，数据可以直接转移，极大提升了效率。

std::vector<Texture> textures;
textures.push_back(Texture(100));  // 使用移动构造函数而不是拷贝构造函数

在这行代码中，std::vector 扩展自身存储空间时，如果没有移动构造函数，会频繁触发拷贝构造函数，影响性能。而有了移动构造函数，它会直接“移动”对象的资源，避免不必要的复制开销。

禁用移动构造函数

如果某个类不允许移动操作，可以禁用移动构造函数。例如，如果某类对象管理独占资源（如硬件设备或文件句柄），移动该类对象可能会导致意外行为。在这种情况下，我们可以显式禁用移动构造函数：

class NonMovable {
public:
    NonMovable() = default;

    // 禁用移动构造函数和移动赋值操作符
    NonMovable(NonMovable&&) = delete;
    NonMovable& operator=(NonMovable&&) = delete;
};

这样，任何移动该类对象的操作都会被编译器阻止：

NonMovable obj1;
// NonMovable obj2 = std::move(obj1);  // 错误，移动构造函数被禁用

3.拷贝构造函数 vs 移动构造函数

• 拷贝构造函数：创建对象的副本，需要分配新资源并复制数据。
• 移动构造函数：直接“移动”资源的所有权，避免复制，提升效率。