聊聊 any：C++ 里的“万能口袋”

说实话，刚接触 C++17 那会儿，我看到 std::any 的第一反应是——这不就是 void* 的现代版吗？后来在项目里真正用上了，才发现事情没那么简单。今天我就跟你好好聊聊这个“万能口袋”类型。

any 到底是什么？

std::any 是 C++17 引入的一个类型。它能存储任意类型的值。嗯，你没听错，任意类型。int、string、vector、甚至你自定义的类，统统可以塞进去。

我习惯把它想象成一个“万能口袋”。你往里面放什么，它就能装什么。但有个关键点——它知道里面装的是什么类型。这一点跟 void* 有本质区别。

为什么需要 any？

你可能会问：有模板了，为什么还要 any？

模板是编译期多态。any 是运行期多态。场景不一样。

举个例子。我在做一个配置系统时，需要从配置文件里读取不同类型的参数。有的是 int，有的是 string，有的是 bool。如果用模板，你得在编译期就知道所有类型。但配置项是运行时才知道的。这时候 any 就派上用场了。

any 的基本用法

先看个最简单的例子：

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

int main() {
    std::any a = 42;                // 存 int
    std::any b = std::string("hello"); // 存 string
    std::any c = 3.14;              // 存 double
    
    // 读取值
    std::cout << std::any_cast<int>(a) << std::endl;
    std::cout << std::any_cast<std::string>(b) << std::endl;
    std::cout << std::any_cast<double>(c) << std::endl;
    
    return 0;
}

看着挺简单对吧？但这里有个坑——any_cast 如果类型不匹配，会抛出 std::bad_any_cast 异常。我曾经在项目里因为这个 bug 排查了半天，后来养成了习惯：读取前先检查类型。

安全地读取 any

怎么检查？用 has_value() 和 type()：

std::any a = 42;

if (a.has_value()) {
    if (a.type() == typeid(int)) {
        int value = std::any_cast<int>(a);
        std::cout << "int value: " << value << std::endl;
    } else {
        std::cout << "type mismatch" << std::endl;
    }
}

或者用 any_cast 的指针版本——它不会抛异常，失败返回 nullptr：

std::any a = 42;
int* p = std::any_cast<int>(&a);
if (p) {
    std::cout << *p << std::endl;
} else {
    std::cout << "not an int" << std::endl;
}

any 与类型安全

说到类型安全，这是 any 跟 void* 最大的区别。

void* 就是个裸指针。你往里面塞一个 int，然后当成 double 读出来，编译器不会报错，运行时也不会报错——你只会得到一堆莫名其妙的值。调试起来简直噩梦。

any 不一样。它内部保存了类型信息。你用 type() 可以查询，用 any_cast 会做类型检查。说白了，它把类型安全从“靠自觉”变成了“靠机制”。

我曾经接手过一个遗留项目，里面大量使用 void* 做回调参数。每次改代码都提心吊胆，生怕类型转换写错了。后来重构时全部换成 any，虽然性能上有点损耗，但代码的可维护性和安全性提升了一大截。

any 的性能考量

嗯，说到性能，这里得提一嘴。any 不是免费的午餐。

它内部会做类型擦除，存储时可能涉及动态内存分配。小类型（比如 int、double）可能有小对象优化，但大类型（比如 vector、string）一定会分配堆内存。

操作	性能开销	说明
构造/赋值	中等	可能涉及堆分配和拷贝
any_cast	低	主要是类型检查，没有拷贝
拷贝/移动	高/低	拷贝会复制内部数据，移动只是指针交换
析构	中等	需要调用内部对象的析构函数

实战：一个简单的配置系统

说了这么多，来个实际例子。这是我之前做的一个配置管理器的简化版：

#include <any>
#include <unordered_map>
#include <string>
#include <stdexcept>

class Config {
public:
    template<typename T>
    void set(const std::string& key, T value) {
        data_[key] = std::any(value);
    }
    
    template<typename T>
    T get(const std::string& key) const {
        auto it = data_.find(key);
        if (it == data_.end()) {
            throw std::runtime_error("key not found: " + key);
        }
        try {
            return std::any_cast<T>(it->second);
        } catch (const std::bad_any_cast&) {
            throw std::runtime_error("type mismatch for key: " + key);
        }
    }
    
    bool has(const std::string& key) const {
        return data_.find(key) != data_.end();
    }
    
private:
    std::unordered_map<std::string, std::any> data_;
};

// 使用示例
Config cfg;
cfg.set("timeout", 30);
cfg.set("name", std::string("server"));
cfg.set("debug", true);

int timeout = cfg.get<int>("timeout");           // 30
std::string name = cfg.get<std::string>("name"); // "server"
bool debug = cfg.get<bool>("debug");             // true

你看，用 any 实现这种配置系统，代码简洁又灵活。不用为每种类型写重载，也不用搞复杂的继承体系。

any 的替代方案

any 不是万能的。有些场景用别的方案更合适：

• std::variant：如果你知道所有可能的类型，用 variant。它更快，更安全。
• std::optional：如果只是“有值/无值”两种情况，用 optional。
• 模板：如果类型在编译期就能确定，用模板。
• 虚函数/接口：如果需要多态行为，用继承。

我个人习惯是：能不用 any 就不用。但当你确实需要在运行时处理未知类型时，any 就是最好的选择。

知识结构图

下面这张图帮你理清 any 的核心知识点：

总结一下

any 是个好东西，但别滥用。记住三点：

• 用它处理运行时未知类型
• 读取时用指针版本的 any_cast 更安全
• 性能敏感场景慎用

我在项目里用 any 最频繁的地方就是配置系统和插件框架。这两个场景都是“运行时才知道类型”，any 正好派上用场。你想想看，如果没有 any，你得写多少重载函数？

好了，any 就聊到这儿。记住它的核心价值：类型安全的万能口袋。用对了地方，它就是一把利器。

---

公众号:蓝海资料掘金营，微信deep3321