C++20 中的 std::variant：实现类型安全的多态方案

作者

std::variant 是 C++17 标准库新增的一个类型安全的联合体容器，用于存储若干种不同类型中的一种。它的核心目标是避免使用 void* 或者传统的继承/多态实现方式所带来的类型不安全问题，同时提供类似多态的灵活性。本文将从基本语法、常用操作、性能对比以及实践场景几个方面，系统阐述如何在 C++ 中使用 std::variant 进行类型安全的多态实现。

1. 基础语法与构造

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

using Variant = std::variant<int, double, std::string>;

Variant v1 = 42;            // 存储 int
Variant v2 = 3.14;          // 存储 double
Variant v3 = std::string{"hello"}; // 存储 string
  • 构造：可以直接用任何兼容的类型赋值给 std::variant。
  • 默认构造：std::variant 默认构造的是第一个类型的值，即 int()。
  • 无参构造：Variant v; 也会构造 int()。

2. 访问和查询

2.1 std::get

int i = std::get <int>(v1);          // 成功
double d = std::get <double>(v2);    // 成功
// std::get<std::string>(v1);      // 抛出 std::bad_variant_access

2.2 std::get_if

if (auto p = std::get_if <double>(&v2)) {
    std::cout << "double: " << *p << '\n';
}

2.3 std::holds_alternative

if (std::holds_alternative<std::string>(v3)) {
    std::cout << "it's a string\n";
}

3. 访问者模式（Visitor）

使用 std::visit 可以实现类似多态的行为，而无需显式的继承。 

struct Printer {
    void operator()(int i) const { std::cout << "int: " << i << '\n'; }
    void operator()(double d) const { std::cout << "double: " << d << '\n'; }
    void operator()(const std::string& s) const { std::cout << "string: " << s << '\n'; }
};

std::visit(Printer{}, v1);  // 输出 int: 42
std::visit(Printer{}, v2);  // 输出 double: 3.14
std::visit(Printer{}, v3);  // 输出 string: hello

注意：访问者函数必须覆盖所有可能的类型，否则编译错误。

4. 性能对比

  • 空间：std::variant 采用联合体实现，空间仅足以容纳最大的类型加上一个小型标识符（index）。
  • 时间：构造/赋值 O(1)；访问 std::get 需要检查 index 并可能抛异常，std::visit 需要根据 index 调用对应的访客，编译器可优化为 switch-case。
  • 与继承多态：继承多态需要 RTTI、虚表指针，空间多且有缓存失效；std::variant 则没有虚表，能更好地与缓存友好。

5. 实际应用场景

  1. 配置系统：配置文件中可能出现整数、浮点数、字符串等多种值，使用 std::variant 可统一存储。
  2. 网络协议：协议字段可能为多种类型，variant 能避免显式的联合体和手动类型检查。
  3. 脚本引擎：脚本语言的变量可以是多种基本类型，variant 可实现类型安全。
  4. 事件系统：不同事件携带不同参数，variant + visitor 可以实现事件回调。

6. 常见坑与建议

  • 异常安全：std::get 在类型不匹配时抛异常，若使用 std::get_if 可避免异常。
  • 移动语义：variant 对移动构造/移动赋值支持良好，但需注意内部类型的移动实现。
  • 多重嵌套：多层 variant 结构易读性差，建议使用结构体包装或自定义类型别名。
  • 与 std::any 的区别：std::any 允许任意类型但无编译时检查，variant 提供编译时类型列表，兼顾安全与灵活。

7. 代码示例：实现一个简单的“表达式求值器”

#include <variant>
#include <string>
#include <iostream>
#include <unordered_map>
#include <functional>

using Expr = std::variant<int, double, std::string>;

int main() {
    std::unordered_map<std::string, std::function<double(double,double)>> ops{
        {"+", [](double a,double b){return a+b;}},
        {"-", [](double a,double b){return a-b;}},
        {"*", [](double a,double b){return a*b;}},
        {"/", [](double a,double b){return a/b;}}
    };

    // 计算 3.14 + 2
    Expr left = 3.14;
    Expr right = 2;
    Expr op = "+";

    double result = std::visit([&](auto&& l, auto&& r, auto&& oper){
        using L = std::decay_t<decltype(l)>;
        using R = std::decay_t<decltype(r)>;
        using O = std::decay_t<decltype(oper)>;
        if constexpr (std::is_same_v<O, std::string>) {
            return ops[oper](static_cast <double>(l), static_cast<double>(r));
        } else {
            return static_cast <double>(l) + static_cast<double>(r);
        }
    }, left, right, op);

    std::cout << "Result: " << result << '\n';
}

通过 std::visit 结合 lambda，我们可以在单次访问中处理不同类型的 operand 和运算符，实现了类型安全且高效的表达式求值。

8. 结语

std::variant 在 C++17/20 之后成为实现类型安全多态的强大工具。它将传统的联合体、类型擦除、继承多态与访问者模式等特性进行统一，既保留了性能，又提升了代码可读性与可维护性。对于需要处理多种可能类型但又不想陷入 RTTI 或虚表的情景，variant 是非常值得一试的选择。希望本文能帮助你快速上手并在项目中发挥出它的威力。

发表评论