**C++ 中的 std::variant 与 std::any 的区别与使用场景**

作者

在现代 C++（C++17 及以后）中，std::variant 与 std::any 都提供了类型安全的“容器”，用于存储任意类型的对象，但它们的设计目标和使用方式有显著差异。本文将详细探讨两者的核心区别、典型使用场景，以及在实际项目中如何合理选择。

1. 语义对比

特性 std::variant std::any
类型安全 编译时类型已知，存储值时必须列出所有可能类型；访问时使用 `std::get
或std::visit。 | 运行时类型未知，使用any_cast` 进行类型转换，若类型不匹配抛出异常。
内存占用 固定大小，取决于所列类型中占内存最大的那一个；无堆分配。 可能动态分配（当存储的对象尺寸超过内部缓冲区时）。
性能 访问速度更快，尤其是对小型数据类型；支持 constexpr。 访问时需要一次动态检查；在大多数实现中会使用 std::type_info 进行类型比较。
用途 适合“有限枚举”类型的值，例如解析 JSON 数字/字符串/布尔值等；适用于多态场景但不需要虚函数。 适合“任意类型”但不想预先声明所有可能类型的情况，例如插件系统、事件总线、消息队列等。
编译器优化 支持 constexpr 和编译期求值，易于内联。 受限于运行时类型识别，优化空间有限。

2. 典型使用场景

2.1 std::variant 的场景

  1. 解析多态数据
    如解析 nlohmann::json 的值，JSON 可以是字符串、数值、布尔值、数组或对象，使用 variant<json, string, int, bool> 可以在编译期定义所有可能类型。

  2. 多种状态表示
    在状态机或 UI 事件处理中，状态可能是“加载中”“已完成”“错误”等几种固定值。用 variant<Loading, Success, Error> 可以强制类型检查。

  3. 统一函数返回值
    当一个函数可能返回多种结果类型时，例如 parseConfig() 可能返回 Config 或 ParseError，可使用 variant<Config, ParseError>。

2.2 std::any 的场景

  1. 插件系统
    插件间共享数据结构时，插件可能提供多种自定义类型。any 可以容纳任何类型，插件使用 any_cast 获取所需类型。

  2. 事件总线
    事件在系统中以匿名消息传递，发送方只知道事件类型不必提前声明。接收方根据事件类型再做 any_cast。

  3. 缓存多态对象
    需要在缓存中存放多种对象且每次访问时只根据需要取出特定类型时，可使用 any。若缓存规模较小，可用 variant；若缓存类型多且未知，则 any 更适合。

3. 代码示例

3.1 用 variant 实现简单的 JSON 解析

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

using JsonValue = std::variant<std::monostate, std::nullptr_t, bool,
                               int, double, std::string>;

void printJson(const JsonValue& val) {
    std::visit([](auto&& v) {
        using T = std::decay_t<decltype(v)>;
        if constexpr (std::is_same_v<T, std::monostate>)
            std::cout << "null";
        else if constexpr (std::is_same_v<T, std::nullptr_t>)
            std::cout << "nullptr";
        else if constexpr (std::is_same_v<T, bool>)
            std::cout << (v ? "true" : "false");
        else if constexpr (std::is_same_v<T, int>)
            std::cout << v;
        else if constexpr (std::is_same_v<T, double>)
            std::cout << v;
        else if constexpr (std::is_same_v<T, std::string>)
            std::cout << '"' << v << '"';
    }, val);
}

int main() {
    JsonValue v = 42;
    printJson(v);  // 输出 42
}

3.2 用 any 实现通用事件总线

#include <any>
#include <functional>
#include <iostream>
#include <unordered_map>
#include <vector>
#include <string>

class EventBus {
public:
    using Handler = std::function<void(const std::any&)>;

    template <typename Event>
    void subscribe(const std::string& name, std::function<void(const Event&)> cb) {
        handlers[name].emplace_back([cb = std::move(cb)](const std::any& payload) {
            try {
                cb(std::any_cast<const Event&>(payload));
            } catch (const std::bad_any_cast&) {
                std::cerr << "Bad any_cast for event: " << name << '\n';
            }
        });
    }

    template <typename Event>
    void publish(const std::string& name, const Event& payload) {
        for (auto& h : handlers[name]) h(payload);
    }

private:
    std::unordered_map<std::string, std::vector<Handler>> handlers;
};

struct UserCreated { std::string name; int id; };

int main() {
    EventBus bus;
    bus.subscribe <UserCreated>("user.created",
        [](const UserCreated& e){ std::cout << "New user: " << e.name << '\n'; });

    UserCreated u{"Alice", 1};
    bus.publish("user.created", u);
}

4. 选择建议

  1. 先确定类型集合

    • 如果你能在编译期列出所有可能的类型，且数量不多，优先使用 std::variant。
    • 如果类型是动态产生或极其多样，使用 std::any。

  2. 关注性能

    • 对于高频访问或性能敏感路径，variant 更优。
    • 对于一次性或不频繁访问，any 的开销可忽略。

  3. 错误处理

    • variant 在访问错误时会产生 std::bad_variant_access（可捕获）；
    • any 在类型不匹配时抛出 std::bad_any_cast。两者均是异常机制，建议在需要时使用 `std::holds_alternative ` 或 `any_cast` 并捕获异常。

  4. 编译期验证

    • variant 可以借助 std::visit 的 constexpr 版本，在编译期验证逻辑。
    • any 无此优势。

5. 小结

  • std::variant：固定、有限的类型集合，编译期安全、无堆分配、性能更佳。
  • std::any：无限制类型容器，运行时类型识别，适合插件/事件等动态场景。

在实际项目中，既可以单独使用，也可以组合使用：例如，用 variant 表示内部固定结构，用 any 作为插件或配置接口的通用容器。正确选择可让代码更安全、可维护并提升性能。

发表评论