在 C++17 之前，开发者通常通过联合（union）加上手动的类型标签、或者使用基类指针配合 RTTI 来实现多态行为。虽然这些方法在一定程度上满足需求，但往往伴随额外的错误风险：错误的类型转换、内存泄漏、以及代码可读性差。C++17 引入了 std::variant，为我们提供了一个类型安全、内存占用最小、易于使用的“类型安全的联合”实现。本文将从概念、基本用法、常见技巧和性能细节四个角度，系统梳理 std::variant 的实用价值。
1. 概念与核心特点
1.1 类型安全的多态
std::variant<Types...> 维护了一个内部的类型索引（index()），指示当前存储的是哪一个类型。它只允许对当前类型进行访问，访问错误会抛出 std::bad_variant_access。因此，比起传统的 union，variant 在编译期就能捕捉大部分类型错误。
1.2 轻量化
- 内存占用：
variant的大小等于其最大类型占用的大小加上一个std::size_t用来存储索引。相比多态基类指针的开销（至少指针大小），variant在多数情况下更节省空间。 - 复制/移动：
variant对每个构造函数、赋值运算符都提供了 复制 与 移动 的实现，内部自动调用对应类型的拷贝/移动构造/赋值。
1.3 兼容性
variant 兼容所有满足 CopyConstructible、CopyAssignable 的类型；若需要移动语义，必须满足 MoveConstructible 与 MoveAssignable。因此在使用时，需要确保所有类型都满足相应约束。
2. 基本使用
#include <variant>
#include <string>
#include <iostream>
#include <vector>
using JsonValue = std::variant<std::nullptr_t, bool, int, double, std::string, std::vector<JsonValue>>;
// 递归遍历并打印 JsonValue
void printJson(const JsonValue& val, int depth = 0) {
std::visit([depth](auto&& arg) {
using T = std::decay_t<decltype(arg)>;
std::string indent(depth * 2, ' ');
if constexpr (std::is_same_v<T, std::nullptr_t>) {
std::cout << indent << "null\n";
} else if constexpr (std::is_same_v<T, bool>) {
std::cout << indent << (arg ? "true" : "false") << "\n";
} else if constexpr (std::is_same_v<T, int>) {
std::cout << indent << arg << "\n";
} else if constexpr (std::is_same_v<T, double>) {
std::cout << indent << arg << "\n";
} else if constexpr (std::is_same_v<T, std::string>) {
std::cout << indent << '"' << arg << "\"\n";
} else if constexpr (std::is_same_v<T, std::vector<JsonValue>>) {
std::cout << indent << "[\n";
for (const auto& e : arg) printJson(e, depth + 1);
std::cout << indent << "]\n";
}
}, val);
}
int main() {
JsonValue v = std::vector <JsonValue>{42, std::string("hello"), true};
printJson(v);
}此示例演示了：
- 如何定义包含多种类型的
variant。 - 使用
std::visit对不同类型进行处理。 - 递归遍历嵌套结构。
3. 常见技巧
3.1 get_if 与安全访问
if (auto p = std::get_if<std::string>(&v)) {
std::cout << "String value: " << *p << '\n';
} else {
std::cout << "Not a string.\n";
}get_if 返回一个指向存储值的指针，如果类型不匹配则返回 nullptr，避免抛异常。
3.2 使用 index() 进行类型检查
switch (v.index()) {
case 0: /* nullptr */ break;
case 1: /* bool */ break;
case 2: /* int */ break;
case 3: /* double */ break;
case 4: /* string */ break;
case 5: /* vector */ break;
}index() 在运行时返回当前类型的序号。
3.3 重写 std::hash 以支持 unordered_map
namespace std {
template<>
struct hash <JsonValue> {
size_t operator()(JsonValue const& v) const noexcept {
return std::visit([](auto&& arg){ return std::hash<std::decay_t<decltype(arg)>>{}(arg); }, v);
}
};
}3.4 用 std::apply 组合多参数
std::variant<int, double> a{5}, b{3.2};
auto result = std::apply([](auto x, auto y){ return x + y; }, std::forward_as_tuple(a, b));4. 性能考量
| 场景 | 对比 | 结论 |
|---|---|---|
| 只存储基本类型（int/float） | variant<int, float> vs 基类指针 |
variant 更节省内存，速度略快 |
| 大对象（如字符串） | variant<string, vector<int>> vs std::unique_ptr<Base> |
需要考虑拷贝/移动开销，variant 对大对象的拷贝较贵，使用移动语义可降低成本 |
| 递归结构 | variant 与 `shared_ptr |
|
|variant` 递归时需要手动处理，基类指针更直观，但存在指针管理成本 |
5. 常见陷阱与调试
- 类型不匹配导致
std::bad_variant_access：在访问前请确认类型，使用get_if或index()。 - 移动构造/赋值缺失：若某个类型没有移动构造，
variant会退回到复制，可能导致性能问题。确认所有成员类型均提供移动语义。 std::visit的返回值：visit的返回值必须在所有 lambda 分支中一致，否则会报错。可以使用std::variant的operator=返回值来统一处理。
6. 小结
- 类型安全：
std::variant用编译时与运行时双重机制保证安全。 - 灵活性：支持任意数量、任意类型的组合，轻量化内存管理。
- 可维护性：相比传统联合+标签，代码可读性更好，错误更易定位。
在现代 C++ 开发中，尤其是需要实现多态容器或解析结构化数据（如 JSON、AST 等）的场景，std::variant 已成为不可或缺的工具。掌握其用法后，你将能写出既安全又高效的代码。