存储不同的类型——std::variant

C++中支持使用struct和class的方式将不同类型的变量进行包装。当我们想要使用一种类型来表示多种类型时，也可以使用union。不过union的问题在于我们无法知道，其是以哪种类型为基础进行的初始化。

看一下下面的代码：

  1. union U {
  2.     int a;
  3.     char *b;
  4.     float c;
  5. };
  6. void func(U u) { std::cout << u.b << '\n'; }

当我们调用func时，其会将已整型a为基础进行初始化的联合体t进行打印，当然也无法阻止我们对其他成员进行访问，就像使用字符串指针对成员b进行初始化了一样，这段代码会引发各种bug。当我们开始对联合体进行打包之前，有一种辅助变量能够告诉我们其对联合体进行的初始化是安全的，其就是std::variant，在C++17中加入STL。

variant是一种新的类型，类型安全，并高效的联合体类型。其不使用堆上的内存，所以在时间和空间上都非常高效。基于联合体的解决方案，我们就不用自己再去进行实现了。其能单独存储引用、数组或void类型的成员变量。

本节中，我们将会了解一下由vriant带来的好处。

How to do it…

我们实现一个程序，其中有两个类型：cat和dog。然后将猫狗混合的存储于一个列表中，这个列表并不具备任何运行时多态性：

  1. 包含必要的头文件，并声明所使用的命名空间：

    1. #include <iostream>
    2. #include <variant>
    3. #include <list>
    4. #include <string>
    5. #include <algorithm>
    7. using namespace std;

  2. 接下来，我们将实现两个具有类似功能的类，不过两个类型之间并没有什么联系。第一个类型是cat。cat对象具有名字，并能喵喵叫：

    1. class cat {
    2.     string name;
    4. public:
    5.     cat(string n) : name{n} {}
    7.     void meow() const {
    8.         cout << name << " says Meow!\n";
    9.     }
    10. };

  3. 另一个类是dog。dog能汪汪叫：

    1. class dog {
    2.     string name;
    4. public:
    5.     dog(string n) : name{n} {}
    7.     void woof() const {
    8.         cout << name << " says Woof!\n";
    9.     }
    10. };

  4. 现在我们就可以来定义一个animal类型，其为std::variant<dog, cat>的别名类型。其和以前的联合体一样，同时具有variant的特性：

    1. using animal = variant<dog, cat>;

  5. 编写主函数之前，我们再来实现两个辅助者。其中之一为动物判断谓词，通过调用is_type<cat>(...)或is_type<dog>(...)，可以判断动物实例中的动物为cat或dog。其实现只需要对holds_alternative进行调用即可，其为variant类型的一个通用谓词函数：

    1. template <typename T>
    2. bool is_type(const animal &a) {
    3.     return holds_alternative<T>(a);
    4. }

  6. 第二个辅助者为一个结构体，其看起来像是一个函数对象。其实际是一个双重函数对象，因为其operator()实现了两次。一种实现是接受dog作为参数输入，另一个实现是接受cat类型作为参数输入。对于两种实现，其会调用woof或meow函数：

    1. struct animal_voice
    2. {
    3.     void operator()(const dog &d) const { d.woof(); }
    4.     void operator()(const cat &c) const { c.meow(); }
    5. };

  7. 现在让我们使用这些辅助者和类型。首先，定义一个animal变量的实例，然后对其进行填充：

    1. int main()
    2. {
    3.     list<animal> l {cat{"Tuba"}, dog{"Balou"}, cat{"Bobby"}};

  8. 现在，我们会将列表的中内容打印三次，并且每次都使用不同的方式。第一种使用variant::index()。因为animal类型是variant<dog, cat>类型的别名，其返回值的0号索引代表了一个dog的实例。1号索引则代表了cat的实例。这里的关键是变量特化的顺序。switch-cast代码块中，可以通过get<T>的方式获取内部的cat或dog实例：

    1.     for (const animal &a : l) {
    2.         switch (a.index()) {
    3.         case 0:
    4.             get<dog>(a).woof();
    5.             break;
    6.         case 1:
    7.             get<cat>(a).meow();
    8.             break;
    9.         }
    10.     }
    11.     cout << "-----\n";

  9. 我们也可以显示的使用类型作为其索引。get_if<dog>会返回一个指向dog类型的指针。如果没有dog实例在列表中，那么指针则为null。这样，我们可以尝试获取下一种不同类型的实例，直到成功为止：

    1.     for (const animal &a : l) {
    2.         if (const auto d (get_if<dog>(&a)); d) {
    3.             d->woof();
    4.         } else if (const auto c (get_if<cat>(&a)); c) {
    5.             c->meow();
    6.         }
    7.     }
    8.     cout << "-----\n";

  10. 使用variant::visit是一种非常优雅的方式。这个函数能够接受一个函数对象和一个variant实例。函数对象需要对variant中所有可能类型进行重载。我们在之前已经对operator()进行了重载，所以这里可以直接对其进行使用：

    1.     for (const animal &a : l) {
    2.         visit(animal_voice{}, a);
    3.     }
    4.     cout << "-----\n";

  11. 最后，我们将回来数一下cat和dog在列表中的数量。is_type<T>的cat和dog特化函数，将会与std::count_if结合起来使用，用来返回列表中不同实例的个数：

    1.     cout << "There are "
    2.         << count_if(begin(l), end(l), is_type<cat>)
    3.         << " cats and "
    4.         << count_if(begin(l), end(l), is_type<dog>)
    5.         << " dogs in the list.\n";
    6. }

  12. 编译并运行程序，我们就会看到打印三次的结果都是相同的。然后，可以看到is_type和count_if配合的很不错：

    1. $ ./variant
    2. Tuba says Meow!
    3. Balou says Woof!
    4. Bobby says Meow!
    5. -----
    6. Tuba says Meow!
    7. Balou says Woof!
    8. Bobby says Meow!
    9. -----
    10. Tuba says Meow!
    11. Balou says Woof!
    12. Bobby says Meow!
    13. -----
    14. There are 2 cats and 1 dogs in the list.

How it works…

std::variant与std::any类型很相似，因为这两个类型都能持有不同类型的变量，并且我们需要在运行时对不同对象进行区分。

另外，std::variant有一个模板列表，需要传入可能在列表中的类型，这点与std::any截然不同。也就是说std::variant<A, B, C>必须是A、B或C其中一种实例。当然这也意味着其就不能持有其他类型的变量，除了列表中的类型std::variant没有其他选择。

variant<A, B, C>的类型定义，与以下联合体定义类似：

  1. union U {
  2.     A a;
  3.     B b;
  4.     C c;
  5. };

当我们对a, b或c成员变量进行初始化时，联合体中对其进行构建机制需要我们自行区分。std::variant类型就没有这个问题。

本节的代码中，我们使用了三种方式来处理variant中成员的内容。

首先，使用了variant的index()成员函数。对变量类型进行索引，variant<A, B, C> 中，索引值0代表A类型，1为B类型，2为C类型，以此类推来访问复杂的variant对象。

下一种就是使用get_if<T>函数进行获取。其能接受一个variant对象的地址，并且返回一个类型T的指针，指向其内容。如果T类型是错误，那么返回的指针就为null指针。其也可能对variant变量使用get<T>(x)来获取对其内容的引用，不过当这样做失败时，函数将会抛出一个异常(使用get-系列函数进行转换之前，需要使用holds_alternative<T>(x)对其类型进行检查)。

最后一种方式就是使用std::visit函数来进行，其能接受一个函数对象和一个variant实例。visit函数会对variant中内容的类型进行检查，然后调用对应的函数对象的重载operator()操作符。

为了这个目的，我们实现为了animal_voice类型，将visit和variant<dog, cat>类型结合在了一起：

  1. struct animal_voice
  2. {
  3.     void operator()(const dog &d) const { d.woof(); }
  4.     void operator()(const cat &c) const { c.meow(); }
  5. };

以visit的方式对variant进行访问看起来更加的优雅一些，因为使用这种方法就不需要使用硬编码的方式对variant内容中的类型进行判别。这就让我们的代码更加容易扩展。

Note：

variant类型不能为空的说法并不完全正确。将std::monostate类型添加到其类型列表中，其就能持有空值了。