2.2、std::variant

什么是 std::variant？为什么它值得深入学习？

std::variant，通俗来说，就是一个“类型安全的联合体”。它允许你在一个变量里存储多种不同类型中的一种，并且它始终知道自己当前存储的是哪种类型。这解决了传统union的两大痛点：

• • 类型不安全：union无法自动跟踪当前存储的类型，容易导致访问错误。
• • 限制多：union不能存放有非平凡构造函数或析构函数的类型。

而std::variant则将这些问题一网打尽，提供了编译时类型安全、运行时高效访问的现代解决方案。

设计哲学

std::variant的设计哲学可以归纳为：

• • 类型安全优先：任何时候都知道当前存储的类型，避免类型错误。
• • 零动态分配：所有数据都在variant内部存储，不额外申请堆内存。
• • 多态替代：不依赖继承和虚函数，避免运行时开销，支持“静态多态”。
• • 灵活性与确定性平衡：支持多种类型选择，但任何时刻只存储一种，避免“选择过多导致困惑”。

std::variant的基本用法

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

int main() {
    std::variant<int, double, std::string> v;  // 可以存int、double或string

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

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

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

    return 0;
}

这里，std::get<T>(v)是访问当前存储类型的值的方式，如果类型不匹配，会抛出异常std::bad_variant_access，保证类型安全。

深入底层：std::variant是如何实现的？

std::variant的核心实现，主要靠两部分：

递归联合体存储结构

std::variant内部用一个递归的union结构存储所有可能类型的值。比如std::variant<int, double>，内部大致是：

union _Variadic_union {
    int _M_first;
    union {
        double _M_first;
    } _M_rest;
};

这样递归定义，确保只占用最大类型的内存空间。

类型索引管理

通过一个整数索引_M_index来标记当前存储的是第几个类型（从0开始）。访问时根据索引递归访问对应的联合体成员。

赋值和访问时，std::variant会通过模板元编程计算类型索引，结合运行时索引，来安全高效地管理值的构造和析构。

进阶案例：用 std::variant 实现一个多类型计算器

假设我们想写一个简单的计算器，它能接受int、double和std::string（代表数字字符串），根据类型执行不同的加法操作。

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

// 定义variant类型
using VarType = std::variant<int, double, std::string>;

// 访问器，处理不同类型的加法
struct Adder {
    VarType operator()(int a, int b) const {
        return a + b;
    }
    VarType operator()(int a, double b) const {
        return a + b;
    }
    VarType operator()(double a, int b) const {
        return a + b;
    }
    VarType operator()(double a, double b) const {
        return a + b;
    }
    VarType operator()(const std::string& a, const std::string& b) const {
        // 字符串转double后加法
        double da = std::stod(a);
        double db = std::stod(b);
        return da + db;
    }
    VarType operator()(int a, const std::string& b) const {
        return a + std::stod(b);
    }
    VarType operator()(const std::string& a, int b) const {
        return std::stod(a) + b;
    }
    VarType operator()(double a, const std::string& b) const {
        return a + std::stod(b);
    }
    VarType operator()(const std::string& a, double b) const {
        return std::stod(a) + b;
    }
};

// 计算函数，利用 std::visit 访问 variant 内部值
VarType add(const VarType& lhs, const VarType& rhs) {
    return std::visit(Adder{}, lhs, rhs);
}

int main() {
    VarType v1 = 10;
    VarType v2 = "20.5";

    VarType result = add(v1, v2);

    std::visit([](auto&& val) {
        std::cout << "Result: " << val << "\n";
    }, result);

    return 0;
}

代码解析

• • std::variant存储多种类型，std::visit是访问多种类型的“万能钥匙”，它接受一个重载的函数对象（这里是Adder）和一个或多个variant，自动根据当前存储类型调用对应的重载。
• • Adder结构体重载了多种组合的operator()，实现了类型安全的加法逻辑。
• • 这种设计避免了大量的类型判断和强制转换，代码简洁且安全。

底层细节

• • std::visit通过模板递归展开，编译时生成针对所有类型组合的调用代码，运行时根据variant的索引调度到正确的函数。
• • 访问时不会进行动态类型转换，性能接近虚函数调用，但无虚表开销。

常见错误及陷阱

1. 1. 错误访问类型
   使用std::get<T>访问variant时，如果当前存储的不是T，会抛std::bad_variant_access异常。正确做法是先用std::holds_alternative<T>(v)判断类型。
2. 2. 默认构造问题
   std::variant默认构造会调用第一个类型的默认构造函数。如果第一个类型没有默认构造，会导致编译错误。解决方案是将std::monostate放在第一个位置，表示空状态。
3. 3. 不支持引用、数组和void类型
   std::variant不能存储引用类型、数组类型或void，否则编译失败。
4. 4. 赋值隐式转换可能导致意外类型匹配
   赋值时，variant会选择最匹配的类型，可能导致意想不到的类型被选中。建议显式使用std::in_place_type或std::in_place_index构造。

面试中可能遇到的问题

1. 1. std::variant和union的区别？
   答：std::variant是类型安全的联合体，知道当前存储的类型；union不安全且不能存储复杂类型。
2. 2. std::visit的作用和原理？
   答：std::visit是访问variant中当前值的通用工具，利用模板展开和索引调度实现多态访问。
3. 3. 如何避免访问variant时异常？
   答：使用std::holds_alternative检查类型，或者使用std::get_if安全访问。
4. 4. std::variant内部如何存储多种类型？
   答：通过递归联合体存储最大类型大小的内存，结合类型索引标识当前存储的类型。

总结

std::variant是C++17引入的革命性类型安全联合体，结合了类型安全、无堆内存分配、灵活多态访问的优点。它的底层设计巧妙，利用递归联合体和类型索引实现高效存储和访问。通过std::visit，我们可以优雅地实现多类型分支逻辑，避免了传统多态的复杂继承体系。