说起C++里多类型存储，很多老手可能首先想到
union或者基类指针。但这些都有各自的坑。
std::variant就是C++17给我们的一个优雅答案，它能让你在一个变量里装好几种不同类型的数据，而且还保证类型安全，避免了那些运行时才能发现的错误。简单来说，它就像一个“智能盒子”，你知道里面可能装了什么，每次拿出来的时候也能确定拿出来的是哪个类型，绝不会搞混。 解决方案
刚接触
std::variant，你会发现它的声明有点像
std::tuple，只是它只能同时持有一个值。比如，
std::variant<int, double, std::string> myValue;这样就声明了一个可以存
int、
double或
std::string的变量。默认情况下，它会用第一个类型（这里是
int）来构造。你可以直接赋值来改变它存储的类型和值，比如
myValue = 42;或者
myValue = 3.14;再或者
myValue = "Hello, Variant!";
那么怎么把值取出来呢？这是关键。
std::get是常用的方法，你可以通过类型或者索引来取。
std::get<int>(myValue)或者
std::get<0>(myValue)。但这里有个坑：如果你当前存的是
double，却想用
std::get<int>去取，程序就会抛出
std::bad_variant_access异常。这就比
union安全多了，至少你能在运行时捕获到这个错误，而不是拿到一堆乱码。
为了避免这种异常，你可以先用
std::holds_alternative<int>(myValue)来检查当前是不是存的
int。不过，更优雅、更现代C++的做法是使用
std::visit。
std::visit接受一个可调用对象（比如lambda表达式或者函数对象）和你的
variant对象，它会根据
variant当前存储的类型，调用对应的重载函数。这简直是处理多类型逻辑的神器，省去了大量的
if-else if链。
看个简单的
std::visit例子：
#include <variant>
#include <string>
#include <iostream>
// 定义一个可以存储int, double, std::string的variant
using MyVariant = std::variant<int, double, std::string>;
// 定义一个访问器，可以是函数对象
struct MyVisitor {
void operator()(int i) const {
std::cout << "当前存储的是整数: " << i << std::endl;
}
void operator()(double d) const {
std::cout << "当前存储的是浮点数: " << d << std::endl;
}
void operator()(const std::string& s) const {
std::cout << "当前存储的是字符串: " << s << std::endl;
}
};
int main() {
MyVariant var; // 默认构造为第一个类型，即int，值为0
var = 123;
std::visit(MyVisitor{}, var); // 输出：当前存储的是整数: 123
var = 4.56;
std::visit(MyVisitor{}, var); // 输出：当前存储的是浮点数: 4.56
var = "Hello, C++17!";
std::visit(MyVisitor{}, var); // 输出：当前存储的是字符串: Hello, C++17!
// 尝试错误地使用std::get
try {
std::cout << "尝试获取int: " << std::get<int>(var) << std::endl;
} catch (const std::bad_variant_access& e) {
std::cerr << "错误: " << e.what() << std::endl; // 输出错误信息
}
// 安全地使用std::get_if
if (const std::string* s_ptr = std::get_if<std::string>(&var)) {
std::cout << "安全获取字符串: " << *s_ptr << std::endl;
}
return 0;
} 这段代码展示了
std::variant的基本用法，包括赋值、通过
std::visit进行类型安全访问，以及
std::get可能抛出的异常和
std::get_if的安全获取方式。 为什么
std::variant比
union和基类指针更安全、更现代？
这问题问得好，也是很多从C++11/14时代过来的开发者心中的疑问。毕竟以前我们不是没法实现多类型存储，
union和多态基类指针不都行吗？但仔细一想，它们各自的痛点可不少。
union嘛，它的问题在于它完全不关心你到底往里塞了什么，也不管你取出来的是什么。你塞个
int，然后硬要当
double取出来，编译器是不会拦你的，结果就是未定义行为（Undefined Behavior），程序可能直接崩溃，也可能给你一堆乱七八糟的数据。而且，
union不能存那些有复杂构造函数、析构函数或者拷贝赋值操作的类型（比如
std::string），限制太大了，因为它不知道怎么去正确地管理这些资源。
用基类指针实现多态固然强大，但它也有自己的适用场景和开销。首先，你得先设计一个基类，然后所有可能的类型都得继承它。这会引入虚函数表（vtable）的运行时开销，而且通常涉及到堆内存分配，你需要自己管理内存（
std::unique_ptr或
std::shared_ptr能减轻负担，但开销还在）。如果你的类型之间没有天然的“is-a”关系，强行设计继承体系反而会显得笨重和不自然。而且，你每次访问具体类型的方法时，通常还需要
dynamic_cast，这本身也是一种运行时开销和潜在的失败点，而且如果转换失败，结果是
nullptr或者抛异常，你还得去处理。
相比之下，
std::variant就像是两者的优点结合体，同时规避了它们的缺点。它在编译期就知道了所有可能的类型，因此提供了强大的类型安全保证。它直接在栈上存储值（除非包含的类型本身需要堆内存），没有虚函数表的开销，也不需要继承体系。通过
std::visit，它提供了一种非常优雅且类型安全的方式来处理内部的不同类型，几乎所有的类型检查和调度都在编译期完成，运行时开销极小。这让它在处理固定集合的异构类型时，成为一个非常现代且高效的选择，特别适合那些类型集合已知且不常变化的场景。
std::variant在实际项目中可能遇到哪些挑战和最佳实践？
任何一个强大的工具，用起来都会有些门道，
std::variant也不例外。我在实际项目里用它的时候，也踩过一些小坑，也总结了一些经验。
一个常见的问题是，如果你
std::variant列表里的第一个类型没有默认构造函数，那么你直接声明
std::variant<MyClass, int> v;就会报错。这时候，一个常见的解决方案是把
std::monostate放在第一个位置：`
以上就是C++如何使用std::variant实现多类型安全存储的详细内容，更多请关注知识资源分享宝库其它相关文章！
发表评论:
◎欢迎参与讨论，请在这里发表您的看法、交流您的观点。