C++17 std::variant[编辑 | 编辑源代码]

std::variant 是 C++17 标准库中引入的一个模板类，用于表示一个类型安全的联合体（union）。它可以存储一组预定义类型中的某一个值，并在运行时安全地访问该值，避免了传统 C 风格联合体（union）的类型不安全问题。std::variant 是 C++ 中实现多态的一种方式，尤其适用于需要存储多种可能类型但每次只使用其中一种的场景。

基本介绍[编辑 | 编辑源代码]

std::variant 类似于一个类型安全的联合体，它允许你在一个变量中存储多种不同类型的值，但在任何时候只能存储其中的一种。它提供了一种比 C 风格联合体更安全、更现代的方式来处理多类型数据。

主要特点[编辑 | 编辑源代码]

类型安全：std::variant 在编译时检查类型，避免运行时错误。
可访问性检查：可以通过 std::holds_alternative 或 std::visit 安全地访问存储的值。
异常安全：如果访问错误的类型，会抛出 std::bad_variant_access 异常（除非使用 std::get_if）。
默认构造：默认构造时存储第一个类型的默认值（如果第一个类型是可默认构造的）。

基本用法[编辑 | 编辑源代码]

定义与初始化[编辑 | 编辑源代码]

std::variant 定义时需要指定可能的类型列表。例如：

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

int main() {
    // 定义一个可以存储 int、double 或 std::string 的 variant
    std::variant<int, double, std::string> v;

    v = 42; // 存储 int
    std::cout << "Stored int: " << std::get<int>(v) << "\n";

    v = 3.14; // 存储 double
    std::cout << "Stored double: " << std::get<double>(v) << "\n";

    v = "Hello"; // 存储 std::string
    std::cout << "Stored string: " << std::get<std::string>(v) << "\n";

    return 0;
}

输出:

Stored int: 42
Stored double: 3.14
Stored string: Hello

访问值[编辑 | 编辑源代码]

有几种方式可以访问 std::variant 中存储的值：

1. std::get：直接获取特定类型的值（如果类型不匹配会抛出异常）

try {
    auto s = std::get<std::string>(v); // 正确
    auto i = std::get<int>(v); // 抛出 std::bad_variant_access
} catch (const std::bad_variant_access& e) {
    std::cerr << "Error: " << e.what() << "\n";
}

2. std::get_if：安全地获取指针（如果类型不匹配返回 nullptr）

if (auto p = std::get_if<int>(&v)) {
    std::cout << "Got int: " << *p << "\n";
} else {
    std::cout << "Not storing int\n";
}

3. std::holds_alternative：检查是否存储特定类型

if (std::holds_alternative<double>(v)) {
    std::cout << "Storing a double\n";
}

4. std::visit：使用访问者模式处理所有可能类型

struct Visitor {
    void operator()(int i) { std::cout << "int: " << i << "\n"; }
    void operator()(double d) { std::cout << "double: " << d << "\n"; }
    void operator()(const std::string& s) { std::cout << "string: " << s << "\n"; }
};

std::visit(Visitor{}, v); // 根据当前存储的类型调用相应的 operator()

实际应用案例[编辑 | 编辑源代码]

配置系统[编辑 | 编辑源代码]

在配置系统中，一个配置项可能是多种类型之一：

struct ConfigItem {
    std::string name;
    std::variant<int, bool, std::string> value;
};

void printConfig(const ConfigItem& item) {
    std::cout << item.name << ": ";
    std::visit([](auto&& arg) {
        std::cout << arg;
    }, item.value);
    std::cout << "\n";
}

int main() {
    ConfigItem items[] = {
        {"Timeout", 30},
        {"DebugMode", true},
        {"Username", "admin"}
    };

    for (const auto& item : items) {
        printConfig(item);
    }
    return 0;
}

输出:

Timeout: 30
DebugMode: 1
Username: admin

解析JSON或XML[编辑 | 编辑源代码]

在处理JSON或XML数据时，一个节点值可能是多种类型：

using JsonValue = std::variant<std::nullptr_t, bool, int, double, std::string>;

void processJsonValue(const JsonValue& value) {
    std::visit([](auto&& arg) {
        using T = std::decay_t<decltype(arg)>;
        if constexpr (std::is_same_v<T, std::nullptr_t>) {
            std::cout << "null";
        } else if constexpr (std::is_same_v<T, bool>) {
            std::cout << (arg ? "true" : "false");
        } else {
            std::cout << arg;
        }
    }, value);
}