std::variant ​

什么是 std::variant ​

std::variant<Types...> 是 C++17 在 <variant> 头文件中引入的类型安全联合体(discriminated union / tagged union)。它可以在任意时刻持有其类型列表中的某一个类型的值,并且始终知道当前持有的是哪个类型。

传统 C++ 的 union 存在严重的类型安全问题:你可以往 union 里写一个 int,然后按 float 读出来,编译器不会报任何错误。std::variant 解决了这个问题——它在内部维护一个"当前活跃类型"的索引,访问时会检查类型是否匹配。

std::variant 不使用堆分配,值直接存储在 variant 对象内部(大小等于最大备选类型的大小加上一个索引标记)。它也不能为空——除非进入了极少见的"无值"状态(valueless_by_exception)。

头文件与基本声明 ​

cpp
#include <variant>

// 可以持有 int、double 或 string 中的一个
std::variant<int, double, std::string> v;

// 默认构造时持有第一个类型(int)的默认值
// v 当前持有 int(0)

核心接口说明 ​

函数/操作说明
std::get<T>(v) / std::get<I>(v)按类型或索引获取值,类型不匹配抛 bad_variant_access
std::get_if<T>(&v) / std::get_if<I>(&v)按类型或索引获取指针,类型不匹配返回 nullptr
std::holds_alternative<T>(v)检查当前是否持有类型 T
v.index()返回当前活跃类型的索引(从 0 开始)
std::visit(visitor, v)用访问者模式处理 variant 的值
v.emplace<T>(args...)原地构造指定类型的值
v.valueless_by_exception()检查是否处于无值状态
std::monostate占位类型,让 variant 可以默认构造

基本示例 ​

cpp
#include <iostream>
#include <variant>
#include <string>
#include <vector>

// ============================
// 示例1:基本使用
// ============================

void basic_usage() {
    std::variant<int, double, std::string> v;

    // 默认构造:持有第一个类型 int 的默认值 0
    std::cout << "默认值: " << std::get<int>(v) << std::endl;  // 0
    std::cout << "索引: " << v.index() << std::endl;            // 0

    // 赋值为 double
    v = 3.14;
    std::cout << "double 值: " << std::get<double>(v) << std::endl;  // 3.14
    std::cout << "索引: " << v.index() << std::endl;                  // 1

    // 赋值为 string
    v = std::string("hello");
    std::cout << "string 值: " << std::get<std::string>(v) << std::endl;  // hello
    std::cout << "索引: " << v.index() << std::endl;                       // 2

    // 检查当前持有的类型
    std::cout << "持有 int? " << std::boolalpha
              << std::holds_alternative<int>(v) << std::endl;      // false
    std::cout << "持有 string? "
              << std::holds_alternative<std::string>(v) << std::endl; // true
}

// ============================
// 示例2:安全访问(get_if 不抛异常)
// ============================

void safe_access() {
    std::variant<int, std::string> v = 42;

    // get_if 返回指针,类型不匹配返回 nullptr
    if (auto* p = std::get_if<int>(&v)) {
        std::cout << "int 值: " << *p << std::endl;
    }

    if (auto* p = std::get_if<std::string>(&v)) {
        std::cout << "string 值: " << *p << std::endl;
    } else {
        std::cout << "当前不是 string" << std::endl;
    }

    // get 类型不匹配会抛异常
    try {
        std::get<std::string>(v);  // v 当前是 int,会抛异常
    } catch (const std::bad_variant_access& e) {
        std::cout << "异常: " << e.what() << std::endl;
    }
}

// ============================
// 示例3:std::visit 访问者模式
// ============================

void visit_demo() {
    std::variant<int, double, std::string> v = "world";

    // 用泛型 lambda 作为访问者
    std::visit([](auto&& arg) {
        using T = std::decay_t<decltype(arg)>;

        if constexpr (std::is_same_v<T, int>) {
            std::cout << "int: " << arg << std::endl;
        } else if constexpr (std::is_same_v<T, double>) {
            std::cout << "double: " << arg << std::endl;
        } else if constexpr (std::is_same_v<T, std::string>) {
            std::cout << "string: " << arg << std::endl;
        }
    }, v);
}

// ============================
// 示例4:overloaded 技巧(更优雅的 visit)
// ============================

// 辅助模板:合并多个 lambda 为一个重载集
template<class... Ts>
struct overloaded : Ts... { using Ts::operator()...; };

// C++17 推导指引
template<class... Ts>
overloaded(Ts...) -> overloaded<Ts...>;

void overloaded_visit_demo() {
    std::variant<int, double, std::string> v = 42;

    // 每种类型一个 lambda,clean 且直观
    std::visit(overloaded{
        [](int i)                { std::cout << "int: " << i << std::endl; },
        [](double d)             { std::cout << "double: " << d << std::endl; },
        [](const std::string& s) { std::cout << "string: " << s << std::endl; }
    }, v);
}

// ============================
// 示例5:monostate(让 variant 可以表示"空")
// ============================

// 如果第一个类型不可默认构造,variant 本身也不能默认构造
// monostate 作为占位类型解决这个问题
struct NonDefaultConstructible {
    int value;
    NonDefaultConstructible(int v) : value(v) {}
};

void monostate_demo() {
    // std::variant<NonDefaultConstructible> v;  // 编译错误!
    std::variant<std::monostate, NonDefaultConstructible> v;  // 可以

    // 默认构造时持有 monostate
    std::cout << "持有 monostate? "
              << std::holds_alternative<std::monostate>(v) << std::endl;  // true

    // 赋值
    v = NonDefaultConstructible{42};
    std::cout << "持有 NonDefaultConstructible? "
              << std::holds_alternative<NonDefaultConstructible>(v) << std::endl;  // true
}

int main() {
    std::cout << "=== 基本使用 ===" << std::endl;
    basic_usage();

    std::cout << "\n=== 安全访问 ===" << std::endl;
    safe_access();

    std::cout << "\n=== visit ===" << std::endl;
    visit_demo();

    std::cout << "\n=== overloaded visit ===" << std::endl;
    overloaded_visit_demo();

    std::cout << "\n=== monostate ===" << std::endl;
    monostate_demo();

    return 0;
}

与传统方案的对比 ​

方案类型安全堆分配能否为空可持有类型数
std::variant类型安全无不能(除非 monostate)编译期固定
union不安全无取决于实现编译期固定
std::any运行期类型安全可能有(大对象)可以为空不限
继承 + 虚函数类型安全通常需要取决于设计运行期可扩展

进阶用法 ​

cpp
#include <iostream>
#include <variant>
#include <string>
#include <vector>
#include <numeric>

// ============================
// 进阶1:用 variant 实现简单的表达式树
// ============================

// 前向声明
struct Add;
struct Mul;
struct Lit;

// 表达式节点:字面量、加法、乘法
using Expr = std::variant<Lit, std::shared_ptr<Add>, std::shared_ptr<Mul>>;

struct Lit {
    double value;
};

struct Add {
    Expr left, right;
};

struct Mul {
    Expr left, right;
};

// 辅助模板
template<class... Ts>
struct overloaded2 : Ts... { using Ts::operator()...; };
template<class... Ts>
overloaded2(Ts...) -> overloaded2<Ts...>;

// 求值函数
double eval(const Expr& expr) {
    return std::visit(overloaded2{
        [](const Lit& lit) -> double {
            return lit.value;
        },
        [](const std::shared_ptr<Add>& add) -> double {
            return eval(add->left) + eval(add->right);
        },
        [](const std::shared_ptr<Mul>& mul) -> double {
            return eval(mul->left) * eval(mul->right);
        }
    }, expr);
}

// ============================
// 进阶2:variant 的异构容器
// ============================

void heterogeneous_container() {
    using Value = std::variant<int, double, std::string, bool>;

    // 一个容器中存储不同类型的值
    std::vector<Value> values{42, 3.14, std::string("hello"), true, 100};

    for (const auto& v : values) {
        std::visit(overloaded2{
            [](int i)                { std::cout << "[int] " << i << std::endl; },
            [](double d)             { std::cout << "[double] " << d << std::endl; },
            [](const std::string& s) { std::cout << "[string] " << s << std::endl; },
            [](bool b)               { std::cout << "[bool] " << std::boolalpha << b << std::endl; }
        }, v);
    }
}

// ============================
// 进阶3:visit 处理多个 variant
// ============================

void multi_visit() {
    std::variant<int, std::string> v1 = 10;
    std::variant<int, std::string> v2 = std::string("hello");

    // visit 可以同时处理多个 variant
    std::visit(overloaded2{
        [](int a, int b)                           { std::cout << "两个int: " << a + b << std::endl; },
        [](int a, const std::string& b)            { std::cout << "int+string: " << a << " " << b << std::endl; },
        [](const std::string& a, int b)            { std::cout << "string+int: " << a << " " << b << std::endl; },
        [](const std::string& a, const std::string& b) { std::cout << "两个string: " << a << " " << b << std::endl; }
    }, v1, v2);
}

int main() {
    // 表达式树:(1 + 2) * 3
    Expr expr = std::make_shared<Mul>(Mul{
        std::make_shared<Add>(Add{Lit{1.0}, Lit{2.0}}),
        Lit{3.0}
    });
    std::cout << "(1 + 2) * 3 = " << eval(expr) << std::endl;  // 9

    std::cout << "\n=== 异构容器 ===" << std::endl;
    heterogeneous_container();

    std::cout << "\n=== 多 variant visit ===" << std::endl;
    multi_visit();

    return 0;
}

适用场景 ​

  • 需要一个变量在不同时刻持有不同类型的值(替代 union 或继承体系)
  • 解析器和编译器中的 AST 节点表示
  • 配置系统中一个字段可能是 int、string、bool 等不同类型
  • 状态机中表示不同的状态(每种状态可能携带不同的数据)
  • 异构容器(std::vector<std::variant<int, string, double>>)
  • 消息系统中的不同消息类型

常见问题 ​

std::variant 和 std::any 有什么区别?

variant 的类型列表在编译期固定,访问时编译器知道所有可能的类型;any 可以持有任意类型,只在运行期检查。variant 不需要堆分配(值直接在对象内),any 对于大对象可能需要堆分配。variant 的 visit 可以在编译期保证所有类型都被处理,any 做不到。

variant 可以持有相同类型多次吗?

可以,但这种情况下不能用类型来访问,只能用索引。std::variant<int, int> 合法,但 std::get<int>(v) 会编译错误(歧义),必须用 std::get<0>(v) 或 std::get<1>(v)。

什么是 valueless_by_exception?

如果在赋值或 emplace 过程中,新值的构造抛出了异常,variant 可能进入"无值"状态(旧值已经销毁,新值构造失败)。这时 valueless_by_exception() 返回 true,index() 返回 variant_npos。这是极少见的边界情况。

为什么需要 monostate?

variant 默认构造时会构造第一个类型的默认值。如果第一个类型不可默认构造,variant 本身也无法默认构造。把 std::monostate 放在第一个位置作为"空"状态的占位符就解决了这个问题。

注意事项 ​

  • std::variant 不能为空(和 std::optional 不同),要表示"空"需要用 monostate
  • std::get 类型不匹配会抛 std::bad_variant_access,std::get_if 返回 nullptr 更安全
  • std::visit 的访问者必须能处理 variant 的所有备选类型,否则编译报错
  • variant 的大小等于最大备选类型的大小加上索引标记的空间(通常 1-8 字节)
  • variant 不能持有 void、引用类型或数组类型
  • 同一个类型在 variant 中出现多次时,只能用索引访问,不能用类型访问
  • overloaded 技巧(合并多个 lambda)是使用 visit 的常见模式

编译器支持情况 ​

编译器最低支持版本
GCC7.0
Clang4.0
MSVC19.10 (VS 2017)

总结 ​

std::variant 是 C++17 提供的类型安全联合体,取代了不安全的 union。它在编译期就确定了所有可能持有的类型,运行时通过索引标记追踪当前活跃的类型。访问值时,std::get 和 std::get_if 提供了带检查和不抛异常两种方式;std::visit 配合重载 lambda(overloaded 技巧)是处理 variant 最优雅的方式——编译器会强制你处理所有备选类型,避免遗漏。variant 不使用堆分配,性能和手写的 tagged union 相当。它特别适合 AST 表示、状态机、异构容器等需要"一个位置放不同类型"的场景。