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)。
头文件与基本声明
#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 可以默认构造 |
基本示例
#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 | 运行期类型安全 | 可能有(大对象) | 可以为空 | 不限 |
| 继承 + 虚函数 | 类型安全 | 通常需要 | 取决于设计 | 运行期可扩展 |
进阶用法
#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不同),要表示"空"需要用monostatestd::get类型不匹配会抛std::bad_variant_access,std::get_if返回 nullptr 更安全std::visit的访问者必须能处理 variant 的所有备选类型,否则编译报错- variant 的大小等于最大备选类型的大小加上索引标记的空间(通常 1-8 字节)
- variant 不能持有
void、引用类型或数组类型 - 同一个类型在 variant 中出现多次时,只能用索引访问,不能用类型访问
overloaded技巧(合并多个 lambda)是使用 visit 的常见模式
编译器支持情况
| 编译器 | 最低支持版本 |
|---|---|
| GCC | 7.0 |
| Clang | 4.0 |
| MSVC | 19.10 (VS 2017) |
总结
std::variant 是 C++17 提供的类型安全联合体,取代了不安全的 union。它在编译期就确定了所有可能持有的类型,运行时通过索引标记追踪当前活跃的类型。访问值时,std::get 和 std::get_if 提供了带检查和不抛异常两种方式;std::visit 配合重载 lambda(overloaded 技巧)是处理 variant 最优雅的方式——编译器会强制你处理所有备选类型,避免遗漏。variant 不使用堆分配,性能和手写的 tagged union 相当。它特别适合 AST 表示、状态机、异构容器等需要"一个位置放不同类型"的场景。