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

2026-01-18 作者 stdcpp

在现代 C++ 中，std::variant 是一种强类型的联合体，能够在运行时安全地存放多种不同类型的值。相比传统的 void* 或者继承实现多态，std::variant 通过编译期类型检查、访客模式以及内置的类型安全访问，大大降低了错误率。本文将从基本使用、访问方式、性能对比以及实际案例几个角度，详细剖析 std::variant 的使用与优势。

1. 基本使用

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

int main() {
    std::variant<int, double, std::string> v;  // 默认构造为第一个类型，即 int

    v = 42;              // 赋值 int
    v = 3.1415;          // 赋值 double
    v = std::string("hello");

    // 打印当前值
    std::visit([](auto&& arg){ std::cout << arg << std::endl; }, v);
}

std::variant 的模板参数列表指定了可存放的类型集合。
默认值是第一个类型，如果需要默认空态，可使用 std::monostate。

2. 类型安全访问

2.1 `std::get`

try {
    int i = std::get <int>(v);    // 若 v 当前不是 int，则抛出 std::bad_variant_access
} catch (const std::bad_variant_access&) {
    std::cerr << "Variant holds different type.\n";
}

2.2 `std::get_if`

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

get_if 返回指向对应类型的指针，若类型不匹配则返回 nullptr，适用于可选访问。

2.3 `std::visit`

std::visit 接收一个可调用对象（函数对象、lambda、std::variant 的 visit 结构）和一个 std::variant，在内部自动解包当前持有的类型并调用相应重载。

std::visit([](auto&& arg){
    std::cout << "variant holds: " << arg << '\n';
}, v);

3. 组合使用

多级嵌套、递归结构可以通过 std::variant 与 std::recursive_wrapper 或 std::shared_ptr 搭配实现。

struct Expr;
using ExprPtr = std::shared_ptr <Expr>;
using ExprVariant = std::variant<
    double,
    std::string,
    std::pair<ExprPtr, ExprPtr>  // 代表二元运算符
>;

struct Expr : ExprVariant {
    using ExprVariant::ExprVariant;  // 继承构造
};

4. 性能与对比

方案	代码复杂度	运行时检查	运行时开销
基于继承的多态	低	运行时通过虚表	低
基于 std::variant	中	编译期类型信息 + 运行时类型码	取决于访问方式；`std::visit` 在多数实现中采用分支预测、跳转表，性能可与继承相当
基于 std::any	低	运行时类型检查	需要类型擦除，开销较大

在大多数实际项目中，std::variant 与传统继承相比较，代码更简洁、类型安全更高；在性能敏感场景下，std::visit 的实现已足够高效。

5. 实际案例：事件系统

enum class EventType { Click, KeyPress, WindowResize };

struct ClickEvent { int x, y; };
struct KeyPressEvent { char key; };
struct WindowResizeEvent { int width, height; };

using EventData = std::variant<ClickEvent, KeyPressEvent, WindowResizeEvent>;

struct Event {
    EventType type;
    EventData data;
};

void handleEvent(const Event& e) {
    std::visit([&](auto&& payload){
        using T = std::decay_t<decltype(payload)>;
        if constexpr (std::is_same_v<T, ClickEvent>)
            std::cout << "Click at (" << payload.x << ", " << payload.y << ")\n";
        else if constexpr (std::is_same_v<T, KeyPressEvent>)
            std::cout << "Key pressed: " << payload.key << '\n';
        else if constexpr (std::is_same_v<T, WindowResizeEvent>)
            std::cout << "Resize to " << payload.width << "x" << payload.height << '\n';
    }, e.data);
}

通过 EventType 与 EventData 的组合，既保留了枚举的可读性，又利用 variant 实现了类型安全的数据携带。
事件处理器不需要手动检查类型，std::visit 自动匹配。

6. 小结

std::variant 提供了一个类型安全的多态实现方案，避免了传统虚函数表的隐式调用与潜在的内存错误。
访问方式多样：get、get_if、visit，可以根据场景选择合适的方式。
在需要组合、递归结构时，可以通过 std::shared_ptr 或 std::recursive_wrapper 简化实现。
性能与传统多态相当，甚至在某些编译器实现中可更快（因编译器优化）。

若你正在寻找一种既安全又灵活的“类型联合”方案，std::variant 无疑是值得深入学习与应用的现代 C++ 特性。

发表评论取消回复