在 C++17 标准中，std::variant 和 std::any 都被引入为“类型安全的联合体”，但它们在设计哲学、使用场景以及性能特征上存在显著差异。本文将从概念、语义、实现细节、典型使用场景以及性能评估等角度，对这两个容器进行系统的比较，并给出实践中的最佳使用建议。
一、基本概念
1. std::variant
- 定义：一个类型安全的离散型联合体，只能保存 有限且已知类型列表 中的 一种。
- 模板参数：
template<class... Types> class variant;，Types...必须是不同且可拷贝/移动的类型。 - 运行时值：内部维护一个 索引（
index()）指示当前存储的是哪一种类型。 - 使用方法：`std::get (v)`、`std::visit(visitor, v)` 等。
2. std::any
- 定义：一个类型安全的 通用容器，可以保存 任意类型（但必须是完整类型，非引用）。
- 模板参数：无模板参数，内部通过
std::type_index保存类型信息。 - 运行时值：使用 虚函数表（RTTI）实现拷贝/移动，内部存储对象的 复制。
- 使用方法：`std::any_cast (a)`，若类型不匹配抛出异常或返回 `nullptr`。
二、语义对比
| 特性 | std::variant | std::any |
|---|---|---|
| 类型约束 | 预先声明固定类型集合 | 任意类型 |
| 是否可以存放空值 | 可通过 std::monostate 或 std::optional 组合实现 |
通过空构造函数即可 |
| 访问方式 | `std::get | |
、std::visit（多态访问） |std::any_cast`（单一访问） |
||
| 异常安全 | 访问错误抛 std::bad_variant_access |
访问错误抛 std::bad_any_cast |
| 实现复杂度 | 需要存储索引、使用联合体 | 需要 RTTI 或自定义虚函数表 |
| 性能 | O(1) 访问 + 编译时分支 | O(1) 访问 + 动态类型信息查找 |
| 内存占用 | 取决于最大类型的大小 | 取决于动态分配，通常更大 |
三、实现细节
1. std::variant 内部实现（简化）
template<class... Ts>
class variant {
union storage_t {
alignas(alignof(std::max_align_t)) char buffer[sizeof(max <Ts>())];
storage_t() noexcept {}
} storage_;
std::size_t idx_ = variant_npos;
template<class T, std::size_t I>
void destroy() {
reinterpret_cast<T*>(&storage_)->~T();
idx_ = variant_npos;
}
// 构造、析构、移动/拷贝实现使用辅助模板
};- 使用 联合体 与 对齐 结合，避免额外内存开销。
index()返回当前类型索引。visit通过std::visit的折叠表达式实现多态访问。
2. std::any 内部实现（简化）
class any {
struct placeholder {
virtual ~placeholder() = default;
virtual placeholder* clone() const = 0;
virtual std::type_index type() const = 0;
};
template<class T>
struct holder : placeholder {
T value;
placeholder* clone() const override { return new holder <T>{value}; }
std::type_index type() const override { return typeid(T); }
};
placeholder* content_ = nullptr;
public:
template<class T>
any(T&& value) : content_(new holder<std::decay_t<T>>(std::forward<T>(value))) {}
// 复制/移动、析构等
};- 使用 虚函数 通过
placeholder实现类型擦除。 any_cast通过typeid对比实现类型检查。
四、典型使用场景
1. std::variant 适用场景
- 有限且已知的类型集合：如解析 JSON、实现多态命令模式、存储多种配置参数。
- 需要高性能且确定的分支：
std::visit可以在编译期生成最优调用链。 - 编译时可预测的行为：适合需要在编译时进行模式匹配的情况。
示例：实现一个简单的命令行参数解析器
using Arg = std::variant<std::monostate, int, double, std::string>;
void parse(const std::string& token, Arg& out) {
if (auto pos = token.find('='); pos != std::string::npos) {
std::string val = token.substr(pos+1);
if (auto dot = val.find('.'); dot != std::string::npos)
out = std::stod(val); // double
else
out = std::stoi(val); // int
} else {
out = token; // string
}
}2. std::any 适用场景
- 需要存储任意未知类型：如插件系统、事件总线、通用属性表。
- 动态类型不确定：在运行时才知道需要存放什么类型。
- 不想显式维护类型列表：代码可读性高，类型信息由 RTTI 维护。
示例：实现一个简单的事件系统
class EventDispatcher {
std::unordered_map<std::string, std::vector<std::function<void(const std::any&)>>> handlers;
public:
template<class T>
void subscribe(const std::string& name, std::function<void(const T&)> fn) {
handlers[name].push_back([fn = std::move(fn)](const std::any& a) {
if (auto p = std::any_cast <T>(&a))
fn(*p);
});
}
template<class T>
void publish(const std::string& name, T&& data) {
std::any a = std::forward <T>(data);
for (auto& f : handlers[name]) f(a);
}
};五、性能评估
1. 访问速度
variant：访问仅需检查索引（编译时已知）并直接解引用，性能优于any。any：需要运行时的 RTTI 比对与虚函数调用，导致略微开销。
2. 内存占用
variant：内存占用等于最大类型的大小 + 对齐。any：除了对象本身外，还需要额外的 类型信息 与 虚函数表指针，以及可能的 动态分配。
3. 编译器优化
variant的visit可以在编译期产生 多态跳转表，使得每个分支都能被内联。any的any_cast由于是运行时分支，往往无法被完全内联。
六、最佳实践与常见坑
- 避免 variant 中出现不可复制/移动的类型，否则
std::visit会报错。 - 不要在 variant 中存放大对象，因为它会被放入内存池，导致堆栈压力。
- **使用 std::optional 组合存放空值**，更符合语义。
- std::any_cast 的返回类型：如果想避免异常，使用 `any_cast (&a)`。
- 使用
std::monostate表示空状态，能与variant的index()一起使用。
七、结论
- 当你 知道 需要存放的类型集合，且类型数量有限时，优先选择 std::variant：它提供了更好的类型安全、更低的内存占用以及更快的访问速度。
- 当你需要一个 完全动态、通用的容器，且类型在运行时才确定，或者你需要把对象存放在通用容器中传递时，std::any 是更合适的选择。
两者各有千秋，理解它们的语义与实现机制能帮助你在实际项目中更好地选择合适的工具，提升代码质量与运行效率。