掌握C++17中的std::variant：类型安全的多态实现

作者

在现代 C++ 开发中，std::variant 是一种强类型安全的“联合”容器，它可以存储多种可能类型中的任意一种。相较于传统的 union，std::variant 在编译时就能保证类型正确性，并提供了更丰富的成员函数和异常安全保证。本文将从基本使用、访问方式、递归结构以及性能优化等角度，深入剖析 std::variant 的实战技巧。

1. 基础概念与声明

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

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

int main() {
    Response r1 = 42;                  // 存储 int
    Response r2 = 3.14;                // 存储 double
    Response r3 = std::string{"Hello"}; // 存储 std::string

    std::visit([](auto&& val){ std::cout << val << '\n'; }, r1, r2, r3);
}
  • std::variant 的模板参数是类型列表，编译器会生成一个可以持有其中任意一种类型的容器。
  • 默认构造函数会初始化为第一个类型的默认值；使用 std::variant<Ts...>() 可以指定索引。

2. 访问与匹配

2.1 std::get 与 std::get_if

int i = std::get <int>(r1);               // 若类型不匹配则抛出 bad_variant_access
if (auto p = std::get_if <double>(&r2))   // 返回指针，若不匹配则为 nullptr
    std::cout << *p << '\n';

2.2 std::visit

std::visit 是最常用的访问方式，它接受一个可调用对象（通常是 lambda 或结构体），并将 variant 的当前值作为参数传递。示例：

std::visit([](auto&& val){
    std::cout << typeid(val).name() << " -> " << val << '\n';
}, r3);

如果想要针对不同类型执行不同逻辑，可以利用多态 lambda：

std::visit(overloaded{
    [](int x){ std::cout << "int: " << x; },
    [](double d){ std::cout << "double: " << d; },
    [](const std::string& s){ std::cout << "string: " << s; }
}, r2);

overloaded 是一个简便的工具：

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

3. 递归与树结构

std::variant 能够递归地包含自身，从而构造出树形数据结构。以下示例演示了一个简单的算术表达式树：

struct Expr;
using ExprPtr = std::shared_ptr <Expr>;

struct Expr : std::variant<
    int,
    double,
    std::string,          // 变量名
    std::tuple<std::string, ExprPtr, ExprPtr> // 运算符 + 两个子表达式
> {
    using base = std::variant<int, double, std::string, std::tuple<std::string, ExprPtr, ExprPtr>>;
    using base::base;
};

ExprPtr make_expr(const std::string& op, ExprPtr left, ExprPtr right) {
    return std::make_shared <Expr>(std::make_tuple(op, left, right));
}

遍历与求值：

double eval(const ExprPtr& node) {
    return std::visit(overloaded{
        [](int x){ return static_cast <double>(x); },
        [](double d){ return d; },
        [](const std::string& var){ /* 这里可以从环境表获取值 */ return 0.0; },
        [](const std::tuple<std::string, ExprPtr, ExprPtr>& tup){
            const auto& [op, l, r] = tup;
            double a = eval(l), b = eval(r);
            if (op == "+") return a + b;
            if (op == "-") return a - b;
            if (op == "*") return a * b;
            if (op == "/") return a / b;
            throw std::runtime_error("unknown op");
        }
    }, *node);
}

4. 性能考量

  1. 大小与对齐
    std::variant 的大小等于最大成员类型的大小加上索引存储。若类型列表中有极大对象，建议使用指针或 std::shared_ptr 以减少占用。

  2. 移动语义
    std::variant 采用标准移动语义，移动构造/赋值会把当前值移动到新对象，避免不必要的拷贝。

  3. 异常安全
    std::variant 的构造与赋值保证强异常安全，若构造某种类型抛异常，则原状态保持不变。

  4. 访问开销
    std::visit 在内部使用 switch 或 if 来决定调用哪个函数，开销与 if constexpr 相当。若访问频繁且类型固定，可考虑 `std::get

    ` 直接访问。

5. 与 std::optional 的配合

在需要“值或空”且“值可以是多种类型”的场景中，常将 std::optional 与 std::variant 组合使用：

using OptResponse = std::optional <Response>;

OptResponse fetch_data() {
    // 可能返回空，或者返回不同类型的结果
}

此时 has_value() 可以判断是否成功获取数据，内部值则用 std::visit 处理。

6. 常见错误与调试技巧

  • 误用 std::get
    `std::get

    ` 在类型不匹配时抛出异常，容易导致程序崩溃。建议先使用 `std::holds_alternative` 或 `std::get_if`。

  • 递归 variant 与 shared_ptr
    直接在 variant 中放 std::variant 会导致无限递归，必须通过指针包装。

  • 编译器错误信息
    std::visit 报告“no matching function for call to ‘operator()’” 时，通常是因为 lambda 不能匹配所有可能类型。使用 overloaded 或 std::variant 的 std::visit 需要确保覆盖所有类型。

7. 进阶：自定义 std::variant 行为

std::variant 的模板参数还可以是自定义类型，只要满足以下条件：

  1. 必须是拷贝可移动类型。
  2. 必须实现 `std::is_copy_constructible_v ` 与 `std::is_move_constructible_v`。

例如，将 std::variant 用作“错误码 + 结果”：

struct Result {
    int code;
    std::variant<int, std::string> data;
};

Result divide(int a, int b) {
    if (b == 0) return {1, std::string("division by zero")};
    return {0, a / b};
}

8. 小结

  • std::variant 提供了比 union 更安全、更易用的多态容器。
  • 通过 std::visit 与多态 lambda 可以实现灵活的分支逻辑。
  • 在递归结构与树形数据中，使用指针包装可避免无限递归。
  • 性能方面需要注意对象大小、移动语义与异常安全。

掌握 std::variant 的用法后，你就能在需要类型安全的多态场景中，写出更简洁、更健壮的 C++ 代码。祝编码愉快！

发表评论