C++17 std::make_any用法详解：类型安全容器与高效对象构造

1. 项目概述：为什么我们需要std::make_any？

在 C++17 之前，处理类型不确定的对象是个麻烦事。你可能得用void*指针配合类型标签，或者自己写一套复杂的类型擦除系统，代码又长又容易出错。std::any的出现，就是为了解决“安全地存储任意类型”这个需求。它就像一个类型安全的万能容器，你可以在运行时把任何可拷贝构造的类型塞进去，需要时再安全地取出来。

而std::make_any，则是创建这个万能容器的“快捷工厂”。很多刚接触std::any的朋友会直接用它的构造函数，比如std::any a = 42;或者std::any a(std::in_place_type<T>, args...)。这当然可以，但make_any提供了更清晰、更符合现代 C++ 习惯的创建方式。它的核心价值在于两点：一是表达意图更明确，看到make_any就知道这是在构造一个any对象；二是完美转发参数，能高效地将构造参数传递给内部存储的对象，避免不必要的拷贝。对于复杂的对象构造，比如需要多个参数或初始化列表，make_any的语法比直接构造any要直观和简洁得多。

简单来说，如果你用过std::make_shared或std::make_unique，那么std::make_any就是同一个设计理念下的产物：让对象的创建更安全、更高效、更现代。这篇文章，我就结合自己这些年踩过的坑和积累的经验，带你彻底搞懂make_any的用法、原理以及那些官方文档里不会写的细节。

2.std::make_any的核心语法与工作原理

2.1 函数签名与重载解析

我们先从最根本的语法看起。根据 C++ 标准库定义，std::make_any有两个重载版本，都定义在<any>头文件中。

// 版本 (1): 最通用的形式 template< class T, class... Args > std::any make_any( Args&&... args ); // 版本 (2): 处理需要初始化列表的情况 template< class T, class U, class... Args > std::any make_any( std::initializer_list<U> il, Args&&... args );

版本 (1) 是主力。它接受一个模板参数T（你希望存储在any中的类型），以及一个可变参数包Args...。这些Args会被完美转发给类型T的构造函数。这意味着，make_any<std::string>("hello", 3)实际上会调用std::string("hello", 3)来构造一个内容为"hel"的字符串对象，然后将其封装进any。

版本 (2) 专门用于处理需要std::initializer_list进行构造的类型，比如std::vector。这里的U是初始化列表中元素的类型。这个重载的存在，解决了直接使用版本 (1) 时，编译器可能无法正确推导出你要用初始化列表构造T的尴尬。举个例子，你想构造一个std::vector<int>，用make_any<std::vector<int>>({1, 2, 3})，编译器可能会懵。而用版本 (2)，你可以清晰地写成make_any<std::vector<int>>(std::initializer_list<int>{1, 2, 3})，虽然有点啰嗦，但意图绝对明确。在实际编码中，我更推荐使用auto配合列表初始化来规避这个问题，后面会详细说。

这两个函数都返回一个构造好的std::any对象。根据标准，它们的实现等价于：

• 版本 (1):return std::any(std::in_place_type<T>, std::forward<Args>(args)...);
• 版本 (2):return std::any(std::in_place_type<T>, il, std::forward<Args>(args)...);

这里的std::in_place_type<T>是一个标签，用于告诉any的构造函数：“请原地（in-place）构造一个T类型的对象，就用我后面给的这些参数”。make_any本质上就是这个过程的语法糖。

2.2 底层机制：类型擦除与 Small Buffer Optimization

理解make_any干了什么，还得稍微了解一下std::any的底层。any的核心是类型擦除。它内部持有一个某种“可调用”的接口（通常是一个虚基类指针），这个接口知道如何执行拷贝、移动、销毁以及查询类型等操作。具体存储的对象，则通过继承这个接口来实现多态。

一个关键的性能优化是SBO（Small Buffer Optimization）。类似于std::string或std::function，std::any也会在对象内部预留一小块缓冲区（具体大小是实现定义的，通常能容纳两个或三个指针大小的对象）。如果要存储的对象尺寸小于等于这个缓冲区，就直接在栈上的这块缓冲区里构造（这就是“原地构造”的由来），避免了堆内存分配的开销。如果对象太大，则会在堆上分配内存。

make_any的调用，最终会触发这个决策过程。编译器根据T的大小和对齐要求，决定使用 SBO 还是堆分配。这对我们来说是透明的，但知道这一点有助于理解为什么any在存储小对象时效率很高。

注意：SBO 的实现是编译器相关的。这意味着用make_any创建一个any，在 MSVC、GCC 和 Clang 下的内存布局和性能特征可能略有不同。对于性能临界代码，如果需要确定性，最好进行测试。

3.std::make_any的实战用法详解

光说不练假把式，我们直接上代码，看看make_any在各种场景下怎么用。

3.1 基础类型与自定义类型的存储

对于基础类型和简单的自定义结构体，make_any用起来非常直观。

#include <any> #include <iostream> #include <string> struct Point { int x, y; Point(int a, int b) : x(a), y(b) { std::cout << "Constructing Point(" << x << ", " << y << ")\n"; } ~Point() { std::cout << "Destroying Point\n"; } }; int main() { // 存储基础类型 auto any_int = std::make_any<int>(42); auto any_double = std::make_any<double>(3.14159); auto any_string = std::make_any<std::string>("Hello, make_any!"); // 存储自定义类型，传递构造参数 auto any_point = std::make_any<Point>(10, 20); // 调用 Point(10, 20) // 通过 any_cast 获取值 (注意：返回的是副本) int i = std::any_cast<int>(any_int); std::string s = std::any_cast<std::string>(any_string); Point p = std::any_cast<Point>(any_point); // 这里会调用 Point 的拷贝构造函数！ std::cout << "Int: " << i << "\n"; std::cout << "String: " << s << "\n"; std::cout << "Point: (" << p.x << ", " << p.y << ")\n"; return 0; } // 输出可能类似于： // Constructing Point(10, 20) // Constructing Point(10, 20) // 注意：这是 any_cast 时拷贝构造的！ // Int: 42 // String: Hello, make_any! // Point: (10, 20) // Destroying Point // 拷贝的 p 被销毁 // Destroying Point // any 中的 Point 被销毁

这里有个非常重要的细节：std::any_cast<T>(any_object)返回的是T类型的一个副本。如果T是像Point这样有自定义构造/析构的类型，就会发生拷贝。对于昂贵的对象，这可能是性能瓶颈。正确的做法是使用引用形式的any_cast。

3.2 使用引用避免拷贝，处理多态与大型对象

为了避免不必要的拷贝，any_cast支持返回引用或指针。

// 接上例 // 错误：尝试修改副本，原 any 中的值不变 Point p_copy = std::any_cast<Point>(any_point); p_copy.x = 100; std::cout << "After modifying copy: " << std::any_cast<Point>(any_point).x << "\n"; // 输出 10 // 正确：获取引用 Point& p_ref = std::any_cast<Point&>(any_point); // 注意模板参数是 Point& p_ref.x = 100; std::cout << "After modifying ref: " << std::any_cast<Point>(any_point).x << "\n"; // 输出 100 // 正确：获取常量引用（如果 any 存储的是 const 对象） const Point& p_cref = std::any_cast<const Point&>(any_point); // 正确：获取指针（失败时返回 nullptr） Point* p_ptr = std::any_cast<Point>(&any_point); // 参数是 any 的地址！ if (p_ptr) { p_ptr->y = 200; }

对于大型对象（比如一个大向量）或多态对象（基类指针指向派生类），使用引用或指针是必须的。考虑以下场景：

#include <any> #include <vector> #include <memory> class Base { public: virtual void foo() { std::cout << "Base\n"; } virtual ~Base() = default; }; class Derived : public Base { public: void foo() override { std::cout << "Derived\n"; } }; int main() { // 存储大型对象：使用移动语义 std::vector<int> huge_vec(1000000, 42); // 错误做法：make_any 会拷贝 huge_vec // auto any_vec_bad = std::make_any<std::vector<int>>(huge_vec); // 正确做法：移动进去 auto any_vec_good = std::make_any<std::vector<int>>(std::move(huge_vec)); // 此时 huge_vec 为空 // 获取引用，避免 any_cast 时再次拷贝 std::vector<int>& vec_ref = std::any_cast<std::vector<int>&>(any_vec_good); std::cout << "Vector size: " << vec_ref.size() << "\n"; // 输出 1000000 // 存储多态对象：存储 std::unique_ptr<Base> auto any_poly = std::make_any<std::unique_ptr<Base>>(std::make_unique<Derived>()); // 通过 any_cast 获取 unique_ptr 的引用，然后调用虚函数 std::unique_ptr<Base>& ptr_ref = std::any_cast<std::unique_ptr<Base>&>(any_poly); ptr_ref->foo(); // 输出 "Derived" return 0; }

实操心得：我强烈建议，只要存储的不是int、double这种微不足道的类型，在any_cast时都优先考虑使用引用（any_cast<T&>）。这能明确你的意图——你是想访问any内部的那个对象，而不是要一个它的拷贝。这既是性能优化，也能避免一些意想不到的逻辑错误。

3.3 处理需要初始化列表的容器类型

这是make_any第二个重载大显身手的地方，也是最容易让人困惑的地方。假设我们想存储一个std::vector<std::string>。

#include <any> #include <vector> #include <string> int main() { // 方法1：使用 auto 推导，这是最简洁的方式，推荐！ auto any_vec1 = std::make_any<std::vector<std::string>>(std::vector<std::string>{"apple", "banana", "cherry"}); // 等价于：先构造一个 vector，再移动给 make_any // 方法2：使用第二个重载，显式传递 initializer_list auto any_vec2 = std::make_any<std::vector<std::string>>( std::initializer_list<std::string>{"apple", "banana", "cherry"} ); // 方法3（容易出错）：直接传递初始化列表。这在某些编译器/标准库版本下可能无法编译，或产生非预期行为。 // auto any_vec3 = std::make_any<std::vector<std::string>>({"apple", "banana", "cherry"}); // 编译器可能无法推导出 Args... 包，因为初始化列表不是表达式，没有明确的类型。 // 验证 auto& vec = std::any_cast<std::vector<std::string>&>(any_vec1); for (const auto& s : vec) { std::cout << s << ' '; } std::cout << '\n'; return 0; }

为什么直接传{"apple", ...}不行？因为{"apple", "banana", "cherry"}作为一个花括号初始化列表，它本身没有类型，在模板参数推导阶段是个“非推导上下文”。编译器很难确定它应该被转换成std::initializer_list<std::string>还是其他什么东西。因此，最安全、最通用的做法就是方法1：显式地构造一个std::vector临时对象（这里会触发移动语义，效率很高），然后交给make_any。

对于std::map,std::set等同样适用：

auto any_map = std::make_any<std::map<int, std::string>>( std::map<int, std::string>{{1, "one"}, {2, "two"}} );

3.4 与std::any_cast的配合与错误处理

创建了any对象，最终目的是把值取出来用。std::any_cast是唯一的“钥匙”，但它也可能抛异常。

#include <any> #include <iostream> int main() { auto a = std::make_any<int>(100); try { // 尝试转换成错误的类型 double d = std::any_cast<double>(a); // 抛出 std::bad_any_cast } catch (const std::bad_any_cast& e) { std::cout << "Caught exception: " << e.what() << '\n'; // 通常输出 "bad any_cast" } // 安全转换：使用指针版本 if (auto* ptr = std::any_cast<double>(&a)) { // 传入 any 的地址 std::cout << "It's a double: " << *ptr << '\n'; } else { std::cout << "It's NOT a double.\n"; } // 检查 any 中是否存储了值及其类型 if (a.has_value()) { std::cout << "a has value, type is: " << a.type().name() << '\n'; // type().name() 返回的类型名是实现定义的，可能不可读（如 "i" 代表 int） } // 重置 any 对象 a.reset(); if (!a.has_value()) { std::cout << "a is now empty.\n"; } return 0; }

关键点：

1. 异常安全：如果类型不匹配，any_cast<T>(any)会抛出std::bad_any_cast。务必在不确定类型时使用try-catch，或者使用指针版本。
2. 指针版本：any_cast<T>(&any)在失败时返回nullptr，不会抛出异常。这是进行“安全试探”的首选方法。
3. type()成员函数：它返回std::type_info的引用，可以用来比较类型。但type_info::name()的字符串格式是编译器相关的（比如 GCC 返回的可能是"i"，MSVC 返回的可能是"int"），不适合用于逻辑判断。比较类型应该用a.type() == typeid(int)。
4. reset()：清空any对象，使其不包含任何值。析构时内部存储的对象也会被正确销毁。

4. 高级主题：make_any的陷阱、技巧与性能考量

掌握了基本用法，我们来看看那些容易踩坑的地方和一些进阶技巧。

4.1 陷阱一：Lambda 表达式的类型处理

这是官方示例里就提到的一个经典陷阱。Lambda 表达式每个都是独一无二的类型（闭包类型）。

#include <any> #include <functional> #include <iostream> int main() { // 陷阱：直接存储 lambda std::any a1 = []() { std::cout << "Lambda 1\n"; }; std::cout << "a1 type: " << a1.type().name() << '\n'; // 输出一个编译器生成的独特类型名 // 尝试将其转换为 std::function<void()> 会失败！ try { std::any_cast<std::function<void()>>(a1)(); // 抛出 bad_any_cast } catch (...) { std::cout << "Cast failed! Lambda type is unique.\n"; } // 正确做法：使用 make_any 明确指定存储类型为 std::function<void()> auto a2 = std::make_any<std::function<void()>>( []() { std::cout << "Lambda 2\n"; } ); std::cout << "a2 type: " << a2.type().name() << '\n'; // 输出与 std::function 相关的类型名 std::any_cast<std::function<void()>>(a2)(); // 成功调用，输出 "Lambda 2" return 0; }

原因分析：a1存储的是 lambda 表达式本身的闭包类型（比如main::<lambda()>），而std::function<void()>是一个完全不同的、可调用的包装器类型。any_cast要求类型完全匹配，所以转换失败。

结论：如果你想在any中存储一个可调用对象，并希望后续能以一种统一的接口（如std::function）调用它，那么必须在创建时就通过make_any将其转换为目标类型。直接赋值 lambda 进去，它的类型就被“锁定”为那个独特的闭包类型了。

4.2 陷阱二：生命周期管理与std::any的拷贝语义

std::any管理着内部对象的生命周期。当any被拷贝、移动或销毁时，内部对象也会相应地被拷贝、移动或销毁。这要求存储的类型必须是可拷贝构造的（对于拷贝操作）或可移动构造的（对于移动操作）。

#include <any> #include <iostream> struct NonCopyable { NonCopyable(int v) : value(v) {} NonCopyable(const NonCopyable&) = delete; // 禁止拷贝 NonCopyable& operator=(const NonCopyable&) = delete; int value; }; int main() { NonCopyable nc(42); // 错误：无法拷贝构造，因为 make_any 内部需要构造一个 T 的实例。 // auto a1 = std::make_any<NonCopyable>(nc); // 正确：移动构造是允许的（如果 NonCopyable 定义了移动构造函数或编译器生成了默认的）。 // 假设 NonCopyable 有移动语义（编译器通常为只有简单成员的结构生成默认移动操作） auto a2 = std::make_any<NonCopyable>(std::move(nc)); // 调用移动构造函数 // 或者直接传递构造参数 auto a3 = std::make_any<NonCopyable>(100); // 直接调用 NonCopyable(100) // 但是，拷贝 any 对象本身会失败，因为内部对象不可拷贝。 // auto a4 = a3; // 编译错误！std::any 的拷贝构造函数要求内部 T 可拷贝。 // 移动 any 对象是可行的 auto a5 = std::move(a3); // a3 被移空，a5 获得所有权 if (!a3.has_value()) { std::cout << "a3 is empty after move.\n"; } return 0; }

重要规则：

• std::any要求其模板参数T满足CopyConstructible条件，因为any本身需要支持拷贝。
• 如果你存储了一个不可拷贝的类型（如std::unique_ptr或自定义的只移动类型），那么这个any对象将不能被拷贝，只能被移动。
• 使用make_any时，如果传递一个左值，它会尝试拷贝；如果希望移动，请使用std::move。

4.3 技巧：结合std::any实现简单的类型安全异构容器

std::any的一个典型应用场景是构建异构容器（比如一个可以存放多种类型元素的向量）。结合std::make_any，我们可以优雅地初始化它。

#include <any> #include <vector> #include <string> #include <iostream> #include <typeinfo> class HeterogeneousContainer { std::vector<std::any> data_; public: template<typename T> void push(T&& value) { // 使用完美转发，支持拷贝和移动 data_.push_back(std::make_any<std::decay_t<T>>(std::forward<T>(value))); } template<typename T> bool try_get(size_t index, T& out_value) const { if (index >= data_.size()) return false; const std::any& elem = data_[index]; if (elem.type() != typeid(T)) return false; try { out_value = std::any_cast<T>(elem); return true; } catch (const std::bad_any_cast&) { return false; } } void print_types() const { for (size_t i = 0; i < data_.size(); ++i) { std::cout << "[" << i << "]: " << data_[i].type().name() << '\n'; } } }; int main() { HeterogeneousContainer container; container.push(42); // int container.push(3.14); // double container.push(std::string("hello")); // std::string container.push(std::vector<int>{1,2,3});// std::vector<int> container.print_types(); int i; if (container.try_get(0, i)) { std::cout << "Got int at index 0: " << i << '\n'; } std::string s; if (container.try_get(2, s)) { std::cout << "Got string at index 2: " << s << '\n'; } // 尝试获取错误类型 double d; if (!container.try_get(1, d)) { // 索引1存储的是 double，但这里我们故意用 int 去取？不，这里演示的是正确获取。 std::cout << "Failed to get value.\n"; } else { std::cout << "Got double at index 1: " << d << '\n'; } return 0; }

在这个例子中，push方法利用make_any和完美转发，可以高效地存储任何类型的值。try_get提供了类型安全的访问。这是一种比使用union或void*安全得多的实现异构容器的方式。

4.4 性能考量与最佳实践

1. 类型查询开销：每次调用any_cast或type()都涉及到一次类型比较（typeid比较或内部类型信息比较）。虽然这个开销很小，但在极高频的循环中仍需注意。
2. 拷贝开销：any的拷贝需要拷贝内部对象。如果内部对象很大（如大容器），拷贝成本会很高。在需要传递any时，优先考虑使用移动（std::move）或常量引用。
3. 堆分配开销：当存储的对象太大无法放入 SBO 缓冲区时，any会在堆上分配内存。频繁创建和销毁大型对象的any可能导致堆内存碎片。对于性能敏感的场景，如果类型范围是已知的，使用std::variant（C++17）可能是更好的选择，因为它是在栈上分配固定大小的存储，没有动态内存分配开销。
4. 何时用any，何时用variant：
   • 用std::any：当需要存储的类型集合在编译期完全未知或非常庞大时。例如，插件系统、脚本引擎绑定、序列化框架中存储任意用户数据。
   • 用std::variant：当需要存储的类型集合在编译期已知且数量有限时（通常不超过十几个）。variant提供类型安全的访问（std::visit），性能通常优于any，并且能利用栈存储。
5. make_anyvs 直接构造：在大多数情况下，make_any和直接使用std::any的in_place_type构造函数在性能上没有区别。make_any的优势在于代码可读性和一致性（与现代 C++ 的make_*工厂函数家族保持一致）。我个人的习惯是：只要不是最简单的any a = value;这种形式，一律使用make_any，让“构造”这个意图更明显。

5. 常见问题排查与调试技巧

在实际项目中用any和make_any，难免会遇到一些奇怪的问题。这里记录几个我踩过的坑和解决方法。

5.1 问题：any_cast抛出bad_any_cast，但类型看起来是对的

场景：你确信any里存的是int，但any_cast<int>却失败了。

可能原因及排查：

1. 类型不严格匹配：any_cast要求精确匹配。int和const int、int&、volatile int都被视为不同的类型。

   std::any a = 42; // auto x = std::any_cast<const int>(a); // 错误！类型是 int，不是 const int auto x = std::any_cast<int>(a); // 正确 auto& x_ref = std::any_cast<int&>(a); // 正确，获取引用

   解决方法是使用type()成员函数检查实际类型，或者使用any_cast的指针版本进行安全尝试。

2. 跨动态链接库边界：如果你在一个 DLL/so 中创建any（比如存储了一个自定义类对象），在另一个 DLL/so 中尝试any_cast，可能会失败。这是因为typeid的比较可能依赖于运行时类型信息（RTTI）的实现细节，跨模块时可能不匹配。这是一个非常棘手的问题，通常的解决方案是避免跨模块传递具体类型的any，或者使用类型名（type().name()）进行字符串比较（虽然不可靠），或者设计一套不依赖typeid的类型标识系统。

3. any对象已被移动或重置：移动一个any对象后，源对象变为空。对空的any进行any_cast会抛出bad_any_cast。

   auto a1 = std::make_any<int>(1); auto a2 = std::move(a1); // a1 被移空 // int x = std::any_cast<int>(a1); // 抛出异常！a1 现在没有值。

   在any_cast前，先用has_value()检查一下是个好习惯。

5.2 问题：使用make_any时编译错误 “no matching function”

场景：auto a = std::make_any<MyClass>(arg1, arg2);编译失败。

可能原因及排查：

1. 参数无法转换为目标构造函数的参数：检查MyClass是否存在接受(arg1类型, arg2类型)的构造函数。make_any的本质是完美转发参数给T的构造函数。
2. 遇到了 Most Vexing Parse：如果你的参数看起来像是一个函数声明，编译器可能会误解。

   // 假设有类 `Timer` 可以用一个 int 初始化 auto a = std::make_any<Timer>(10); // 正确，构造一个延迟10的Timer // 但如果 Timer 有一个构造函数接受一个函数指针？ // 某些情况下，复杂的参数列表可能导致解析歧义。

   解决方法是确保参数列表清晰，或者使用花括号初始化（但要注意前面提到的初始化列表问题）。
3. 缺少必要的头文件或命名空间：确保MyClass的定义在作用域内可见。
4. C++ 版本过低：std::make_any是 C++17 特性。确认你的编译器开启了 C++17 或更高标准（-std=c++17//std:c++17）。

5.3 调试技巧：打印any中存储的内容

由于any的类型是运行时确定的，直接打印其内容很困难。一个实用的调试方法是写一个辅助函数，针对几种已知的常用类型进行尝试性转换和打印。

#include <any> #include <iostream> #include <string> #include <typeinfo> void debug_print_any(const std::any& a) { if (!a.has_value()) { std::cout << "(empty)"; return; } const std::type_info& ti = a.type(); // 尝试几种常见类型 if (ti == typeid(int)) { std::cout << std::any_cast<int>(a); } else if (ti == typeid(double)) { std::cout << std::any_cast<double>(a); } else if (ti == typeid(std::string)) { std::cout << '\"' << std::any_cast<std::string>(a) << '\"'; } else if (ti == typeid(const char*)) { std::cout << '\"' << std::any_cast<const char*>(a) << '\"'; } else { // 对于未知类型，至少打印类型名 std::cout << "[object of type: " << ti.name() << "]"; } } int main() { std::any arr[] = { std::make_any<int>(42), std::make_any<double>(3.14), std::make_any<std::string>("test"), std::any() // empty }; for (const auto& a : arr) { debug_print_any(a); std::cout << ", "; } std::cout << '\n'; // 输出可能类似：42, 3.14, "test", (empty), }

当然，对于生产代码，可能需要更完善的类型注册和访问机制。但这样一个简单的调试函数在开发阶段能解决大部分问题。

std::make_any作为std::any的伴侣函数，将类型安全的动态类型存储这一强大功能，以符合现代 C++ 习惯的方式呈现给我们。从简单的值存储到复杂的异构容器，再到与多态对象的配合，它提供了一种灵活且相对安全的机制。核心在于理解其“完美转发参数进行原地构造”的原理，并时刻牢记any_cast的精确类型匹配和引用/指针用法以避免性能陷阱。在实际项目中，权衡any的灵活性与variant的性能和类型安全，选择最适合的工具，才是用好这些现代 C++ 特性的关键。