27、C++11/14/17对STL的增强：移动语义与右值引用、emplace系列函数、std::optional、std::variant、std::any

说实话，C++11 之后的 STL 才真正让我觉得「这语言活过来了」。早些年写 C++98，最头疼的就是那些临时对象的拷贝——明明一个临时变量用完就扔，还得硬生生复制一份，性能白白浪费。后来 C++11 引入了移动语义和右值引用，整个 STL 的容器实现都跟着翻了个身。今天咱们就聊聊这些改变，以及 C++17 带来的几个实用工具类。

27.1 移动语义与右值引用：STL 容器的性能革命

先说说右值引用。你想想看，一个函数返回的临时 std::vector，里面可能存了几万个元素。在 C++98 里，你要把它赋值给另一个 vector，就得老老实实把每个元素拷贝一遍。这合理吗？不合理。因为那个临时对象马上就要销毁了，为什么不直接把它的内部指针「偷」过来？

右值引用用 && 表示，它绑定的就是那些「即将销毁的临时对象」。配合移动构造函数和移动赋值运算符，STL 容器可以做到「零拷贝」转移资源。

// C++11 移动语义示例
std::vector<std::string> createBigVector() {
    std::vector<std::string> v(100000, "hello");
    return v;  // 触发移动构造，而非拷贝
}

int main() {
    std::vector<std::string> v1 = createBigVector();  // 移动，O(1)
    std::vector<std::string> v2 = std::move(v1);      // 显式移动，v1 变为空
    // v1 现在处于「有效但未指定」状态，通常为空
}

我个人习惯在需要「转让所有权」的场景下，明确使用 std::move。比如往容器里插入一个以后不再用的大对象，用 std::move 能省掉一次深拷贝。我在项目中遇到过这样一个坑：移动后的源对象虽然可以继续使用，但它的内容已经被掏空了。如果你还指望它保留原数据，那就等着出 bug 吧。

27.2 emplace 系列函数：直接在容器里构造

有了移动语义，性能已经提升不少了。但 emplace 系列函数更进一步——它让你直接在容器的内存位置上构造对象，连临时对象都不需要创建。

传统的 push_back 流程是这样的：先在外面构造一个临时对象，然后拷贝/移动到容器里，最后销毁临时对象。而 emplace_back 直接把构造参数转发到容器内部，在容器预留的内存上就地构造。

#include <vector>
#include <string>

struct Person {
    std::string name;
    int age;
    Person(std::string n, int a) : name(std::move(n)), age(a) {}
};

int main() {
    std::vector<Person> people;
    
    // 传统方式：先构造临时对象，再拷贝
    people.push_back(Person("Alice", 30));
    
    // emplace 方式：直接在容器内构造，省去临时对象
    people.emplace_back("Bob", 25);  // 参数直接传给 Person 构造函数
    
    // 对于 map，emplace 同样适用
    std::map<int, std::string> m;
    m.emplace(1, "one");  // 避免构造 pair<int, string> 临时对象
}

说白了，emplace 就是「把构造函数的参数直接扔给容器，让容器自己看着办」。对于像 std::map 这种节点式容器，emplace 还能避免不必要的节点分配和释放。我建议你在所有「插入新元素」的场景下，优先考虑 emplace 系列函数——emplace_back、emplace_front、emplace、emplace_hint。

27.3 std::optional：可能没有值

C++17 引入的 std::optional 解决了一个老问题：函数返回「可能有值，也可能没有」的情况。以前我们怎么处理？要么返回一个特殊值（比如 -1、nullptr），要么传一个输出参数，要么抛异常。这些方式都不够优雅。

#include <optional>
#include <string>

// 查找用户，可能找不到
std::optional<std::string> findUser(int id) {
    if (id == 42) {
        return "Alice";  // 有值
    }
    return std::nullopt;  // 无值
}

int main() {
    auto result = findUser(42);
    if (result) {  // 检查是否有值
        std::cout << "Found: " << *result << "\n";  // 解引用
    }
    
    // 或者用 value_or 提供默认值
    std::string name = findUser(100).value_or("Unknown");
    
    // 访问值，如果没有则抛 std::bad_optional_access 异常
    try {
        std::string val = findUser(999).value();
    } catch (const std::bad_optional_access& e) {
        std::cout << "No value: " << e.what() << "\n";
    }
}

我在项目中用 std::optional 最多的地方是解析配置文件——某个字段可能存在，也可能不存在。用 optional 比用空字符串或 -1 要清晰得多。不过要注意，std::optional 本身是有开销的：它需要额外存储一个 bool 标记来指示是否有值。对于 int 这种小类型，这个开销可能翻倍。

27.4 std::variant：类型安全的联合体

std::variant 是 C++17 对 C 风格 union 的现代化替代。union 的问题在于：你不知道当前存储的是哪个类型的值，而且不能存储非平凡类型（比如 std::string）。variant 解决了这两个问题。

#include <variant>
#include <string>
#include <iostream>

// 定义一个可以存储 int、double 或 string 的变体
using MyVariant = std::variant<int, double, std::string>;

int main() {
    MyVariant v = 42;                    // 存储 int
    std::cout << std::get<int>(v) << "\n";  // 用类型索引访问
    
    v = 3.14;                            // 现在存储 double
    std::cout << std::get<double>(v) << "\n";
    
    v = std::string("hello");            // 现在存储 string
    std::cout << std::get<std::string>(v) << "\n";
    
    // 安全访问：用 std::visit 配合 lambda
    std::visit([](auto&& arg) {
        std::cout << arg << "\n";
    }, v);
    
    // 或者用 get_if 检查
    if (auto* p = std::get_if<int>(&v)) {
        std::cout << "int: " << *p << "\n";
    } else if (auto* p = std::get_if<double>(&v)) {
        std::cout << "double: " << *p << "\n";
    }
}

我个人觉得 std::variant 最妙的地方是 std::visit——你可以写一个泛型 lambda，一次性处理所有可能的类型。这在实现状态机或者解析器的时候特别有用。不过要注意，variant 的大小等于所有可能类型中最大的那个，再加上一些管理开销。如果你存储的类型大小差异很大，可以考虑用 std::unique_ptr 包装大对象。

27.5 std::any：真正的类型擦除

std::any 比 variant 更进一步——它可以存储任意类型的值，只要该类型是可拷贝的。它内部使用了类型擦除技术，类似于 void* 但更安全。

#include <any>
#include <string>
#include <vector>

int main() {
    std::any a = 42;                    // 存储 int
    a = std::string("hello");           // 现在存储 string
    a = std::vector<int>{1, 2, 3};      // 现在存储 vector
    
    // 安全访问：用 any_cast
    try {
        int val = std::any_cast<int>(a);  // 如果类型不匹配，抛 bad_any_cast
    } catch (const std::bad_any_cast& e) {
        std::cout << "Type mismatch: " << e.what() << "\n";
    }
    
    // 用 any_cast 指针形式检查
    if (auto* p = std::any_cast<std::string>(&a)) {
        std::cout << "It's a string: " << *p << "\n";
    } else if (auto* p = std::any_cast<std::vector<int>>(&a)) {
        std::cout << "It's a vector of size " << p->size() << "\n";
    }
    
    // 检查类型
    if (a.type() == typeid(std::vector<int>)) {
        std::cout << "Yes, it's a vector<int>\n";
    }
}

std::any 的开销比 variant 大，因为它需要动态分配内存（对于小对象可能有小对象优化，但标准不保证）。我一般只在「实在不知道会存什么类型」的场景下用它，比如插件系统、脚本引擎的变量绑定。如果你能提前知道所有可能的类型，用 variant 更高效。

27.6 知识体系总览

下面这张图总结了 C++11/14/17 对 STL 的这些增强，以及它们各自解决的核心问题：

从这张图可以看得很清楚：C++11 主要解决的是「性能」问题——怎么让临时对象的传递更高效，怎么在容器里构造对象更省事。而 C++17 的这三个工具类，解决的是「表达能力」问题——怎么让代码更清晰地表达「可能有值」「可能是几种类型之一」「可以是任意类型」这些语义。

在实际项目中，我建议你按这个优先级来选：能用 std::optional 就别用 std::variant，能用 std::variant 就别用 std::any。类型越具体，编译器能做的优化就越多，代码的可读性也越好。反过来，如果你发现自己在用 std::any 做类型转换，那八成是设计上出了问题——该用虚函数或者模板的地方，别偷懒。

好了，这一章的内容就到这里。移动语义和 emplace 系列函数是 C++11 给 STL 带来的「性能引擎」，而 optional、variant、any 是 C++17 给 STL 装上的「表达力翅膀」。用好它们，你的 C++ 代码会变得更安全、更高效、更易读。

---

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