一、简介

C++标准库中的std::variant是C++17引入的一种数据类型，它的作用是可以同时存储多种不同类型的值，但在任意时间只能有一种类型的值被存储。这使得std::variant成为一种灵活的数据类型，适用于需要处理多种可能类型的情况。

std::variant的优势在于它提供了类型安全和便利的接口，相比传统的联合体（union），std::variant不需要手动管理数据成员的活跃性，也提供了更加友好和安全的访问方法。它在处理多样化数据类型、泛型编程以及处理变化的数据结构时非常有用。通过std::variant可以更加方便地处理多类型值的存储和访问，增强代码的灵活性和安全性。

二、理解std::variant

std::variant是C++17标准引入的一种数据类型，它是一种能够存储多种不同类型的值，但在任何时刻只能有一种类型的值被存储的类型安全的联合体。换句话说，它是一种能够存储一组预定义类型中的一个值的数据结构。与传统的联合体（union）不同，std::variant不需要手动管理数据成员的活跃性，从而避免了一些常见的错误。

std::variant的特点：

1. 类型安全：在编译时就能够保证类型的正确性，不会出现因类型错误而导致的运行时错误。
2. 便利的访问方式：std::variant提供了丰富的访问方式，包括std::get方法和std::visit方法，可以方便地获取和操作存储在std::variant中的值。
3. 能够方便地在不同类型值之间切换，并且可以用于编写通用代码处理不同类型的数据。

2.1、定义和使用std::variant

使用std::variant时需要包含头文件<variant>，同时需要使用namespace std。
std::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类型：

#include <variant>
#include <string>
#include <iostream>

int main() {
    std::variant<int, double, std::string> v;
    return 0;
}

在此示例中定义了一个std::variant对象v，它可以存储int、double和std::string类型的值。

std::variant存储值：

v = 10; // 存储int类型的值
v = 3.14; // 存储double类型的值
v = "hello"; // 存储std::string类型的值

要访问存储的值，可以使用std::get方法：

std::cout << std::get<int>(v) << std::endl; // 获取存储的int类型的值
std::cout << std::get<double>(v) << std::endl; // 获取存储的double类型的值
std::cout << std::get<std::string>(v) << std::endl; // 获取存储的std::string类型的值

也可以使用std::visit方法来访问不同类型的值：

std::visit([](auto&& arg) {
    std::cout << arg << std::endl;
}, v);

这个lambda函数将会根据存储的值类型来自动调用对应的代码。

2.2、与传统联合体union的区别

1. 类型安全。在传统的联合体中，需要手动跟踪当前存储的是哪种类型的值，这容易导致错误。而 std::variant 在编译时就会检查类型的正确性，避免了因类型错误而导致的运行时问题。

2. 在传统的联合体中，需要手动管理哪个成员是“活跃”的，需要额外的逻辑来保证只有一个数据成员是有效的。而 std::variant 不需要手动管理活跃成员，它内置了这种管理机制。

3. std::variant 提供了通用的访问接口，如 std::get 和 std::visit，使得对存储的值进行访问变得更加友好和便利。

4. 支持复制和销毁语义，即使值类型是trivial也可以正确地进行复制和销毁操作。在传统的联合体中，这种语义可能是不确定的或者无法保证的。

三、多类型值存储示例

#include <variant>
#include <iostream>
#include <string>

int main() {
    // 定义一个std::variant对象，可以存储int、double和std::string类型的值
    std::variant<int, double, std::string> v;

    // 存储int类型的值
    v = 10;
    // 访问存储的int类型的值
    std::cout << "Stored int value: " << std::get<int>(v) << std::endl;

    // 存储double类型的值
    v = 3.14;
    // 访问存储的double类型的值
    std::cout << "Stored double value: " << std::get<double>(v) << std::endl;

    // 存储std::string类型的值
    v = "Hello";
    // 访问存储的std::string类型的值
    std::cout << "Stored string value: " << std::get<std::string>(v) << std::endl;

    // 使用std::visit访问不同类型的值
    std::visit([](auto && arg) {
        using T = std::decay_t<decltype(arg)>;
        if constexpr (std::is_same_v<T, int>) {
            std::cout << "int: " << arg << std::endl;
        } else if constexpr (std::is_same_v<T, double>) {
            std::cout << "double: " << arg << std::endl;
        } else if constexpr (std::is_same_v<T, std::string>) {
            std::cout << "string: " << arg << std::endl;
        }
    }, v);

    return 0;
}

定义了一个std::variant对象v，它可以存储int、double和std::string类型的值，并对其进行了存储和访问的操作。

四、访问std::variant中的值

使用std::get和std::visit等方法来访问存储在std::variant中的值。

1. 使用std::get直接获取存储在std::variant中的特定类型的值。要确保std::variant中存储的是指定类型的值才可以使用std::get来安全的获取它。例如：

   std::variant<int, double, std::string> v;
   
   v = 10; // 存储int类型的值
   std::cout << std::get<int>(v) << std::endl; // 获取存储的int类型的值
   

2. 使用std::visit: std::visit是一个非常强大且灵活的访问方式。它允许定义一个访问器根据std::variant 中的实际类型调用对应的函数。示例：

   std::visit([](auto&& arg) {
       using T = std::decay_t<decltype(arg)>;
       if constexpr (std::is_same_v<T, int>) {
           std::cout << "int: " << arg << std::endl;
       } else if constexpr (std::is_same_v<T, double>) {
           std::cout << "double: " << arg << std::endl;
       } else if constexpr (std::is_same_v<T, std::string>) {
           std::cout << "string: " << arg << std::endl;
       }
   }, v);
   

除了std::get和std::visit之外，std::variant还提供了其他一些方法来访问存储的值，例如index()方法可以用来获取当前存储的值的索引。std::get和std::visit是使用最为广泛的方法。

使用index()方法来获取当前存储的值的索引。索引表示了当前存储的值在std::variant中是第几个备选项。示例：

#include <iostream>
#include <variant>
#include <string>

int main() {
    std::variant<int, double, std::string> v;
    
    v = 10; // 存储int类型的值
    std::cout << "Index of the stored value: " << v.index() << std::endl; // 获取存储的值的索引，这里会输出 0

    v = 3.14; // 存储double类型的值
    std::cout << "Index of the stored value: " << v.index() << std::endl; // 获取存储的值的索引，这里会输出 1

    v = "Hello"; // 存储std::string类型的值
    std::cout << "Index of the stored value: " << v.index() << std::endl; // 获取存储的值的索引，这里会输出 2

    return 0;
}

index()方法对于在某些情况下需要了解当前存储的值类型的位置是非常有用的。

五、错误处理和访问未初始化的std::variant

使用std::get或者std::visit方法去访问未初始化的值或者访问非活跃的成员，会触发std::bad_variant_access异常。

#include <iostream>
#include <variant>

int main() {
    std::variant<int, double, std::string> v;

    try {
        // 尝试访问未初始化的值，并捕获std::bad_variant_access异常
        std::cout << std::get<int>(v) << std::endl;
    } catch (const std::bad_variant_access& e) {
        std::cout << "Caught bad_variant_access: " << e.what() << std::endl;
    }

    v = 10; // 存储int类型的值
    // 尝试访问非活跃的成员，并捕获std::bad_variant_access异常
    try {
        std::cout << std::get<double>(v) << std::endl;
    } catch (const std::bad_variant_access& e) {
        std::cout << "Caught bad_variant_access: " << e.what() << std::endl;
    }

    return 0;
}

通过捕获并处理std::bad_variant_access异常可以在代码中更安全地处理访问未初始化值和使用非活跃成员的错误。

六、应用场景

在实际的应用程序中，std::variant可以被用于处理多类型值的情况，例如处理配置选项、解析数据等。

（1）假设需要实现一个配置选项的系统，用户可以设置不同类型的数值选项，比如整数、浮点数或字符串。可以使用std::variant来存储不同类型的选项值，并使用该类型来统一管理选项值。例如：

#include <variant>
#include <string>

using OptionValue = std::variant<int, double, std::string>;

struct Configuration {
    std::string name;
    OptionValue value;
};

（2）当处理需要解析多类型数据的情况时，std::variant也可以派上用场。例如，当解析一些类似JSON的结构时，可以使用std::variant来表示不同可能的值类型，从而在解析期间轻松地处理不同类型的值。

std::variant<int, double, std::string, bool> parseValue(const JsonValue& json) {
    if (json.isInt()) {
        return json.getInt();
    } else if (json.isDouble()) {
        return json.getDouble();
    } else if (json.isString()) {
        return json.getString();
    } else if (json.isBoolean()) {
        return json.getBoolean();
    }
    // Handle error, unsupported type, or default case
}

七、总结

std::variant提供了类型安全的方式来存储和访问多种不同类型的值，避免了由于类型不匹配导致的运行时错误。

掌握多类型值的存储对于现代C++编程来说至关重要，特别是在需要处理多种动态数据类型的场景下。

随着C++标准的不断更新和发展，std::variant将在许多领域继续发挥作用。例如在网络编程中，处理复杂消息类型；在图形界面开发中，处理各种用户输入类型；在游戏开发中处理实体的多种状态等。

学习资料：

• 《Effective Modern C++》：一本非常好的C++书籍，其中介绍了现代C++编程的最佳实践。
• C++ reference : 这个网站提供了关于C++中各种类和库的非常详尽的参考文档，其中包括std::variant的详细信息。
• 《C++ Programming Language, The (4th Edition)》：由Bjarne Stroustrup著作，包含了C++语言的全面信息，也包括了对于C++标准库的介绍。