22、移动语义与 STL 算法：移动迭代器、移动算法、移动与排序

这一章我们来聊聊 STL 算法和移动语义的「联姻」。说实话，我早年写 C++ 的时候，总觉得移动语义是容器和智能指针的事，跟算法关系不大。直到有一次我在项目中处理一个超大的 vector<string>，排序时内存疯狂拷贝，性能惨不忍睹。嗯，从那以后我才真正意识到——移动语义和算法结合，才是现代 C++ 性能优化的杀手锏。

移动迭代器：把拷贝变成移动的「转换器」

先问一个问题：std::copy 会把元素拷贝过去，那有没有办法让它「移动」过去？

答案是 std::move_iterator。它本质上是一个迭代器适配器，包装任意迭代器后，解引用返回的是右值引用。说白了，它把 operator* 的返回值从 T& 变成了 T&&。

#include <iostream>
#include <vector>
#include <algorithm>
#include <iterator>

int main() {
    std::vector<std::string> src = {"hello", "world", "move", "iterator"};
    std::vector<std::string> dst(src.size());

    // 使用 move_iterator 把元素从 src 移动到 dst
    std::copy(std::make_move_iterator(src.begin()),
              std::make_move_iterator(src.end()),
              dst.begin());

    // 此时 src 中的元素已被移走，处于「合法但未指定」状态
    for (const auto& s : src) {
        std::cout < "[" << s << "] ";  // 可能输出空字符串
    }
    std::cout << std::endl;

    for (const auto& s : dst) {
        std::cout << s << " ";  // 正常输出
    }
    return 0;
}

我个人习惯在需要批量转移资源时用这个。比如从临时容器中提取数据到永久存储，用 move_iterator 能省掉大量深拷贝。不过要注意——源对象被移走后，不要再依赖它的内容。

std::move 算法：不只是 std::move 函数

很多人把 std::move 和 std::move_iterator 搞混。其实 std::move 是一个算法，定义在 <algorithm> 中，作用是把一个范围内的元素移动到另一个范围。

#include <iostream>
#include <vector>
#include <algorithm>

int main() {
    std::vector<std::string> src = {"alpha", "beta", "gamma"};
    std::vector<std::string> dst(src.size());

    // std::move 算法：将 src 中的元素移动到 dst
    std::move(src.begin(), src.end(), dst.begin());

    // src 中的元素已被移走
    for (const auto& s : src) {
        std::cout << "[" << s << "] ";  // 大概率输出空字符串
    }
    std::cout << std::endl;

    return 0;
}

你想想看，std::move 算法和 std::copy 算法在接口上几乎一模一样，区别就在于内部用的是移动赋值而不是拷贝赋值。对于像 std::string、std::vector 这样的类型，移动赋值只是交换指针，性能差距巨大。

移动与排序算法：性能提升的关键

排序算法（如 std::sort）内部会大量交换元素。在 C++11 之前，交换两个 vector<string> 意味着三次深拷贝。有了移动语义，std::swap 被特化为移动操作，性能直接起飞。

#include <iostream>
#include <vector>
#include <algorithm>
#include <string>

struct HeavyObject {
    std::vector<int> data;
    std::string name;

    HeavyObject(std::string n, size_t size) : name(std::move(n)), data(size) {}
    
    // 移动构造函数
    HeavyObject(HeavyObject&& other) noexcept
        : data(std::move(other.data)), name(std::move(other.name)) {}
    
    // 移动赋值运算符
    HeavyObject& operator=(HeavyObject&& other) noexcept {
        if (this != &other) {
            data = std::move(other.data);
            name = std::move(other.name);
        }
        return *this;
    }
};

int main() {
    std::vector<HeavyObject> objs;
    objs.emplace_back("object1", 1000000);
    objs.emplace_back("object2", 500000);
    objs.emplace_back("object3", 2000000);

    // 排序时内部交换会使用移动语义
    std::sort(objs.begin(), objs.end(),
              [](const HeavyObject& a, const HeavyObject& b) {
                  return a.name < b.name;
              });

    return 0;
}

为什么排序性能提升这么大？因为 std::sort 内部用的是 std::swap，而 C++11 后的 std::swap 会调用移动构造函数和移动赋值运算符。对于 HeavyObject 这种类型，移动只是交换几个指针，拷贝则要复制几百万个 int。

知识体系总览

下面这张图帮你理清本章的核心脉络：

实战中的注意事项

我在项目中总结了几条经验，分享给你：

1. 移动后源对象的状态：被移走的对象处于「合法但未指定」状态。你可以重新赋值，但不要假设它的值。我曾经踩过这个坑——移走一个 vector 后，以为它还是空的，结果里面还有残留数据。
2. noexcept 是关键：STL 算法在排序时，如果移动操作可能抛异常，会退化为拷贝。所以移动构造函数和移动赋值运算符一定要标记 noexcept。
3. 不要滥用移动迭代器：如果你后续还要用源数据，就别用 move_iterator。它适合「一次性转移所有权」的场景。
4. 性能测试要落地：我建议你在自己的项目里写个 benchmark，对比 std::copy 和 std::move 算法在 vector<string> 上的性能差异。数据会说话。

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