C++ std::variant 为什么比传统 union 更类型安全

问题源头：传统 union 的“裸”内存共享

传统 C 风格的 union 让你在同一个内存位置存储不同类型的数据，但不提供任何类型跟踪机制。写入一个成员后，读取另一个未被初始化的成员，会触发未定义行为（UB）。编译器无法检测这类错误，只能靠程序员手动记住“当前哪个类型是活跃的”。

union Value {
    int i;
    float f;
    const char* s;
};

Value v;
v.i = 42;
// 忘记自己存的是 int，错误地读取 f —— 未定义行为
std::cout << v.f;  // 输出垃圾值，可能崩溃

传统 union 的核心缺陷：类型安全完全依赖程序员的自律，而人总会犯错。

std::variant 的解决方案：编译期类型追踪与运行时检查

std::variant（C++17 引入）是带标记的联合体（tagged union）。它在内部存储一个鉴别器（discriminator），记录当前存放的是哪一个可选类型。所有对 variant 的访问操作都强制检查这个鉴别器，从而杜绝未定义行为。

#include <variant>
#include <iostream>

std::variant<int, float, const char*> v;
v = 42;                     // 存储 int
// v = 3.14f;               // 切换为 float

// 安全访问：必须通过 std::get 或 std::get_if
try {
    int val = std::get<int>(v);  // 正确：当前类型是 int
    std::cout << val;
} catch (const std::bad_variant_access& e) {
    std::cerr << "类型不匹配: " << e.what();
}

如果当前类型不是 int，std::get<int>(v) 会抛出 std::bad_variant_access 异常，或者在 std::get_if 返回空指针。异常或空指针都是可预测的行为，而不是 UB。

类型安全的三个维度

1. 初始化时强制指定类型

传统 union 在声明后，所有成员都处于未初始化状态，读取任何成员都是 UB。std::variant 在构造时自动初始化第一个类型的默认值（或你指定的值）。你无法创造一个“无类型”的 variant。

// 传统 union：未初始化
union U { int x; double y; };
U u;                 // u.x 和 u.y 都是未初始化的垃圾

// std::variant：自动初始化第一个类型
std::variant<int, double> v;   // v 持有 int(0)

2. 访问必须配对类型

所有对 variant 内容的读取操作都要求你显式指定期望的类型，并且运行时校验一致性。这强制你每次访问前思考“当前到底是什么类型”。相比之下，传统 union 允许你直接用任一个成员名去读，编译器不会阻止。

3. 切换类型时自动构造/析构

传统 union 需要手动调用构造函数和析构函数来管理复杂类型（如 std::string），否则会内存泄漏或重复析构。std::variant 在赋值新类型时，自动销毁旧对象并在原位构造新对象，避免资源泄漏。

// 传统 union 无法安全包含非平凡类型
union Bad {
    std::string s;
    int i;
    // 必须手动管理生命周期，极易出错
};

// std::variant 自动管理
std::variant<std::string, int> v;
v = std::string("hello"); // 构造 string
v = 42;                   // 自动析构 string，构造 int

对比表格：具体差异一针见血

使用 std::visit 实现“模式匹配”风格

std::visit 是访问 variant 最强大、最安全的方式。它一次性处理所有可能类型，如果某个类型未被处理，编译器会发出警告或错误（取决于参数）。

std::visit([](auto&& arg) {
    using T = std::decay_t<decltype(arg)>;
    if constexpr (std::is_same_v<T, int>)
        std::cout << "整数: " << arg;
    else if constexpr (std::is_same_v<T, float>)
        std::cout << "浮点数: " << arg;
    else if constexpr (std::is_same_v<T, const char*>)
        std::cout << "字符串: " << arg;
}, v);

这种方式强制你覆盖所有 case，漏掉一个类型代码将编译失败（如果 if constexpr 分支未覆盖，则访问该类型时不会调用任何代码——但至少不会出现 UB）。在实际工程中，更推荐为每种类型提供明确的响应。

运行时 vs 编译时开销

std::variant 的类型安全是有微小代价的：

• 运行时鉴别：每次 get 或 get_if 都会检查 index()，但通常是一条 cmp 指令和条件跳转，开销极低。
• 存储空间：variant 的大小等于最大成员的大小 + 鉴别器对齐后的空间。通常比传统 union 多出几个字节（用于存储索引），但不超过 sizeof(uintptr_t)。
• 编译器优化：在大量 visit 中，现代编译器能够将多个分支合并为跳转表，性能接近手写的 switch。

相比之下，传统 union 虽然零额外空间和运行时检查，但你为“安全”付出的代价是在调试上——UB 可能几小时后才崩溃，甚至静默产生错误结果，排查成本远高于那点 CPU 周期。

什么时候仍然需要用传统 union？

std::variant 几乎在所有场景下都是替代传统 union 的更优选择。唯一需要保留传统 union 的情况是：

• 与 C 语言 ABI 交互（如解析网络协议、嵌入式寄存器映射）
• 极低内存约束的嵌入式系统，无法容忍额外几个字节的鉴别器
• 需要位域或完全自定义内存布局时

除此之外，默认选择 std::variant，让编译器帮你检查类型错误，把精力放在业务逻辑上。