std::variant 类型擦除原理
面试考点
std::variant 是 C++17 的类型安全联合体。面试官通过这道题考察你是否理解 variant 的内部实现:它用 tagged union 存储值、用索引标记当前激活的类型、以及 std::visit 的分发机制。
核心概念
std::variant<Types...> 内部是一个 union(能存放任意一个 Types 类型的值)加一个整数索引(记录当前是哪个类型)。它不做堆分配,大小等于最大类型的大小加上索引和对齐的开销。std::visit 通过跳转表(函数指针数组)实现对当前类型的访问。
基本示例
#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 状态。