**C++17 标准库：std::variant 与 std::any 的差异与实际应用**

作者

在 C++17 中，引入了两个强大的类型安全容器：std::variant 和 std::any。它们都能在运行时保存不同类型的值，但在设计理念、使用方式以及性能特性上有显著区别。本文从概念、使用场景、实现细节以及常见坑点四个维度，对这两个类型进行系统对比，并给出实际编码示例，帮助开发者在项目中做出更合适的选择。

1. 基本概念对比

特性 std::variant std::any
设计目标 组合类型（sum type） 任意类型（type erasure）
类型安全 编译时知道所有候选类型 运行时类型检查
内存布局 只存放最大占用的成员 + index 动态分配，基于 typeid
访问方式 `std::get
()、std::visit|std::any_cast()`
可复制性 需要所有候选类型可复制 需要内部对象可复制或移动
典型用例 状态机、事件系统 配置存储、跨模块通信

2. 典型使用场景

2.1 std::variant

  • 有限枚举：将几种可能的值组合成一个单一类型，如 std::variant<int, std::string, double>。
  • 状态机：状态对象仅在有限的类型集合中切换，例如解析器的不同解析状态。
  • 模式匹配：通过 std::visit 统一处理不同类型的逻辑，减少 if constexpr 或 dynamic_cast 的使用。
using ConfigValue = std::variant<int, double, std::string>;

ConfigValue cfg = 42;          // int
cfg = std::string("hello");    // std::string
std::visit([](auto&& v){ std::cout << v << '\n'; }, cfg);

2.2 std::any

  • 插件系统：需要在不同插件间传递任意类型的数据。
  • 键值对存储：实现通用配置表、属性系统，键对应任意类型值。
  • 消息传递：在消息队列中携带多种类型的 payload。
std::any payload = std::make_shared<std::vector<int>>(std::initializer_list<int>{1,2,3});

try {
    auto vec = std::any_cast<std::shared_ptr<std::vector<int>>>(payload);
    std::cout << "size: " << vec->size() << '\n';
} catch(const std::bad_any_cast& e) {
    std::cerr << "type mismatch\n";
}

3. 性能与实现细节

3.1 内存占用

  • std::variant 的内存布局类似 union，只有一次内存分配，且大小为最大成员类型 + std::size_t 用于存储 index。
  • std::any 在内部使用 type erasure，通常包含指针、大小、对齐以及类型信息。其内存开销远高于 variant，且每次赋值会触发 heap 分配。

3.2 复制与移动

  • variant 的复制构造与移动构造取决于各候选类型是否可复制/可移动。若所有候选类型都支持移动，则 variant 默认采用移动语义。
  • any 的复制与移动都涉及 type erasure 的实现，默认使用 typeid 的 copy 与 move 处理，若对象没有这些功能会导致运行时错误。

3.3 访问方式

  • variant 的访问是安全的： `std::get (v)` 若 `T` 与当前值不匹配则抛出 `std::bad_variant_access`。
  • any 的访问是类型擦除后恢复类型，若类型不匹配则抛出 std::bad_any_cast。

4. 常见坑点与最佳实践

场景 问题 解决方案
选取 variant 时出现 bad_variant_access 未正确检查当前类型 使用 `std::holds_alternative
或std::visit`
any_cast 性能低 频繁分配、复制 仅在必要时使用 any_cast，考虑使用 std::any_view（C++23）
variant 大小过大 其中一个成员非常大 采用 std::unique_ptr 包装大对象
any 失效 对象已被销毁 保证引用计数或使用智能指针

建议

  • 当你已经知道所有可能的类型集合且不需要频繁扩展时，优先使用 std::variant。
  • 当你需要真正通用的、动态的类型容器，且无法提前枚举所有类型时，使用 std::any。
  • 对性能敏感的代码路径，尽量避免使用 std::any，考虑使用自定义结构或模板化的方案。

5. 代码示例：事件系统

下面给出一个简单的事件系统实现，分别使用 variant 和 any 两种方案，展示两者的优缺点。

#include <iostream>
#include <variant>
#include <any>
#include <vector>
#include <string>

// --------- Variant 版本 ----------
struct MouseEvent {
    int x, y;
};

struct KeyEvent {
    char key;
};

using Event = std::variant<MouseEvent, KeyEvent>;

void handleEvent(const Event& e) {
    std::visit([](auto&& evt){
        using T = std::decay_t<decltype(evt)>;
        if constexpr (std::is_same_v<T, MouseEvent>) {
            std::cout << "Mouse at (" << evt.x << "," << evt.y << ")\n";
        } else if constexpr (std::is_same_v<T, KeyEvent>) {
            std::cout << "Key pressed: " << evt.key << '\n';
        }
    }, e);
}

// --------- Any 版本 ----------
using AnyEvent = std::any;

void handleAnyEvent(const AnyEvent& e) {
    if (e.type() == typeid(MouseEvent)) {
        const MouseEvent& me = std::any_cast<const MouseEvent&>(e);
        std::cout << "Any: Mouse at (" << me.x << "," << me.y << ")\n";
    } else if (e.type() == typeid(KeyEvent)) {
        const KeyEvent& ke = std::any_cast<const KeyEvent&>(e);
        std::cout << "Any: Key pressed: " << ke.key << '\n';
    } else {
        std::cout << "Unknown event type\n";
    }
}

int main() {
    Event ev1 = MouseEvent{100, 200};
    Event ev2 = KeyEvent{'A'};
    handleEvent(ev1);
    handleEvent(ev2);

    AnyEvent aev1 = MouseEvent{50, 75};
    AnyEvent aev2 = KeyEvent{'B'};
    handleAnyEvent(aev1);
    handleAnyEvent(aev2);
}

输出示例 

Mouse at (100,200)
Key pressed: A
Any: Mouse at (50,75)
Any: Key pressed: B

从上例可以看到，variant 的 visit 让我们可以利用编译期类型信息，避免显式的 if 或 typeid 比较；而 any 的实现更灵活，但代码略显冗长，且需要手动维护类型检查。

6. 结语

std::variant 与 std::any 为 C++17 标准库提供了两种不同的“容器”思路：一种是 类型安全的组合，另一种是 通用的类型擦除。在实际项目中，选择哪一种取决于你对类型可知性、性能要求和代码可维护性的考量。掌握它们的区别与适用场景，将使你在构建复杂系统时更加从容。祝编码愉快！

发表评论