大家应该都知道C++17引入了variant，这篇文章我们来研究下它究竟有啥用。

本期目录

 variant是什么？

 为什么要引入variant？

 如何确定variant中当前存放的数据类型？

 variant为什么要搭配monostate？

 如何用variant实现多态？

variant这货类似于union，可以存放多种类型的数据，但任何时刻最多只能存放其中一种类型。

这里大家可能有些疑问，既然有了union，那为啥还要引入variant呢？

那肯定是因为union有缺点呗。

看这段union的基本用法：

union MyUnion {    int a;    float b;    double c;};
void test_simple_union() {    MyUnion u;    u.a = 1;    std::cout << u.a="">"\n"

;
   u.b = 1.32f;    std::cout << u.b="">"\n"

;
   u.c = 2.32;    std::cout << u.c="">"\n"

;}

union貌似也只能这么使用，没有其他方法。

这里有一个很重要的点，我没法获取当前存储的数据是什么类型，比如我当前存储的是float，但是却按int方式获取，这不就坏事了吗。

再看一段代码：

• struct A {    A() = default;    A(int aa) : a{aa} { std::cout <<>"A() \n"
  

; }    ~A() { std::cout <<>"~A() \n"

; }    int a;};
struct B {    B() = default;    B(float bb) : b{bb} { std::cout <<>"B() \n"

; }    ~B() { std::cout <<>"~B() \n"

; }    float b;};
union MyStructUnion {    A a;    B b;    /**     * @brief 在析构函数中我要做什么？不知道当前类型究竟是A还是B     * 那调用 a.~A() 还是 b.~B() ?     */    ~MyStructUnion() { std::cout <<>"~MyStructUnion() \n"

; }};
/** * @brief 需要手动调用析构函数 * */void test_struct_union() {    MyStructUnion u;
   new (&u.a) A(1);    std::cout << u.a.a="">"\n"

;    u.a.~A();
   u.b = B(2.3f);    std::cout << u.b.b="">"\n"

;    u.b.~B();}

这里可以看到，union无法自动处理构造和析构等逻辑，它需要用户手动调用相关函数才行，这就导致使用它union存储自定义类型时特别麻烦。

所以，variant诞生：struct C {    C() = default;    C(std::string cc) : c{cc} { std::cout <<>"C() \n"

; }    ~C() { std::cout <<>"~C() \n"

; }    std::string c;};
/** * @brief 使用variant完全不需要手动调用构造和析构函数，它会自动处理好所有逻辑，非常方便 * */void test_variant() {    std::variant u; ///< 下面很快就会介绍monostate    u = 1;    std::cout <<>std::get(u).a <<>"\n";    u = std::string("dsd");    std::cout <<>std::get(u).c <<>"\n";}

使用variant完全不需要手动调用构造和析构函数，它会自动处理好所有逻辑，非常方便。

这里还遗留个问题，即如何判断variant内部当前存储的数据是什么类型？别着急，后面会介绍。

在这之前还需要介绍个知识点：monostate。

首先，普通的variant使用方法如下：

这也是常规的variant使用方法。那我如果存储个自定义类型呢？

这里会编译失败，因为S没有无参默认构造函数，无法默认直接声明，所以这里需要加个monostate，表示默认情况下它的存储类型就是monostate。

然后可以这样使用：

那如何获取variant内部存储的类型呢？

其实variant有一个index()方法可以做到。

看这段代码：

在定义variant结束后，我们就会知道内部类型的index，然后在运行时我们就可以动态的获取当前var的index，进而确定内部数据的类型。

难道我们每次都要手动记录下variant内部数据类型的index吗？如果将来有一天我们要在中间新增数据类型，岂不是之前建立的index都错乱了。

这里可以使用可变参数模板+模板元编程的小技巧，看下面这段代码：

通过get_index_v，我就可以知道数据类型在variant中的index，以后即使有改动也不需要担心，它都会自动处理。再贴一段它的测试代码：

结果在这：

是不是很方便？

其实上面的代码，个人认为它也是一种多态，尽管它就是一个普通的switch-case，然而，我们可以使用std::visit稍微改装一下。

那std::visit怎么用？看这段代码：

visit内部会自动判断当前variant内部存储的类型，进而触发不同的行为。

上面是使用仿函数搭配的visit，其实使用lambda表达式更方便：

看到这里大家应该也悟到了，可以使用std::visit搭配variant来实现多态。

下面是我写的几个variant的多态示例：

上面的是没有参数的多态，那如果想为函数添加一些参数怎么办？

可以利用仿函数中的成员变量，即：

或者lambda表达式的捕获方式，即：

到这里已经介绍了variant实现多态的完整方案。

认为继承是个洪水猛兽的朋友，其实也可以考虑variant来实现多态的行为哈。

那同样是实现多态，是用继承好呢，还是用variant好呢？可以看这个图：

图片来源于这个链接：http://cpptruths.blogspot.com/2018/02/inheritance-vs-stdvariant-based.html。大家感兴趣的可以直接移步哈。

另外大家应该也比较感兴趣variant是如何实现的。关于如何实现variant，我找到了这篇文章，写的很不错，大家可以看看：https://www.cnblogs.com/qicosmos/p/3416432.html

下面是本文参考链接：

https://www.cppstories.com/2020/04/variant-virtual-polymorphism.html/

https://stackoverflow.com/questions/52296889/what-are-the-advantages-of-using-stdvariant-as-opposed-to-traditional-polymorp

https://www.cppstories.com/2018/06/variant/

http://cpptruths.blogspot.com/2018/02/inheritance-vs-stdvariant-based.html

打完收工。

完整代码见：

https://github.com/chengxumiaodaren/cpp-learning/tree/master/src/varian