8. 默认移动操作：编译器何时自动生成移动构造/赋值，Rule of Five

好，咱们来聊聊一个很实际的问题：编译器到底什么时候会“顺手”帮你把移动构造和移动赋值给生成了？

我记得刚学C++11那会儿，我特别兴奋——终于有移动语义了！然后我写了个类，里面就一个 std::vector<int> 成员，心想这下移动肯定飞快。结果一测性能，跟拷贝一样慢。查了半天才发现，编译器根本没给我生成移动构造函数。

为什么会这样？因为编译器生成默认移动操作，是有严格条件的。

编译器生成默认移动操作的条件

说白了，编译器只在以下所有条件都满足时，才会隐式声明一个默认的移动构造函数或移动赋值运算符：

• 没有用户自定义的拷贝构造函数
• 没有用户自定义的拷贝赋值运算符
• 没有用户自定义的移动构造函数
• 没有用户自定义的移动赋值运算符
• 没有用户自定义的析构函数

嗯，你想想看，这五个条件缺一不可。只要你自己写了其中一个，编译器就“罢工”了，不再帮你生成默认移动操作。

默认移动操作的行为

如果编译器真的生成了默认移动操作，它会做什么？很简单：对每个非静态成员进行逐成员移动。

• 对于内置类型（int、double、指针等）：直接按位拷贝（相当于浅拷贝）
• 对于类类型成员：调用该成员的移动构造函数或移动赋值运算符

举个例子：

class Widget {
    std::string name;
    std::vector<int> data;
    int id;
};

// 编译器生成的默认移动构造函数，等价于：
Widget(Widget&& other) 
    : name(std::move(other.name))
    , data(std::move(other.data))
    , id(other.id)  // int 没有移动语义，直接拷贝
{}

这里有个坑，我曾经踩过：如果某个成员类型没有移动构造函数，但可以拷贝，那么移动操作会退化为拷贝操作。说白了就是“能移则移，不能移就拷”。

Rule of Five：五法则

好，那什么时候该自己动手写这五个函数呢？

我个人的习惯是：只要类管理了资源（动态内存、文件句柄、网络连接等），就把五个函数都显式写出来。这就是所谓的 Rule of Five。

函数	作用	何时需要自定义
析构函数	释放资源	类管理了资源
拷贝构造函数	深拷贝资源	需要独立副本
拷贝赋值运算符	深拷贝并释放旧资源	需要独立副本
移动构造函数	转移资源所有权	需要高效转移
移动赋值运算符	转移资源并释放旧资源	需要高效转移

Rule of Zero vs Rule of Five

其实还有另一种思路：Rule of Zero。意思是，如果你的类不管理任何资源，那就一个特殊成员函数都不要写，全让编译器生成默认的。

我个人更倾向于 Rule of Zero。你想想看，能用标准库容器和智能指针解决的问题，就别自己手写资源管理。这样代码更简洁，也不容易出错。

但如果你真的需要自己管理资源（比如实现一个自定义的内存池），那就老老实实把五个函数都写全。

一个完整的例子

咱们来看一个实际场景。假设你要实现一个简单的 Buffer 类：

class Buffer {
    int* data;
    size_t size;
public:
    // 构造函数
    Buffer(size_t n) : data(new int[n]), size(n) {}
    
    // 析构函数
    ~Buffer() { delete[] data; }
    
    // 拷贝构造函数
    Buffer(const Buffer& other) 
        : data(new int[other.size]), size(other.size) {
        std::copy(other.data, other.data + size, data);
    }
    
    // 拷贝赋值运算符
    Buffer& operator=(const Buffer& other) {
        if (this != &other) {
            delete[] data;
            data = new int[other.size];
            size = other.size;
            std::copy(other.data, other.data + size, data);
        }
        return *this;
    }
    
    // 移动构造函数
    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;
    }
};

注意看移动操作里的 noexcept。这个关键字很重要——标准库容器（比如 std::vector）在重新分配内存时，会优先使用 noexcept 的移动操作。如果没有 noexcept，它宁愿用拷贝操作，因为拷贝更安全（不会抛出异常后留下半残的对象）。

知识体系图

下面这张图总结了编译器生成默认移动操作的条件，以及 Rule of Five 的核心逻辑：

总结一下

嗯，咱们把今天的内容捋一捋：

• 编译器生成默认移动操作的条件非常严格——五个特殊成员函数都不能自定义
• 默认移动操作是逐成员移动，能移则移，不能移就拷
• Rule of Five：只要自定义了析构函数、拷贝构造或拷贝赋值中的任何一个，就应该把五个函数都考虑全
• Rule of Zero：能用标准库组件就别自己写，让编译器帮你搞定一切
• 移动操作记得加 noexcept，这对标准库容器的性能至关重要

我个人在实际项目中，大部分类都遵循 Rule of Zero。只有那些真正需要精细控制资源的底层组件，我才会手写 Rule of Five。这样代码既高效又不容易出 bug。

---

公众号:蓝海资料掘金营，微信deep3321