**C++20 中 std::variant 的高效使用技巧与常见陷阱**

作者

在 C++20 标准正式发布后，std::variant 成为统一类型安全的多态容器。它可以在编译期静态地描述一组可能的类型，并在运行时保持其中之一。虽然使用起来比传统的 std::any 更安全，但在性能、语义和可维护性方面仍有若干细节需要注意。本文将从以下几方面展开讨论：

  1. 构造与销毁的开销
  2. 访问方式的选择
  3. 自定义类型的兼容性
  4. 与 std::visit 的高效组合
  5. 错误处理与异常安全

1. 构造与销毁的开销

std::variant 内部维护一个联合（union）以及一个索引值，用来标记当前存储的是哪种类型。所有成员类型都必须满足 MoveConstructible 和 MoveAssignable，而对不需要的类型可以仅提供 CopyConstructible 或 DefaultConstructible。

1.1 预分配空间

由于 std::variant 的大小由其最大成员决定，若使用 variant 存放大对象（如 std::string、std::vector），会在内部对齐时产生额外的内存填充。若已知某个字段不经常使用，考虑使用 std::optional 包装后再放入 variant，可以减少整体大小。

using SmallVariant = std::variant<
    int,
    double,
    std::string,         // 可能是大对象
    std::optional<std::vector<int>> // 仅在需要时存在
>;

1.2 触发构造/析构

在构造或切换 variant 时，仅 对当前类型进行构造，且仅在更改索引时析构旧值。若在切换时涉及到非平凡类型，可能触发深拷贝。可通过显式使用 std::in_place_type_t 来避免不必要的复制。

SmallVariant v(0);                 // 直接构造 int
v.emplace<std::string>("hello");   // 直接构造 string，旧 int 自动析构

2. 访问方式的选择

2.1 std::get 与 std::get_if

  • `std::get (v)`：如果当前类型不是 `T`，会抛出 `std::bad_variant_access`。适合在你已知索引的情况下使用，且不想处理异常。
  • `std::get_if (&v)`：返回指向 `T` 的指针，若类型不匹配返回 `nullptr`。适用于条件检查而不抛异常。
if (auto p = std::get_if<std::string>(&v)) {
    std::cout << *p;
}

2.2 std::visit

std::visit 可以同时访问不同类型的值，避免多次 std::get_if。如果访问逻辑复杂，建议使用 std::visit 并通过 lambda 或函数对象实现。

std::visit([](auto&& arg){
    using T = std::decay_t<decltype(arg)>;
    if constexpr (std::is_same_v<T, int>)
        std::cout << "int: " << arg << '\n';
    else if constexpr (std::is_same_v<T, std::string>)
        std::cout << "string: " << arg << '\n';
}, v);

3. 自定义类型的兼容性

3.1 类型可比较

若你计划使用 std::variant 做为 std::map 的键或 std::set 的元素，需要提供 operator< 或 std::compare_three_way。C++20 通过 std::variant 的 operator<=> 自动实现，但前提是所有成员类型也都有三向比较。

struct MyStruct {
    int a;
    double b;
    constexpr auto operator<=>(const MyStruct&) const = default;
};

using V = std::variant<int, MyStruct>;
std::set <V> myset;   // 正确工作

3.2 noexcept 与异常安全

若自定义类型的构造或析构可能抛异常，使用 std::variant 时要格外小心。尤其在 std::visit 的访问中，若 lambda 抛异常，variant 仍保持旧值，异常安全性由自定义类型决定。

4. 与 std::visit 的高效组合

4.1 避免多次复制

如果访问逻辑需要多次读取同一成员，建议一次性捕获引用或移动：

auto handle = std::visit([](auto&& arg) -> std::any {
    return std::any{std::forward<decltype(arg)>(arg)};
}, v);   // 把值包进 std::any 仅一次移动

4.2 利用 overloaded

C++17 起，常用技巧是 overloaded 结构体，用于把多种 lambda 合并为一个可调用对象：

template<class... Ts> struct overloaded : Ts... { using Ts::operator()...; };
template<class... Ts> overloaded(Ts...) -> overloaded<Ts...>;

std::visit(overloaded{
    [](int i){ std::cout << "int: " << i; },
    [](const std::string& s){ std::cout << "str: " << s; },
    [](const std::vector <int>& v){ std::cout << "vec size: " << v.size(); }
}, v);

5. 错误处理与异常安全

5.1 std::visit 与 noexcept

若访问 lambda 可能抛异常，最好在访问前做好异常处理。C++23 提供了 std::variant::visit 的 noexcept 变体，但在 C++20 中仍需手动检查。

5.2 std::variant 的赋值安全

赋值操作符会先对右侧进行构造（或拷贝），随后再替换左侧当前值。如果左侧和右侧类型相同，直接移动/复制即可；若不同，旧值会析构，然后构造新值。此过程中如果构造失败，左侧保持旧值，满足异常安全。

结语

std::variant 是 C++20 里极具潜力的多态容器，但若不熟悉其内部细节，常常会在性能或错误处理上产生隐患。通过合理的构造方式、适当的访问方法、兼容自定义类型以及高效的 std::visit 组合，能够充分发挥 std::variant 的优势，为程序带来更安全、可维护、性能可控的代码结构。希望本文能帮助你在日常编码中更好地运用 std::variant。

发表评论