如何在C++中使用std::variant实现类型安全的多态

作者

在 C++17 之前，开发者常用 union、void* 或者 boost::variant 来实现多态数据结构。然而，这些方案往往缺乏类型安全、需要手动管理资源，且在现代 C++ 中已被更优雅的标准库工具所取代。std::variant 是 C++17 标准中提供的类型安全的多重类型容器，它可以让你在不使用继承和虚函数的情况下，实现类似多态的功能。下面我们将深入探讨 std::variant 的核心概念、使用方法以及典型应用场景，并给出完整的代码示例。

1. 什么是 std::variant？

std::variant 是一个模板类，接受一个或多个类型参数，表示它可以持有这些类型中的任意一种。它内部使用一个联合（union）来存储数据，并通过索引（index）记录当前存储的是哪一种类型。与普通 union 不同的是，std::variant 会自动调用构造、析构和拷贝/移动操作，保证资源安全。

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

std::variant<int, std::string> data;
data = 42;           // 存储 int
data = "hello";      // 存储 string

2. 访问和操作

2.1 std::get 与 std::get_if

  • `std::get (variant)`：直接获取存储的 `T` 类型值，如果存储的不是 `T`，则抛出 `std::bad_variant_access`。
  • `std::get_if (&variant)`：返回指向存储的 `T` 值的指针，如果不是 `T`，返回 `nullptr`。
try {
    int i = std::get <int>(data);
    std::cout << "int: " << i << '\n';
} catch (const std::bad_variant_access&) {
    std::cout << "Not an int\n";
}

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

2.2 std::visit

最强大的访问方式是 std::visit，它允许你对 variant 中存储的值执行访问者模式（Visitor）。访问者可以是结构体、类、Lambda 表达式等。

std::visit([](auto&& val){
    std::cout << "value: " << val << '\n';
}, data);

std::visit 的参数可以是一个多态调用对象，该对象提供了针对每种类型的重载。

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

std::visit(Printer{}, data);

3. 与传统继承/虚函数的比较

方案 优点 缺点
继承+虚函数 直观、易读 需要显式定义基类、可能导致多重继承冲突
boost::variant 早期可用 依赖第三方库，资源管理手动
std::variant 标准、类型安全、RAII 对于大规模状态机不如继承灵活

在很多情况下，尤其是仅需要持有有限数量的类型时，std::variant 更为简洁安全。

4. 典型应用场景

  1. 解析器或解释器
    表达式树中不同节点类型（整数、浮点、变量、运算符）可用 std::variant 表示。

  2. 事件系统
    事件可能携带不同类型的数据，使用 std::variant 可避免使用 void* 或宏。

  3. 序列化/反序列化
    JSON、XML 等结构中字段可能是多种类型，std::variant 能保持类型安全。

  4. 状态机
    每个状态对应不同的数据结构，使用 std::variant 表示当前状态。

5. 示例：简易表达式求值器

下面给出一个最小化的例子，演示如何使用 std::variant 来构造一个简单的算术表达式求值器。

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

// 先声明结构体
struct BinaryOp;

// 定义表达式类型
using Expr = std::variant<
    int,                            // 直接整数
    std::shared_ptr <BinaryOp>       // 二元操作符
>;

// 二元操作符
struct BinaryOp {
    char op;      // '+', '-', '*', '/'
    Expr left;
    Expr right;
};

// 计算函数
int eval(const Expr& expr) {
    return std::visit([](auto&& val) -> int {
        using T = std::decay_t<decltype(val)>;
        if constexpr (std::is_same_v<T, int>) {
            return val;
        } else if constexpr (std::is_same_v<T, std::shared_ptr<BinaryOp>>) {
            const BinaryOp* op = val.get();
            int l = eval(op->left);
            int r = eval(op->right);
            switch (op->op) {
                case '+': return l + r;
                case '-': return l - r;
                case '*': return l * r;
                case '/': return l / r;
                default:  throw std::runtime_error("unknown operator");
            }
        }
    }, expr);
}

// 简单构造器
Expr make_binary(char op, Expr lhs, Expr rhs) {
    return std::make_shared <BinaryOp>(BinaryOp{op, lhs, rhs});
}

int main() {
    // 表达式: (3 + 4) * 5
    Expr expr = make_binary('*',
                 make_binary('+', 3, 4),
                 5);

    std::cout << "Result: " << eval(expr) << '\n';
}

运行结果：

Result: 35

上述代码展示了如何使用 std::variant 结合递归结构来表示和计算表达式树。关键点是：

  • 通过 std::variant 让 Expr 既能容纳整数，也能容纳二元操作符。
  • std::visit 负责根据当前存储的类型执行相应逻辑，保证了类型安全且无需显式判断。

6. 进阶使用

6.1 std::monostate

如果你需要一个空值占位符，可以使用 std::monostate。它是一个空结构体，常用来表示 variant 的默认状态。

std::variant<std::monostate, int, std::string> opt;

6.2 std::holds_alternative

在访问之前判断存储类型，避免异常：

if (std::holds_alternative <int>(data)) {
    int val = std::get <int>(data);
}

6.3 递归 variant

对于递归数据结构（如树），需要使用 std::shared_ptr 或 std::unique_ptr 包装 variant，否则会导致无限递归类型大小。

using Node = std::variant<int, std::shared_ptr<Node>>;

7. 性能考虑

  • std::variant 的大小等于最大成员类型大小加上一个 unsigned 或 uint8_t（取决于实现）。因此，使用大对象时请注意内存占用。
  • std::visit 的开销在编译期已被模板展开，运行时几乎无额外成本。

8. 小结

std::variant 为 C++ 开发者提供了一种既类型安全又简洁的方式来处理多种类型的数据。它在很多场景下可以替代传统继承/虚函数或第三方库，使代码更易读、易维护。掌握 std::variant 的核心概念（std::get、std::visit、std::holds_alternative）以及如何在递归结构中使用它，是提升现代 C++ 编程水平的重要一步。

祝你在 C++ 之路上愉快编码！

发表评论