第28章常见陷阱

课程目录第28章常见陷阱

28. 常见陷阱：移动后状态、自移动、const对象移动、多次移动

移动语义出来这么多年了，我依然在代码评审里看到各种「想当然」的用法。说实话，C++的移动语义并不难，但坑全藏在细节里。今天咱们就聊聊四个最常见的陷阱——移动后状态、自移动、const对象移动、还有多次移动。

每个我都踩过，有的还不止一次。嗯，咱们一个一个说。

28.1 移动后状态：别假设它是空的

标准里只说了移动后的对象处于「有效但未指定」的状态。说白了，就是能用，但值是什么没人保证。

我见过有人这么写：

std::vector<int> v1 = {1, 2, 3, 4, 5};
std::vector<int> v2 = std::move(v1);

// 然后想当然地认为 v1 是空的
v1.push_back(100);   // 这行没问题，但 v1.size() 不一定是 0

你想想看，标准库的实现里，移动后的vector大概率是空的，但你不能依赖这个。不同的编译器、不同的版本，行为可能不一样。

⚠️ 警告：移动后的对象只能做两件事：销毁，或者重新赋值。别去读它的值，也别假设它的大小。

我在项目中遇到过一个问题：某同事移动了一个string后，又拿它的c_str()去拼接日志。结果日志里偶尔出现乱码。查了半天，发现是某个STL实现移动后保留了原字符串的内容，但另一个版本直接清空了。从那以后，我养成了一个习惯——移动后如果需要再用，直接赋个新值：

std::string s1 = "hello";
std::string s2 = std::move(s1);
s1 = "reset";  // 显式重置，心里踏实

28.3 自移动：自己移动自己？别闹

自移动就是 std::move(x) = std::move(x) 这种操作。你可能会说：「谁会这么写啊？」

还真有。最常见的是在泛型代码里，或者swap实现里不小心触发的。

template <typename T>
void my_swap(T& a, T& b) {
    T tmp = std::move(a);
    a = std::move(b);  // 如果 a 和 b 是同一个对象呢？
    b = std::move(tmp);
}

当 a 和 b 引用同一个对象时，第二行 a = std::move(b) 就是自移动。标准说自移动后的对象也处于有效但未指定状态。但有些类型的自移动实现是有问题的。

核心要点：自移动不是未定义行为，但结果不可预测。如果你的类型要支持移动语义，最好显式处理自移动情况。

我个人习惯在自定义类型的移动赋值运算符里加个自检：

MyClass& operator=(MyClass&& other) noexcept {
    if (this != &other) {  // 自移动保护
        // 正常的移动逻辑
        delete[] data_;
        data_ = other.data_;
        other.data_ = nullptr;
    }
    return *this;
}

别嫌啰嗦。我曾经在一个大型项目里追过一个bug，就是自移动导致的内存双释放。查了两天才定位到，最后发现是算法里有个迭代器指向了同一个容器元素。从那以后，我所有自定义类型的移动赋值都加了这个判断。

28.4 const对象移动：编译器不会拦你，但结果很坑

这个陷阱我印象特别深。你看这段代码：

const std::string s = "hello";
std::string t = std::move(s);  // 编译通过！

为什么会这样？因为 std::move(s) 返回的是 const std::string&&，而 const 右值引用会匹配到拷贝构造函数，而不是移动构造函数。所以这行代码实际上做了一次深拷贝，移动语义根本没生效。

你想想看，你满心欢喜地以为用了移动语义提升了性能，结果编译器默默给你做了个拷贝。性能没提升，代码还变复杂了。

⚠️ 警告：const对象永远无法被移动！std::move 只是把对象转成右值引用，但如果对象本身是const的，移动构造函数无法修改它，只能退回到拷贝。

我在代码评审里看到过这样的写法：

void process(std::vector<int>&& v) {
    // 处理 v
}

const std::vector<int> data = {1, 2, 3};
process(std::move(data));  // 你以为在移动？其实在拷贝！

嗯，这里要注意：如果你想让一个对象支持移动，就别给它加const。移动语义的本质是「偷资源」，const就是告诉编译器「别碰我」，这两者是矛盾的。

28.5 多次移动：移动一次就够了

移动后的对象处于有效但未指定状态。如果你连续移动同一个对象两次，第二次移动的行为完全取决于第一次移动后的状态。

std::string s = "hello";
std::string t1 = std::move(s);  // s 现在有效但未指定
std::string t2 = std::move(s);  // 从「未指定状态」的 s 中移动

这段代码能编译，能运行，但t2的值是什么？没人知道。可能是空字符串，可能是"hello"，也可能是"hel"——取决于STL实现。

💡 建议：移动后立即重置对象，或者干脆不再使用它。如果你需要多次使用某个对象的值，就别移动它，用拷贝。

我见过最离谱的bug是这样的：有人写了个函数，接收一个string右值引用，在里面移动了两次：

void consume(std::string&& s) {
    auto t1 = std::make_shared<std::string>(std::move(s));
    auto t2 = std::make_shared<std::string>(std::move(s));  // 从空指针？不，从已移动的string
}

结果t2拿到的数据时有时无。调试的时候发现，第一次移动后s被清空了，第二次移动自然拿到空字符串。但换成另一个STL版本，第一次移动后s没被清空，第二次移动反而拿到了完整数据。这种「时灵时不灵」的bug最难查。

28.6 知识体系总览

下面这张图把四个陷阱的关系梳理了一下，方便你对照记忆：

28.7 总结一下

这四个陷阱说白了就一句话：移动语义不是魔法，它只是把资源的所有权转移了。你没法从const对象里偷东西，也没法从空口袋里偷两次。

我个人的经验是：

移动后立刻重置，或者不再碰它
自定义类型一定要处理自移动
别对const对象用std::move，没用
一个对象只移动一次，别贪心

记住这些，移动语义用起来就顺手多了。

💡 避坑指南：我曾经在一个性能敏感模块里，因为没处理自移动，导致线上服务偶发崩溃。排查了整整两天，最后发现是某个算法在边界条件下让两个迭代器指向了同一个元素。从那以后，我所有移动赋值运算符都加了 if (this != &other)，不管标准库类型还是自定义类型。

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

📚 课程目录

28. 常见陷阱：移动后状态、自移动、const对象移动、多次移动

28.1 移动后状态：别假设它是空的

28.3 自移动：自己移动自己？别闹

28.4 const对象移动：编译器不会拦你，但结果很坑

28.5 多次移动：移动一次就够了

28.6 知识体系总览

28.7 总结一下