37. 如何将移动语义应用于自定义的RAII类？

RAII（Resource Acquisition Is Initialization）是C++里最核心的设计思想之一。说白了就是——资源在构造函数里拿，在析构函数里还。我做了这么多年C++，可以说没有RAII，现代C++的很多优雅写法都无从谈起。

但问题来了：RAII类通常管理着独占资源（比如堆内存、文件句柄、锁）。这类对象不能随便拷贝。那怎么办？移动语义就是答案。

RAII类的核心痛点

先看一个典型的RAII类——管理动态数组：

class Buffer {
public:
    explicit Buffer(size_t size)
        : data_(new int[size]), size_(size) {
        // 构造函数获取资源
    }

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

    // 问题来了：拷贝怎么办？
private:
    int* data_;
    size_t size_;
};

这个类如果直接拷贝，会出大问题——两个对象指向同一块内存，析构时double free。所以要么禁止拷贝，要么实现深拷贝。但深拷贝代价高，而且很多时候我们只是想把资源「转移」给另一个对象。

实现移动构造函数和移动赋值运算符

嗯，这里要注意几个关键点。我直接给一个完整的实现，你一看就明白：

class Buffer {
public:
    // 构造函数
    explicit Buffer(size_t size)
        : data_(new int[size]), size_(size) {
    }

    // 析构函数
    ~Buffer() {
        delete[] data_;
    }

    // 移动构造函数
    Buffer(Buffer&& other) noexcept
        : data_(other.data_), size_(other.size_) {
        // 把源对象置为空壳
        other.data_ = nullptr;
        other.size_ = 0;
    }

    // 移动赋值运算符
    Buffer& operator=(Buffer&& other) noexcept {
        if (this != &other) {          // 自赋值检查
            delete[] data_;            // 释放当前资源
            data_ = other.data_;       // 接管源对象资源
            size_ = other.size_;
            other.data_ = nullptr;     // 源对象置空
            other.size_ = 0;
        }
        return *this;
    }

    // 禁止拷贝（或者你也可以实现深拷贝）
    Buffer(const Buffer&) = delete;
    Buffer& operator=(const Buffer&) = delete;

private:
    int* data_;
    size_t size_;
};

这段代码有几个关键点，我一个个说：

• noexcept 关键字：移动操作必须标记为 noexcept。为什么？因为标准库容器（比如 vector）在重新分配内存时，如果移动操作不抛异常，它会优先用移动；否则只能退回到拷贝。我遇到过好几次因为漏掉 noexcept 导致性能骤降的情况。
• 源对象置空：移动后源对象必须处于「有效但未指定」的状态。通常做法是把指针置为 nullptr，这样析构时 delete nullptr 是安全的。
• 自赋值检查：移动赋值里一定要检查 this != &other。虽然移动自赋值很少见，但万一出现，没有检查就会把资源释放掉。

一个更复杂的例子：管理文件句柄

我在项目中遇到过管理文件句柄的RAII类。文件句柄不是指针，但道理一样：

class FileHandle {
public:
    explicit FileHandle(const char* filename)
        : handle_(fopen(filename, "w")) {
        if (!handle_) {
            throw std::runtime_error("打开文件失败");
        }
    }

    ~FileHandle() {
        if (handle_) {
            fclose(handle_);
        }
    }

    // 移动构造函数
    FileHandle(FileHandle&& other) noexcept
        : handle_(other.handle_) {
        other.handle_ = nullptr;  // 源对象不再拥有文件句柄
    }

    // 移动赋值运算符
    FileHandle& operator=(FileHandle&& other) noexcept {
        if (this != &other) {
            if (handle_) fclose(handle_);  // 关闭当前文件
            handle_ = other.handle_;        // 接管新句柄
            other.handle_ = nullptr;        // 源对象置空
        }
        return *this;
    }

    // 禁止拷贝
    FileHandle(const FileHandle&) = delete;
    FileHandle& operator=(const FileHandle&) = delete;

    // 提供写入接口
    void write(const char* data) {
        if (handle_) {
            fputs(data, handle_);
        }
    }

private:
    FILE* handle_;
};

移动语义与「五法则」

C++98时代有「三法则」——如果你需要自定义析构函数、拷贝构造函数、拷贝赋值运算符中的任何一个，那么三个都需要。到了C++11，变成了「五法则」——再加上移动构造函数和移动赋值运算符。

法则	需要实现的函数	适用场景
三法则（C++98）	析构函数、拷贝构造、拷贝赋值	管理资源的类，不支持移动
五法则（C++11）	析构函数、拷贝构造、拷贝赋值、移动构造、移动赋值	管理资源的类，支持移动
零法则	什么都不写	使用标准库组件管理资源

你想想看，如果你的类里只有普通数据成员（int、string、vector），那根本不用自己写移动操作——编译器生成的默认移动就够用了。这就是「零法则」的精髓。

移动语义与标准库容器的配合

实现了移动语义的RAII类，可以和标准库无缝配合。比如：

std::vector<Buffer> buffers;
buffers.push_back(Buffer(1024));  // 临时对象，触发移动构造
buffers.emplace_back(2048);       // 直接在容器内构造

// 从函数返回RAII对象
Buffer createBuffer(size_t size) {
    Buffer buf(size);
    // ... 做一些操作
    return buf;  // 移动构造（甚至可能被NRVO优化掉）
}

没有移动语义的话，上面的代码要么编译失败（如果拷贝被删除），要么产生昂贵的深拷贝。有了移动语义，这些操作都是O(1)的指针交换。

知识体系总览

下面这张图总结了RAII类应用移动语义的核心逻辑：

总结一下

把移动语义应用到RAII类，说白了就是三步：

1. 实现移动构造函数：接管源对象的资源，把源对象置为空壳
2. 实现移动赋值运算符：先释放当前资源，再接管源对象资源，最后置空源对象
3. 标记 noexcept：让标准库容器能放心使用你的移动操作

记住一点：移动语义不是用来替代拷贝的，而是提供一种更高效的资源转移方式。对于RAII类来说，移动语义让资源所有权可以安全、高效地流转，这正是现代C++的核心设计理念之一。