C++如何使用std::any存储任意类型数据

P粉602998670

发布时间：2025-09-09 09:56:01

252人浏览过

来源于php中文网

原创

std::any通过类型擦除和运行时检查实现任意类型安全存储，区别于void*和union的手动类型管理及std::variant的编译时类型限定，适用于配置系统、插件架构等动态场景，但需注意堆分配和类型检查带来的性能开销，优先使用std::variant或具体类型以提升性能。

c++如何使用std::any存储任意类型数据

在C++中，

std::any

提供了一种类型安全的方式来存储任意类型的值，有点像一个可以动态持有任何类型数据的“盒子”。它允许你在运行时将不同类型的数据赋值给同一个

std::any

对象，并在需要时通过类型安全的机制将其取出。

解决方案

使用

std::any

存储任意类型的数据，核心在于包含

头文件，然后创建

std::any

对象，并利用赋值操作存储数据，最后通过

std::any_cast

来安全地提取数据。

这东西用起来其实挺直观的。你先得

include

。然后，声明一个

std::any

类型的变量，就像这样：

std::any my_data;

。

当你需要存储一个值时，直接赋值就行了，它会自动处理类型擦除：

立即学习“C++免费学习笔记（深入）”；

#include 
#include 
#include 
#include 

int main() {
    std::any my_data; // 创建一个空的any对象

    my_data = 42; // 存储一个int
    std::cout << "存储了int: " << std::any_cast(my_data) << std::endl;

    my_data = std::string("Hello, std::any!"); // 存储一个std::string
    std::cout << "存储了string: " << std::any_cast(my_data) << std::endl;

    my_data = std::vector{1.1, 2.2, 3.3}; // 存储一个std::vector
    // 取出并打印vector的第一个元素
    std::cout << "存储了vector，第一个元素是: " << std::any_cast>(my_data)[0] << std::endl;

    // 尝试取出不存在的类型会抛出std::bad_any_cast异常
    try {
        std::cout << std::any_cast(my_data) << std::endl;
    } catch (const std::bad_any_cast& e) {
        std::cerr << "捕获到异常: " << e.what() << std::endl;
    }

    // 检查是否有值，以及当前存储的类型
    if (my_data.has_value()) {
        std::cout << "my_data当前有值，类型是: " << my_data.type().name() << std::endl;
    }

    my_data.reset(); // 清空any对象
    if (!my_data.has_value()) {
        std::cout << "my_data已经被清空。" << std::endl;
    }

    return 0;
}

这段代码展示了

std::any

的基本操作：赋值、

any_cast

取值、异常处理，以及

has_value()

和

type()

的使用。

any_cast

是这里的关键，它不仅取回值，还会在类型不匹配时抛出

std::bad_any_cast

异常，这保证了类型安全性。

std::any与void*、union、std::variant有何本质区别？

这个问题问得好，因为很多时候我们看到

std::any

都会联想到那些老朋友。但它们之间其实有着非常根本的区别，理解这些差异能帮助我们更好地选择工具。

在我看来，

std::any

最核心的价值在于它在运行时提供了类型安全的任意类型存储能力，并且能处理任意复杂类型。

void*

是最原始的“万能指针”，它能指向任何类型的数据。但问题在于，

void*

本身不带任何类型信息，你必须手动记住它指向的是什么，然后强制转换回去。一旦转换错了，程序行为就未定义了，这简直就是个定时炸弹，编译期根本发现不了。

std::any

则不然，它内部维护了类型信息，

any_cast

会在运行时检查类型，不匹配就报错，这安全性高了不止一个档次。

union

嘛，它在C语言时代就有了，主要用于在同一块内存空间存储不同类型的数据，但同一时间只能有一种类型是有效的。它的限制很多，比如成员类型通常得是POD类型（Plain Old Data），不能有复杂的构造函数、析构函数。你得自己管理它的生命周期，而且同样没有内置的类型安全检查。

std::any

可以存储任何带有构造函数、析构函数的复杂C++对象，并且它自己会管理这些对象的生命周期，比如在赋值新值时正确销毁旧值。

而

std::variant

，这是C++17引入的另一个利器，它和

std::any

有些相似，都是类型安全的“和类型”（sum type）。但

std::variant

的关键在于，它能存储的类型集合必须在编译时就确定。比如

std::variant

，它只能是这三种类型之一。它的优点是通常没有堆内存分配（除非内部类型本身需要），性能通常更好，而且编译期就能进行类型检查。

std::any

则没有这个限制，它可以在运行时存储任何类型，你不需要提前知道所有可能的类型。所以，如果你的类型集合是固定的，并且你知道它们是什么，

std::variant

往往是更优的选择；如果类型是完全动态、不可预测的，

std::any

就派上用场了。

说白了，

void*

和

union

是“手动挡”，效率可能高但风险大；

std::variant

是“自动挡”，但车型（类型）是固定的；

std::any

则是“智能电动车”，能适应各种路况（类型），但可能需要一些额外的“电量”（运行时开销）。

NetShop网店系统

NetShop软件特点介绍： 1、使用ASP.Net(c#)2.0、多层结构开发 2、前台设计不采用任何.NET内置控件读取数据，完全标签化模板处理，加快读取速度3、安全的数据添加删除读取操作，利用存储过程模式彻底防制SQL注入式攻击4、前台架构DIV+CSS兼容IE6,IE7,FF等，有利于搜索引挚收录5、后台内置强大的功能，整合多家网店系统的功能，加以优化。6、支持三种类型的数据库：Acces

下载

在实际项目中，何时应该考虑使用std::any？

std::any

虽然强大，但它不是万能药，也不是应该随处可见的工具。它的最佳应用场景通常集中在那些需要高度灵活性，且类型在编译期难以确定的地方。

我个人觉得，最典型的应用场景就是配置系统。想象一下，你的应用程序需要从配置文件（比如JSON、YAML）中读取各种设置，有些是整数，有些是字符串，有些是布尔值，甚至可能是更复杂的自定义对象。如果用一堆

if-else

或

switch

来判断类型并存储，代码会变得非常臃肿。这时，你可以用

std::map

来存储配置项，键是配置名，值就是对应的任意类型数据。读取时，根据配置名取出

std::any

对象，再尝试

any_cast

到预期类型，如果失败就说明配置错误或者类型不匹配，这样处理起来既灵活又健壮。

另一个我能想到的地方是插件系统或扩展架构。当你的主程序需要加载外部插件，而这些插件可能会返回各种不同类型的数据时，

std::any

就很有用。主程序不需要知道每个插件具体返回什么类型，只需要约定一个接口，让插件返回

std::any

，然后主程序根据上下文尝试解析。这提供了一种松散耦合的机制。

事件系统中的事件数据载荷也是一个好例子。不同的事件可能携带不同结构的数据。一个

Event

基类可能有一个

std::any payload;

成员，

MouseClickEvent

把它设为

MouseCoords

结构体，

KeyboardEvent

把它设为

KeyCode

。事件处理器在接收到事件后，根据事件类型再决定如何

any_cast

这个

payload

。

当然，也要警惕过度使用。如果你的数据类型是固定的几个，或者你可以通过多态（继承）来解决，那么

std::any

可能就不是最好的选择。它引入的运行时开销和类型擦除，可能会让代码的意图变得不那么直接，甚至增加了调试难度。所以，用之前最好先问问自己：真的有必要这么灵活吗？有没有更直接、编译期更安全的方案？

使用std::any时可能遇到的性能问题及最佳实践是什么？

std::any

的便利性并非没有代价，性能问题是我们在使用时需要特别留意的。它在实现上，为了能够存储任意类型，通常会利用小对象优化（Small Object Optimization, SOO）。

简单来说，如果存储的类型足够小（比如

int

、

char

等，通常小于

std::any

内部预留的固定大小缓冲区，这个大小一般是16到32字节），那么数据会直接存储在

std::any

对象的内部。这种情况下，性能开销相对较小，没有堆内存分配。但一旦你存储的数据类型超过了这个内部缓冲区的大小（比如一个

std::string

包含长文本，或者一个

std::vector

），

std::any

就会在堆上动态分配内存来存储你的数据。频繁的堆分配和释放是众所周知的性能杀手，它可能导致缓存局部性变差，增加内存碎片，并带来额外的开销。

此外，每次使用

std::any_cast

取值时，都会有运行时类型检查的开销。虽然这通常很快，但在极度性能敏感的循环中，累积起来也可能成为瓶颈。类型擦除本身也意味着一些间接调用（通过函数指针或虚函数），这比直接调用要慢一些。

基于这些考量，我总结了一些使用

std::any

的最佳实践：

优先考虑
std::variant
：这点我之前提过，如果你的类型集合是已知的且有限的，
```
std::variant
```
几乎总是比
```
std::any
```
更好的选择。它通常没有堆分配，类型安全检查在编译期就能完成，性能和可读性都更优。
最小化
any_cast
的次数：尽量在获取到具体类型后，就用该具体类型的变量进行操作，而不是反复从
```
std::any
```
中
```
any_cast
```
。比如，先
```
auto& val = std::any_cast(my_any);
```
，然后对
```
val
```
进行一系列操作。
避免在热点路径（性能关键代码）中频繁使用
std::any
：如果你的代码需要处理大量数据，并且对性能要求极高，那么
```
std::any
```
可能不是一个好选择。它的动态特性和潜在的堆分配，可能会让性能难以预测。
注意对象的生命周期和所有权：
```
std::any
```
内部存储的是值的副本，或者通过移动语义获取所有权。这意味着你传入的对象会被复制或移动。对于大对象，这会增加开销。如果你想存储指针或引用，确保被指向或引用的对象生命周期足够长。
为
std::any
存储的类型提供移动构造函数：如果你的类型支持移动语义，
```
std::any
```
在存储和赋值时会优先使用移动构造而不是拷贝构造，这对于减少开销非常有帮助，尤其是在处理大对象时。
文档化预期类型： 由于
```
std::any
```
抹去了类型信息，代码的读者很难一眼看出
```
std::any
```
变量在特定上下文中应该存储什么类型。因此，清晰的注释或文档变得尤为重要，说明
```
std::any
```
在某个点上可能包含哪些类型，以及如何安全地提取它们。