**题目：使用 C++17 的 std::variant 与 std::visit 实现类型安全的多态**

作者

在 C++17 之前，处理多种可能的数据类型往往依赖于传统的多态（继承+虚函数）或手写的联合体和标记枚举。C++17 引入了 std::variant，它是一种类型安全的联合体，可以存放多种指定类型中的任意一种，并通过 std::visit 进行访问。本文将深入探讨 std::variant 的核心概念、典型用法、性能考量以及常见陷阱，并给出一段完整的示例代码，帮助你快速上手。

1. 为什么需要 std::variant？

  1. 类型安全
    与 union 不同，std::variant 会在编译时保证只能存放指定类型，且访问时必须先确定当前实际类型，避免了未定义行为。

  2. 无需继承
    传统多态需要定义基类和派生类，使用时还要管理指针或引用。std::variant 直接在栈上保存数据，消除指针相关的开销和生命周期管理。

  3. 与 std::visit 搭配
    std::visit 可以像 std::visit([](auto&& v){...}) 这样的语法，使访问变得直观且可扩展。

2. 基本语法

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

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

int main() {
    MyVariant v = 42;          // 存放 int
    v = std::string("hello");  // 再存放 std::string

    std::visit([](auto&& val){ std::cout << val << std::endl; }, v);
}
  • variant<Ts...>：模板参数列表定义了允许的类型集合。
  • std::visit(visitor, variant)：visitor 可以是函数对象、lambda、或者 std::function。
  • `get ()` / `get_if()`：直接获取当前类型，若不匹配则抛出 `std::bad_variant_access` 或返回 `nullptr`。

3. 典型使用场景

3.1 表示 JSON 字段

using JsonValue = std::variant<
    std::nullptr_t, bool, int64_t, double,
    std::string, std::vector <JsonValue>, std::map<std::string, JsonValue>
>;

3.2 结果包装

template<typename T, typename E>
using Result = std::variant<T, E>;

与传统 std::pair<T, E> 或自定义 Either 结构类似，但更安全。

3.3 事件系统

struct ClickEvent { int x, y; };
struct KeyEvent { int keycode; };
using Event = std::variant<ClickEvent, KeyEvent>;

4. 访问技巧

4.1 单一类型访问

int getInt(const MyVariant& v) {
    if (auto p = std::get_if <int>(&v))
        return *p;
    throw std::runtime_error("Variant does not hold int");
}

4.2 访问所有可能类型

std::visit(overloaded{
    [](int i)   { std::cout << "int: " << i << '\n'; },
    [](double d){ std::cout << "double: " << d << '\n'; },
    [](const std::string& s){ std::cout << "string: " << s << '\n'; }
}, v);

overloaded 是一个辅助模板，用于将多个 lambda 合并成一个可调用对象。

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

4.3 访问并返回值

auto getLength(const MyVariant& v) {
    return std::visit([](auto&& val) -> size_t {
        using T = std::decay_t<decltype(val)>;
        if constexpr (std::is_same_v<T, std::string>)
            return val.size();
        else
            return 0;
    }, v);
}

利用 if constexpr 可以在编译期根据类型做分支。

5. 性能与实现细节

  • 内部存储：std::variant 内部维护一个 char buffer[max_size]（对齐），以及一个 index_type 表示当前类型。max_size 是所有类型中大小最大的一个，max_align 是最大对齐。
  • 移动/拷贝：默认拷贝/移动构造/赋值会调用对应类型的拷贝/移动构造函数。若所有类型都满足 MoveConstructible，则 std::variant 也满足。
  • 大小：对于常见的 int, double, std::string 组合，variant 的大小大约是 sizeof(void*) * 2（64 位平台），因为 std::string 采用小字符串优化（SSO）。
  • 分支预测：std::visit 通过 index 对应的 switch 或 constexpr 递归实现，编译器通常能很好地优化。
  • 可变形参数：如果需要在运行时动态决定类型，可以考虑 std::any 或 boost::variant，但 std::variant 受限于模板参数列表是编译时固定的。

6. 常见错误与陷阱

  1. **忘记包含 `

    `** 这是最常见的编译错误，尤其在使用旧编译器时。

  2. 错误的类型顺序
    std::variant 的构造/赋值优先匹配第一个相同类型。如果有同名类、别名等，可能导致意外匹配。

  3. 未处理的类型
    std::visit 需要覆盖所有可能的类型，否则在运行时抛 std::bad_variant_access。使用 overloaded 时，可通过 static_assert 确保覆盖完整。

  4. 复制构造时不匹配
    当 variant 的 index 与目标 variant 不同，拷贝/移动构造会失败。请确保目标 variant 的类型集合与源相同。

  5. 递归 variant 的限制
    variant 不能直接包含自身，除非使用 std::shared_ptr 或 std::unique_ptr 进行包装。

7. 完整示例：一个简易的数学表达式求值器

#include <variant>
#include <vector>
#include <string>
#include <iostream>
#include <stdexcept>
#include <functional>

// 1. 定义表达式节点
struct Number {
    double value;
};

struct BinaryOp {
    char op; // '+', '-', '*', '/'
    std::shared_ptr <void> left;
    std::shared_ptr <void> right;
};

using ExprNode = std::variant<Number, BinaryOp>;

using Expr = std::shared_ptr <ExprNode>;

// 2. 构造表达式 (3 + 4) * 5
Expr makeSampleExpr() {
    auto left = std::make_shared <ExprNode>(BinaryOp{
        '+',
        std::make_shared <ExprNode>(Number{3}),
        std::make_shared <ExprNode>(Number{4})
    });
    return std::make_shared <ExprNode>(BinaryOp{
        '*',
        left,
        std::make_shared <ExprNode>(Number{5})
    });
}

// 3. 递归求值
double eval(const Expr& expr) {
    return std::visit(overloaded{
        [](const Number& n) { return n.value; },
        [](const BinaryOp& op) {
            double l = eval(std::static_pointer_cast <ExprNode>(op.left));
            double r = eval(std::static_pointer_cast <ExprNode>(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("未知运算符");
            }
        }
    }, *expr);
}

int main() {
    Expr expr = makeSampleExpr();
    std::cout << "Result: " << eval(expr) << std::endl; // 输出 35
}

说明

  • ExprNode 是 variant，可以存放 Number 或 BinaryOp。
  • BinaryOp 的 left、right 是 `shared_ptr `，为了示例简化了类型推断。
  • eval 通过 std::visit 对每种节点类型做不同处理，实现递归求值。

8. 结语

std::variant 与 std::visit 的组合为 C++ 提供了强大且类型安全的多态方案。无论是 JSON 解析、事件系统、结果包装，还是简易脚本引擎，都能轻松实现。掌握它的核心概念和常用技巧，能显著提升代码的可读性与安全性。希望本文能帮助你在实际项目中快速运用 std::variant，让代码更简洁、错误更少。祝编码愉快！

发表评论