2.3、std::any

什么是 std::any？它解决了什么问题？

std::any，简单来说，就是一个“类型安全的万能盒子”，它可以存储任意类型的值，而且你不需要在编译时确定类型。相比于传统的void*指针，std::any不仅能存储任何类型，还能安全地识别和访问存储的类型，避免了类型错误和野指针的风险。

设计哲学

• • 类型安全替代void*：避免了void*带来的类型不确定和强制转换风险。
• • 动态类型存储：允许运行时存储任意类型，满足灵活场景需求。
• • 值语义管理：内部通过类型擦除和动态分配管理存储对象，支持复制、移动和销毁。
• • 单值存储：每个std::any实例只存储一个对象，但类型不固定。

std::any的出现，体现了现代C++对“类型安全”和“灵活性”的追求，它让我们可以写出既安全又通用的代码。

std::any的基本用法

#include <any>
#include <iostream>
#include <string>

int main() {
    std::any a = 42;  // 存储int
    std::cout << std::any_cast<int>(a) << "\n";

    a = std::string("Hello std::any");  // 存储string
    try {
        std::cout << std::any_cast<std::string>(a) << "\n";
        // 错误访问类型会抛异常
        std::cout << std::any_cast<int>(a) << "\n";  
    } catch (const std::bad_any_cast& e) {
        std::cout << "捕获异常: " << e.what() << "\n";
    }

    a.reset();  // 清空存储
    if (!a.has_value()) {
        std::cout << "a已被清空\n";
    }
    return 0;
}

这段代码展示了std::any的核心用法：

• • 可以存储任意类型的值。
• • 访问时用std::any_cast<T>进行类型转换，类型不匹配会抛std::bad_any_cast异常。
• • reset()清空当前存储，has_value()判断是否有值。

深入底层：std::any是如何实现的？

std::any的底层设计主要基于类型擦除（type erasure）和动态内存管理，其核心思想是：

• • 内部用一个指向基类的指针（通常是抽象基类placeholder）来管理存储的对象。
• • 每个存储的具体类型都有一个派生类模板holder<T>，负责管理该类型的对象生命周期（构造、复制、销毁）。
• • 通过虚函数接口实现对不同类型对象的统一操作（复制、移动、获取类型信息）。
• • 访问时通过typeid对比和动态转换，保证类型安全。

简化示意：

struct placeholder {
    virtual ~placeholder() = default;
    virtual const std::type_info& type() const = 0;
    virtual placeholder* clone() const = 0;
};

template<typename T>
struct holder : placeholder {
    T value;
    holder(const T& v) : value(v) {}
    const std::type_info& type() const override { return typeid(T); }
    placeholder* clone() const override { return new holder(value); }
};

class any {
    placeholder* content;
public:
    template<typename T>
    any(T&& value) : content(new holder<std::decay_t<T>>(std::forward<T>(value))) {}

    any(const any& other) : content(other.content ? other.content->clone() : nullptr) {}
    ~any() { delete content; }

    const std::type_info& type() const { return content ? content->type() : typeid(void); }
    // 省略访问和赋值操作
};

这种设计让std::any在存储任意类型的同时，保持了类型安全和正确的生命周期管理。

深度案例：用 std::any 实现通用事件系统

假设你设计一个事件系统，事件参数类型多样，可能是int、std::string、自定义结构体等，传统写法需要大量模板或继承。用std::any可以轻松实现：

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

class EventBus {
    using Handler = std::function<void(const std::any&)>;
    std::unordered_map<std::string, std::vector<Handler>> listeners;
public:
    void subscribe(const std::string& eventName, Handler handler) {
        listeners[eventName].push_back(std::move(handler));
    }

    void publish(const std::string& eventName, std::any data) {
        if (listeners.count(eventName)) {
            for (auto& handler : listeners[eventName]) {
                handler(data);
            }
        }
    }
};

struct PlayerInfo {
    std::string name;
    int level;
};

int main() {
    EventBus bus;

    bus.subscribe("PlayerJoined", [](const std::any& data) {
        try {
            const PlayerInfo& info = std::any_cast<PlayerInfo>(data);
            std::cout << "玩家加入: " << info.name << " 等级:" << info.level << "\n";
        } catch (const std::bad_any_cast&) {
            std::cout << "事件数据类型错误\n";
        }
    });

    bus.subscribe("ScoreUpdate", [](const std::any& data) {
        try {
            int score = std::any_cast<int>(data);
            std::cout << "分数更新: " << score << "\n";
        } catch (const std::bad_any_cast&) {
            std::cout << "事件数据类型错误\n";
        }
    });

    bus.publish("PlayerJoined", PlayerInfo{"Alice", 10});
    bus.publish("ScoreUpdate", 1500);

    return 0;
}

代码解析

• • EventBus用std::any作为事件数据的统一载体，支持任意类型。
• • 订阅者通过std::any_cast安全访问参数类型，避免了复杂的模板和继承设计。
• • 事件发布时，std::any自动管理参数对象生命周期。

底层细节

• • std::any内部动态分配存储事件参数，保证生命周期直到事件处理完毕。
• • 通过std::any_cast进行类型检查，防止错误访问。
  这种设计极大提升了事件系统的灵活性和扩展性。

常见错误及误区

1. 1. 误用std::any_cast导致异常
   访问类型不匹配时会抛std::bad_any_cast，必须捕获异常或先用type()判断。
2. 2. 性能开销被忽视
   std::any内部通常动态分配内存，频繁赋值和复制会带来性能损耗，不适合高频调用场景。
3. 3. 存储大对象的副作用
   大对象存储时会分配堆内存，建议对性能敏感的场合使用std::variant或自定义类型。
4. 4. 误解与std::variant的区别
   std::variant是编译时确定的多类型联合体，类型安全且无动态分配；std::any是运行时任意类型存储，灵活但有开销。

面试中可能考察的点

1. 1. std::any和void*的区别？
   答：std::any是类型安全的，能存储任意类型并记录类型信息；void*不安全，无法自动管理生命周期和类型。
2. 2. std::any内部如何实现类型擦除？
   答：通过基类指针和派生模板类管理不同类型的对象，实现统一接口。
3. 3. 访问std::any的正确方式？
   答：使用std::any_cast<T>，类型不匹配会抛异常；也可用std::any_cast<T>(&a)返回指针，失败时返回空指针。
4. 4. 什么时候用std::any，什么时候用std::variant？
   答：如果类型集合固定且有限，优先用std::variant；如果类型不确定或动态，使用std::any。
5. 5. std::any的性能特点？
   答：有动态内存分配和虚函数开销，不适合性能敏感的热路径。

总结

std::any是C++17中极具灵活性的类型安全容器，打破了编译时类型限制，允许我们在运行时存储和操作任意类型的值。它的底层通过类型擦除和动态内存管理实现，既保证了类型安全，也带来了灵活性。通过合理使用std::any，我们可以设计出极具扩展性的通用框架，如事件系统、配置管理器等。
本文首发于【讳疾忌医-note】公众号，未经授权，不得转载。
（加入我的知识星球，免费获取账号，解锁所有文章。）