C++17 中 std::variant 的实战应用

在 C++17 标准中，std::variant 被引入作为一种类型安全的和类型擦除（type-erasure）相对较轻的容器，类似于 std::any 但具有更严格的类型检查。它可以用来代替传统的 union 或者使用 void* 进行类型不安全的存储。本文将从概念、基本使用、常见问题以及实际案例四个方面，系统地介绍如何在项目中合理地使用 std::variant。

一、概念与优势

类型安全：编译器在编译时就知道 variant 可能持有的类型，使用 `get ` 或 `std::get_if` 时若类型不匹配会产生编译错误或返回空指针。
值语义：与 std::any 一样，variant 存储的是值而不是引用，避免了悬空指针问题。
访问成本低：std::variant 内部采用标签/联合结构，访问时只需一次索引检查，开销极低。
兼容性：可以与 std::visit、std::holds_alternative 等工具配合使用，实现多态行为。

二、基本使用

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

int main() {
    std::variant<int, std::string> v = 10;          // 通过整型初始化
    std::cout << std::get<int>(v) << std::endl;    // 输出 10

    v = std::string("Hello, variant!");            // 换成字符串
    std::cout << std::get<std::string>(v) << std::endl; // 输出字符串

    // 使用 std::holds_alternative 判断类型
    if (std::holds_alternative <int>(v)) {
        std::cout << "是整型" << std::endl;
    } else if (std::holds_alternative<std::string>(v)) {
        std::cout << "是字符串" << std::endl;
    }

    // 使用 visit 访问值
    std::visit([](auto&& arg){ std::cout << arg << std::endl; }, v);
}

1. `get` 与 `get_if`

`std::get ` 若 `v` 并不持有类型 `T`，会抛出 `std::bad_variant_access` 异常。
`std::get_if (&v)` 若不匹配返回 `nullptr`，安全更友好。

2. 默认值

如果你不想抛异常，可以使用 std::get_or（C++23）或自己实现：

template<class T, class... Ts>
constexpr const T& get_or(const std::variant<Ts...>& v, const T& default_val) {
    if (std::holds_alternative <T>(v))
        return std::get <T>(v);
    return default_val;
}

三、常见问题与解决方案

问题	说明	解决方案
多次转换导致不必要的复制	频繁使用 `std::get` 可能导致拷贝开销。	采用 `std::get_if` 或 `std::visit`，或使用引用 `std::get
(v)` 并保持引用。
类型顺序导致性能差异	`variant` 的内部布局依赖类型顺序，放大对象可能占用更多空间。	将占用空间较大的类型放在后面，或使用 `std::aligned_union_t` 进行手动控制。
与 `std::vector` 配合使用时的默认构造	`std::variant` 必须有默认可构造的类型，否则在容器中扩容会报错。	为所有可能类型提供默认构造，或者使用 `std::optional<std::variant<...>>`。
多继承与 variant	`std::variant` 只能存储 POD 或具有完整类型的对象。	使用 `std::shared_ptr
`包装多态对象，或使用`std::variant<std::shared_ptr, int>`。

四、实战案例：日志系统的多种记录类型

在一个高性能日志系统中，我们需要记录不同类型的日志条目：文本、数值、错误对象等。传统做法是使用继承或联合结构，但维护成本高。下面展示如何利用 std::variant 简化设计。

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

struct ErrorInfo {
    int code;
    std::string message;
};

using LogContent = std::variant<std::string, int, ErrorInfo>;

struct LogEntry {
    std::chrono::system_clock::time_point timestamp;
    std::string level; // "INFO", "WARN", "ERROR"
    LogContent content;
};

void printLog(const LogEntry& entry) {
    std::cout << std::chrono::system_clock::to_time_t(entry.timestamp) << " [" << entry.level << "] ";
    std::visit([](auto&& arg){
        using T = std::decay_t<decltype(arg)>;
        if constexpr (std::is_same_v<T, std::string>) {
            std::cout << arg;
        } else if constexpr (std::is_same_v<T, int>) {
            std::cout << arg;
        } else if constexpr (std::is_same_v<T, ErrorInfo>) {
            std::cout << "Error " << arg.code << ": " << arg.message;
        }
    }, entry.content);
    std::cout << std::endl;
}

int main() {
    LogEntry e1{std::chrono::system_clock::now(), "INFO", std::string("启动完成")};
    LogEntry e2{std::chrono::system_clock::now(), "WARN", 42};
    LogEntry e3{std::chrono::system_clock::now(), "ERROR", ErrorInfo{404, "未找到资源"}};

    printLog(e1);
    printLog(e2);
    printLog(e3);
}

优点：

统一接口：所有日志条目共享相同结构，无需 RTTI 或虚函数。
高效存储：variant 仅占用一次标签 + 最大子类型大小，空间控制可预测。
可扩展：只需在 LogContent 中添加新类型即可，无需修改访问代码。

五、与 C++20 模板化 `std::visit`

C++20 引入了“通用 lambda”与“模板化 std::visit”，使 variant 的使用更灵活：

std::visit([](auto&& arg){ /*...*/ }, variant);

该 lambda 的参数是通用引用，允许你对 int、std::string 等类型做相同处理或专门处理。你还可以利用 if constexpr 进行类型判定，进一步减少代码重复。

六、性能小贴士

避免频繁拷贝：使用 std::get_if 获取指针，直接操作而不复制。
缓存 variant：在高频循环中，把 variant 对象存入栈而不是堆，减少分配成本。
对齐：如果你使用的是多字节对齐的自定义类型，考虑使用 alignas 或 std::aligned_union_t 进行手动对齐，避免内部 padding 产生空间浪费。

七、总结

std::variant 是 C++17 之后的一项强大工具，它在保证类型安全的前提下，提供了与 std::any 相似的灵活性，但又不失值语义与性能。通过熟练掌握 variant 的基本操作、访问方式以及 std::visit 的模式，可以显著简化代码结构、提高可维护性，并在性能敏感的场景中获得显著收益。希望本文能帮助你在项目中更好地利用 std::variant，让代码更优雅、可靠。

一、概念与优势

二、基本使用

1. get 与 get_if