C++17的三剑客分别是std::optional, std::any, std::vairant。今天主要讲std::variant。std::variant的定义如下：
template< class... Types >
class variant;类模板?std::variant?表示一个类型安全的联合体（以下称“变化体”）。std::variant?的一个实例在任意时刻要么保有它的一个可选类型之一的值，要么在错误情况下无值（此状态难以达成，见?valueless_by_exception）；从功能上讲，它就跟union的功能差不多，但却比union更高级；variant主要是为了提供更安全的union。举个例子union里面不能有string这种类型，但std::variant却可以，还可以支持更多复杂类型，如map等
为了支持第一个类型没有默认构造函数的variant对象，提供了一个特殊的helper类型:std::monostate。类型std::monostate的对象总是具有相同的状态，因此，它们总是相等的。它自己的目的是表示另一种类型，这样variant就没有任何其他类型的值。也就是说，std::monostate可以作为第一种替代类型，使变体类型默认为可构造。
?
std::variant<std::monostate, int> test; // OK
std::cout << "index: " << test.index(); //输出： 0我们可以简单理解std::monostate是个占位符。
?std::bad_variant_access?是下列情形中抛出的异常类型：
variant? ? ? ?示例如下：
#include <variant>
#include <iostream>
int main()
{
std::variant<int, float> v;
v = 12;
try {
std::get<float>(v);
}
catch(const std::bad_variant_access& e) {
std::cout << e.what() << '\n';
}
}可能的输出：
bad_variant_access提供作为编译时常量表达式，对可有 cv 限定的?variant?中可选项数量的访问，示例如下：
#include <any>
#include <cstdio>
#include <variant>
static_assert(std::variant_size_v<std::variant<>> == 0);
static_assert(std::variant_size_v<std::variant<int>> == 1);
static_assert(std::variant_size_v<std::variant<int, int>> == 2);
static_assert(std::variant_size_v<std::variant<int, int, int>> == 3);
static_assert(std::variant_size_v<std::variant<int, float, double>> == 3);
static_assert(std::variant_size_v<std::variant<std::monostate, void>> == 2);
static_assert(std::variant_size_v<std::variant<const int, const float>> == 2);
static_assert(std::variant_size_v<std::variant<std::variant<std::any>>> == 1);
int main() { std::puts("All static assertions passed."); }输出：
All static assertions passed.提供对?variant?的类型编译时下标访问,示例如下：
#include <variant>
#include <iostream>
using my_variant = std::variant<int, float>;
static_assert(std::is_same_v
<int, std::variant_alternative_t<0, my_variant>>);
static_assert(std::is_same_v
<float, std::variant_alternative_t<1, my_variant>>);
// variant 类型上的 cv 限定传播给提取出的可选项类型。
static_assert(std::is_same_v
<const int, std::variant_alternative_t<0, const my_variant>>);
int main()
{
std::cout << "All static assertions passed\n";
}输出：
All static assertions passedstd::variant提供的主要操作有：
| 操作 | 说明 |
|---|---|
| constructors | 创建一个variant对象(可能调用底层类型的构造函数) |
| destructor | 销毁一个variant对象 |
| emplace<T>() | 为具有类型T的备选项分配一个新值 |
| emplace<Idx>() | 为索引Idx的备选项分配一个新值 |
| = | 分配一个新值 |
| index() | 返回当前备选项的索引 |
| holds_alternative<T>() | 返回类型T是否有值 |
| ==, !=, <, <=, >, >= | 比较variant对象 |
| swap() | 交换两个对象的值 |
| hash<> | 函数对象类型来计算哈希值 |
| valueless_by_exception() | 返回该变量是否由于异常而没有值 |
| get<T>() | 返回备选项类型为T的值或抛出异常(如果没有类型为T的值) |
| get<Idx>() | 返回备选项索引为idx的值或抛出异常(如果没有索引为idx的值) |
| get_if<T>() | 返回指向类型为T指针或返回nullptr(如果没有类型为T的值) |
| get_if<Idx>() | 返回指向索引Idx的指针或nullpt(如果没有索引为idx的值) |
| visit() | 为当前备选项执行操作 |
直接定义std::variant,如：
std::variant<std::uint32_t, double, std::string, std::int32_t> t;可以对 t 赋初值，对于基本类型，它是0、false还是nullptr。如果传递一个值进行初始化，则使用最佳匹配类型，如：
std::variant<std::uint32_t, double, std::string, std::int32_t> t{ 25 };
cout << t.index(); //输出: 3要传递多个值进行初始化，必须使用in_place_type或in_place_index标记:
std::variant<std::complex<double>> t1{1.0,564.0}; // ERROR
std::variant<std::complex<double>> t2{std::in_place_type<std::complex<double>>,
322.0, 2323.0};
std::variant<std::complex<double>> t3{std::in_place_index<0>, 35.0, 8.0};如果初始化过程中出现歧义或匹配问题，可以用in_place_index标签来解决，如：
std::variant<int, int> t1{std::in_place_index<1>, 77}; // init 2nd int
std::variant<int, long> t2{std::in_place_index<1>, 77}; // init long, not int
std::cout << t2.index(); // prints 1std::variant可以通std::get来获取或修改值。
std::variant<std::uint32_t, double, std::string, std::int32_t> var;
auto x = std::get<double>(var);
auto y = std::get<4>(var); // compile-time ERROR: no 4th alternative
auto c = std::get<int>(var);
try{
auto m = std::get<std::string>(var); // throws exception (first int currently set)
auto n = std::get<0>(var); // OK, i==0
auto o = std::get<1>(var); // throws exception (other int currently set)
}
catch (const std::bad_variant_access& e) { // in case of an invalid access
std::cout << "Exception: " << e.what() << '\n';
}std::get_if用来判断某项是否存在
#include <variant>
#include <iostream>
int main()
{
std::variant<int, float> v{12};
if(auto pval = std::get_if<int>(&v))
std::cout << "variant value: " << *pval << '\n'; //输出: 12
else
std::cout << "failed to get value!" << '\n';
}还可以通过std::visit来访问值：
struct stValueVisitor {
void operator()(int i) { cout << "int: " << i << '\n'; }
void operator()(float f) { cout << "float: " << f << '\n'; }
void operator()(const std::string& s) { cout << "str: " << s << '\n'; }
};
int main() {
std::variant<int, float, string> value = 65.2；
std::visit(stValueVisitor{}, value); // 输出 float: 65.2
return 0;
}也可以利用C++17 新增的 overloaded 模板，可以直接生成匿名访问器，简化代码， 下面的代码是等价的:?
int main() {
std::variant<int, float, string> t= 56.4；
std::visit(overloaded{
void operator()(int i) { cout << "int: " << i << '\n'; }
void operator()(float f) { cout << "float: " << f << '\n'; }
void operator()(const std::string& s) { cout << "str: " << s << '\n'; }
},t);
}接下来还有第三种方法来访问std::variant :?
int main()
{
std::variant<int, float, string> t = 16.4；
std::visit(
[&](auto &&arg) {
using T = std::decay_t<decltype(arg)>; // 类型退化，去掉类型中的const 以及 &
if constexpr(std::is_same_v<T,int>) {
cout << "int: " << arg << '\n';
} else if constexpr(std::is_same_v<T,float>){
cout<< "float: "<< arg <<'\n';
} else if constexpr(std::is_same_v<T,std::string>){
cout<< "str: "<< arg <<'\n';
}
}, t);
}这里我们可以看出来第三种写法比第一种的优势在哪里了：编译期推断。
第三种方法由于使用了constexpr 进行 if 分支的判断，因此是在编译期运行，而第一种方法是运行期进行类型判断，效率是不同的。
第二种方法和模板一样，也是编译期推断的，因此效率也是很高的，所以我们应当尽量使用 std::visit 方法来访问variant 变量
另外std::visit 还有一个好处是，它的参数列表是不定长的，我们可以传入多个variant 变量
template <class Visitor, class... Variants>
constexpr visit(Visitor&& vis, Variant&&... vars);用std::get来修改值，如：
std::variant<std::uint32_t, double, std::string, std::int32_t> t;
std::get<double>(t) = 1.0;
cout << t.index(); //输出: 1
std::get<std::uint32_t>(t) = 34;
cout << t.index(); //输出: 0
std::get<2>(t) = "4343636";
cout << t.index(); //输出:2也可以用std::get_if来修改值，如：
std::variant<std::uint32_t, double, std::string, std::int32_t> t;
if (auto p = std::get_if<1>(&t)) { // if second int set
*p = 42.2; // modify it
}以上都是我日常工作中对std::variant的用法的总结；做技术，要知其然，更要知其所以然，后面我将从std::varant的源码实现上继续分析它的原理，敬请期待。。。