std::variant 类型擦除原理 ​

面试考点 ​

std::variant 是 C++17 的类型安全联合体。面试官通过这道题考察你是否理解 variant 的内部实现:它用 tagged union 存储值、用索引标记当前激活的类型、以及 std::visit 的分发机制。

核心概念 ​

std::variant<Types...> 内部是一个 union(能存放任意一个 Types 类型的值)加一个整数索引(记录当前是哪个类型)。它不做堆分配,大小等于最大类型的大小加上索引和对齐的开销。std::visit 通过跳转表(函数指针数组)实现对当前类型的访问。

基本示例 ​

cpp
#include <iostream>
#include <variant>
#include <string>
#include <vector>
#include <type_traits>

// ============================
// 示例1:variant 的基本用法和大小
// ============================

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

    // 默认构造第一个类型(int)
    std::cout << "默认 index: " << v.index() << std::endl;  // 0

    v = 42;
    std::cout << "int 值: " << std::get<int>(v) << std::endl;

    v = 3.14;
    std::cout << "double 值: " << std::get<double>(v) << std::endl;

    v = std::string("Hello");
    std::cout << "string 值: " << std::get<std::string>(v) << std::endl;

    // 大小分析
    std::cout << "\nsizeof(int) = " << sizeof(int) << std::endl;
    std::cout << "sizeof(double) = " << sizeof(double) << std::endl;
    std::cout << "sizeof(string) = " << sizeof(std::string) << std::endl;
    std::cout << "sizeof(variant<int,double,string>) = "
              << sizeof(std::variant<int, double, std::string>) << std::endl;
    // variant 大小 = max(sizeof(Types...)) + sizeof(index) + padding
}

// ============================
// 示例2:简化版 variant 实现
// ============================

// 辅助:递归 union 存储
template<typename... Ts>
union VariadicUnion {};

// 递归终止
template<typename T>
union VariadicUnion<T> {
    T value;
    VariadicUnion() {}
    ~VariadicUnion() {}
};

// 递归展开:第一个类型 + 其余类型
template<typename T, typename... Rest>
union VariadicUnion<T, Rest...> {
    T value;                      // 当前类型
    VariadicUnion<Rest...> rest;  // 剩余类型

    VariadicUnion() {}
    ~VariadicUnion() {}
};

// 简化版 variant
template<typename... Types>
class SimpleVariant {
    VariadicUnion<Types...> storage_;  // union 存储
    std::size_t index_;                 // 当前激活类型的索引

public:
    SimpleVariant() : index_(0) {
        // 默认构造第一个类型
    }

    std::size_t index() const { return index_; }

    // 为了简化,这里只展示核心布局思路
    // 实际实现需要处理构造、析构、拷贝、移动等
};

void simple_variant_demo() {
    std::cout << "sizeof(SimpleVariant<int, double>) = "
              << sizeof(SimpleVariant<int, double>) << std::endl;
    std::cout << "sizeof(SimpleVariant<char, int, double>) = "
              << sizeof(SimpleVariant<char, int, double>) << std::endl;
}

// ============================
// 示例3:std::visit 的分发机制
// ============================

/*
std::visit 的实现核心是一个函数指针跳转表:

// 伪代码
template<typename Visitor, typename Variant>
auto visit(Visitor&& vis, Variant&& var) {
    // 编译期生成函数指针数组
    using FuncPtr = ReturnType(*)(Visitor&&, Variant&&);
    static constexpr FuncPtr table[] = {
        [](Visitor&& v, Variant&& var) { return v(get<0>(var)); },
        [](Visitor&& v, Variant&& var) { return v(get<1>(var)); },
        [](Visitor&& v, Variant&& var) { return v(get<2>(var)); },
        // ...每个类型一个函数指针
    };

    // 运行时根据 index 跳转
    return table[var.index()](std::forward<Visitor>(vis),
                               std::forward<Variant>(var));
}
*/

// overloaded 模式(常用技巧)
template<class... Ts>
struct overloaded : Ts... { using Ts::operator()...; };
// C++17 推导指引
template<class... Ts>
overloaded(Ts...) -> overloaded<Ts...>;

void visit_demo() {
    std::variant<int, double, std::string> v = std::string("World");

    // 用 overloaded 组合多个 lambda
    std::visit(overloaded{
        [](int i)                { std::cout << "int: " << i << std::endl; },
        [](double d)             { std::cout << "double: " << d << std::endl; },
        [](const std::string& s) { std::cout << "string: " << s << std::endl; }
    }, v);
}

// ============================
// 示例4:variant 实现运行时多态
// ============================

// 传统虚函数方式
class ShapeBase {
public:
    virtual double area() const = 0;
    virtual ~ShapeBase() = default;
};

class VCircle : public ShapeBase {
    double r_;
public:
    VCircle(double r) : r_(r) {}
    double area() const override { return 3.14159 * r_ * r_; }
};

class VRect : public ShapeBase {
    double w_, h_;
public:
    VRect(double w, double h) : w_(w), h_(h) {}
    double area() const override { return w_ * h_; }
};

// variant 方式(无虚函数,值语义)
struct Circle { double r; };
struct Rect { double w, h; };

using Shape = std::variant<Circle, Rect>;

double area(const Shape& s) {
    return std::visit(overloaded{
        [](const Circle& c) { return 3.14159 * c.r * c.r; },
        [](const Rect& r)   { return r.w * r.h; }
    }, s);
}

void polymorphism_demo() {
    // variant 方式:值语义,无堆分配,缓存友好
    std::vector<Shape> shapes;
    shapes.push_back(Circle{5.0});
    shapes.push_back(Rect{3.0, 4.0});
    shapes.push_back(Circle{2.0});

    for (const auto& s : shapes) {
        std::cout << "面积: " << area(s) << std::endl;
    }

    // 对比:虚函数方式需要指针和堆分配
    // std::vector<std::unique_ptr<ShapeBase>> shapes_v;
}

// ============================
// 示例5:valueless_by_exception 状态
// ============================

void valueless_demo() {
    /*
    variant 在极端情况下可能进入 valueless_by_exception 状态:
    当赋值或 emplace 过程中,新类型的构造函数抛出异常,
    而旧值已经被销毁,variant 就变成"没有任何值"的状态。

    struct ThrowOnCopy {
        ThrowOnCopy() = default;
        ThrowOnCopy(const ThrowOnCopy&) { throw std::runtime_error("!"); }
    };

    std::variant<int, ThrowOnCopy> v = 42;
    try {
        v = ThrowOnCopy{};  // 构造抛异常
    } catch (...) {
        // v 可能进入 valueless_by_exception 状态
        // v.valueless_by_exception() == true
        // v.index() == std::variant_npos
    }
    */
    std::cout << "variant_npos = " << std::variant_npos << std::endl;
}

int main() {
    std::cout << "=== 基本用法 ===" << std::endl;
    basic_demo();

    std::cout << "\n=== 简化实现 ===" << std::endl;
    simple_variant_demo();

    std::cout << "\n=== visit 分发 ===" << std::endl;
    visit_demo();

    std::cout << "\n=== variant 多态 ===" << std::endl;
    polymorphism_demo();

    std::cout << "\n=== valueless 状态 ===" << std::endl;
    valueless_demo();

    return 0;
}

variant vs 虚函数多态 ​

特性std::variant虚函数
内存分配栈上,无堆分配通常需要堆分配(new)
值语义值类型,可拷贝指针/引用语义
类型集合封闭的(编译期确定)开放的(可以添加新派生类)
缓存友好好(连续存储)差(指针跳转)
添加新类型需要修改 variant 定义只需添加新派生类
添加新操作只需添加新 visitor需要修改所有派生类

常见问题 ​

variant 的 visit 是怎么实现的?

编译期生成一个函数指针数组(跳转表),每个函数对应一个类型的处理逻辑。运行时根据 variant 的 index 查表跳转。这比虚函数的间接调用在某些情况下更快,因为跳转表是连续的,对缓存更友好。

什么是 valueless_by_exception?

当 variant 在类型切换过程中,新类型的构造抛出异常,而旧值已经被销毁时,variant 进入"无值"状态。这时 index() 返回 variant_npos,任何 get 操作都会抛异常。这种状态在实践中很少见。

variant 和 union 有什么区别?

union 不跟踪当前激活的成员,访问非激活成员是未定义行为。variant 用索引跟踪当前类型,提供类型安全的访问。variant 还自动处理构造和析构。

适用场景 ​

  • 类型集合固定且较小的多态场景
  • 需要值语义的异构容器
  • 状态机(每个状态是不同类型)
  • 替代传统的 tagged union

注意事项 ​

  • variant 不能存放引用类型和 void
  • 第一个类型必须有默认构造函数(否则用 std::monostate 占位)
  • variant 的大小是最大类型的大小加上索引开销
  • std::visit 对多个 variant 的笛卡尔积分发,类型多时编译会变慢
  • C++26 新增了成员 visit 函数

总结 ​

std::variant 是类型安全的 tagged union,内部用递归 union 存储值、用整数索引标记当前类型。不做堆分配,大小等于最大类型加上索引和对齐开销。std::visit 通过编译期生成的函数指针跳转表实现类型分发。面试中要能解释 variant 的内存布局、visit 的跳转表机制、和虚函数多态的区别(封闭类型集 vs 开放类型集),以及 valueless_by_exception 状态。