C++三剑客之std::any(二) : 源码剖析

目录

1.引言

2.std::any的存储分析

3._Any_big_RTTI与_Any_small_RTTI

4.std::any的构造函数

4.1.从std::any构造

4.2.可变参数模板构造函数

4.3.赋值构造与emplace函数

5.reset函数

6._Cast函数

7.make_any模版函数

8.std::any_cast函数

9.总结

---

1.引言

 C++三剑客之std::any(一) : 使用详解_c++ std::any-CSDN博客

        在前面详细的讲解了std::any的用法，std::any能够容纳任何可拷贝构造类型的数据，我们不禁会想它是怎么做到的呢？不同类型怎么做到巧妙的构造与转换的?多种构造函数如何实现？内部数据怎么储存？为什么分Big，Samll，trivial？

        下面就以vs2019的std::any实现为例进行具体分析它的实现。

2.std::any的存储分析

std::any 将保存内容的内存形式分为了三种：_Small、_Trivial、_Big

划分规则代码为：

// size in pointers of std::function and std::any (roughly 3 pointers larger than std::string when building debug)
constexpr int _Small_object_num_ptrs = 6 + 16 / sizeof(void*); //64位系统: 8//64位系统：_Any_trivial_space_size = 56
inline constexpr size_t _Any_trivial_space_size = (_Small_object_num_ptrs - 1) * sizeof(void*);template <class _Ty>
inline constexpr bool _Any_is_trivial = alignof(_Ty) <= alignof(max_align_t)&& is_trivially_copyable_v<_Ty> && sizeof(_Ty) <= _Any_trivial_space_size;//64位系统：_Any_small_space_size = 48
inline constexpr size_t _Any_small_space_size = (_Small_object_num_ptrs - 2) * sizeof(void*);template <class _Ty>
inline constexpr bool _Any_is_small = alignof(_Ty) <= alignof(max_align_t)&& is_nothrow_move_constructible_v<_Ty> && sizeof(_Ty) <= _Any_small_space_size;

简单来说，满足 _Any_is_trivial 则为 Trivial 类型内存，满足 _Any_is_small 则为 Small 类型内存，其余的则为 Big 类型内存。

在 64 位系统下，划分规则可以解释为：

• _Any_is_small：类型长度小于等于 48 字节，内存对齐长度小于等于 8 字节，拥有具备 nothrow 声明的移动构造
• _Any_is_trivial：类型长度小于等于 56 字节，内存对齐长度小于等于 8 字节，可平凡拷贝（基本数据类型、可平凡拷贝的聚合类型、以上类型的数组等）

下面是一些 _Any_is_small 和 _Any_is_trivial 判断的实测值：

struct Test1 {char a[48];
};struct Test2 {char a[56];
};struct Test3 {Test3(Test3&& other){memcpy(a, other.a, sizeof(Test3));}char a[48] {};
};struct Test4 {int& a;
};struct Test5 {virtual void a() = 0;
};// 1
std::cout << std::_Any_is_small<char> << std::endl;
// 1
std::cout << std::_Any_is_small<int> << std::endl;
// 1
std::cout << std::_Any_is_small<double> << std::endl;
// 1
std::cout << std::_Any_is_small<Test1> << std::endl;
// 0, sizeof(Test2) > _Any_trivial_space_size
std::cout << std::_Any_is_small<Test2> << std::endl;
// 0, is_nothrow_move_constructible_v<_Ty> == false
std::cout << std::_Any_is_small<Test3> << std::endl;
// 1
std::cout << std::_Any_is_small<Test4> << std::endl;
// 0, is_nothrow_move_constructible_v<_Ty> == false
std::cout << std::_Any_is_small<Test5> << std::endl;// 1
std::cout << std::_Any_is_trivial<char> << std::endl;
// 1
std::cout << std::_Any_is_trivial<int> << std::endl;
// 1
std::cout << std::_Any_is_trivial<double> << std::endl;
// 1
std::cout << std::_Any_is_trivial<Test1> << std::endl;
// 1
std::cout << std::_Any_is_trivial<Test2> << std::endl;
// 0, is_trivially_copyable_v == false
std::cout << std::_Any_is_trivial<Test3> << std::endl;
// 1
std::cout << std::_Any_is_trivial<Test4> << std::endl;
// 0, is_trivially_copyable_v == false
std::cout << std::_Any_is_trivial<Test5> << std::endl;

 下面看看3中模型的数据存储结构：

    //【1】struct _Small_storage_t {unsigned char _Data[_Any_small_space_size];const _Any_small_RTTI* _RTTI;};static_assert(sizeof(_Small_storage_t) == _Any_trivial_space_size);//【2】struct _Big_storage_t {// Pad so that _Ptr and _RTTI might share _TypeData's cache lineunsigned char _Padding[_Any_small_space_size - sizeof(void*)];void* _Ptr;const _Any_big_RTTI* _RTTI;};static_assert(sizeof(_Big_storage_t) == _Any_trivial_space_size);//【3】struct _Storage_t {union {unsigned char _TrivialData[_Any_trivial_space_size];_Small_storage_t _SmallStorage;_Big_storage_t _BigStorage;};uintptr_t _TypeData;};static_assert(sizeof(_Storage_t) == _Any_trivial_space_size + sizeof(void*));static_assert(is_standard_layout_v<_Storage_t>);union {_Storage_t _Storage{};max_align_t _Dummy;};

我们可以看出_Storage_t本身由于一个联合体加上uintptr_t类型的_TypeData，在64位下uintptr_t就是unsigned long long，32位 unsigned int；

• _TypeData，这个实际是MSVC自己实现的，为了方便类型区分，借助了编译器内部类型信息。其什为：_Storage._TypeData = reinterpret_cast<uintptr_t>(&typeid(_Decayed)) | static_cast<uintptr_t>(_Any_representation::_Trivial);其中_Decayed为any要储存类型的模板退化类型，然后用typeid求出std::type_info全局静态类型再取地址，用reinterpret_cast强转，说来说去就是为了类型得到一个类似hash后的数值，这里只是地址，然后再|上_Any_representation枚举值，为了后面来区分类型。
  • enum class _Any_representation : uintptr_t { _Trivial, _Big, _Small }; 类型也比较容易，平凡类对应数值0，大类1，小类2
  • typeid返回type_info这个实现，实际上没有编译器内部实现也可以自己模板实现，模板类有个int型静态常量成员，对类型进行特化，最后也是取地址即可。
  • 为什么_TypeData敢直接或上枚举，因为type_info的大小肯定大于3，两个type_info就算连续存储地址差肯定大于4，所以就算|2的话，从hash角度够用，也不会引发错误。
• _TrivialData[_Any_trivial_space_size];为char数组，其中inline constexpr size_t _Any_trivial_space_size = (_Small_object_num_ptrs - 1) * sizeof(void*);,编译器常量，只要求_Small_object_num_ptrs即可，_Small_object_num_ptrs它又是typeinfo文件中的编译期常量，constexpr int _Small_object_num_ptrs = 6 + 16 / sizeof(void*);,对于64位也就是8，那么可以得出_Any_trivial_space_size为56，所以就是大小为char[56]
• _Small_storage_t;是一个结构体，先是char数组且大小为_Any_small_space_size，这个也是编译期常理，inline constexpr size_t _Any_small_space_size = (_Small_object_num_ptrs - 2) * sizeof(void*);由上面可以就是6* 8 = 48;然后接一个_Any_small_RTTI指针，也是8，大小总共一起还是56
• _Big_storage_t；也是一个结构体，先是char数组且大小为_Any_small_space_size - sizeof(void*)，这由上面可以就是48 - 8 = 40;再接一个8字节void*指针，最后接一个_Any_big_RTTI指针，也是8，大小总共一起还是56

综上可以看出：_Storage_t就是56+8 = 64字节大小，我们对any进行sizeof得到的结果也是64，印证分析，只不过具体一个any的对象是union中三个类型中的一个。

3._Any_big_RTTI与_Any_small_RTTI

Trivial 类型的内存是直接对拷的，对于这种内存无需再添加额外的生命周期指针。按照 Small 内存的定义，对于 Small 内存要添加 in_place 的销毁、拷贝、移动函数指针，而 Big 则需要保存堆内存的拷贝与销毁函数指针。源码中定义了 _Any_small_RTTI 和 _Any_big_RTTI 结构体，来存储这些指针：

struct _Any_big_RTTI { // Hand-rolled vtable for types that must be heap allocated in an anyusing _Destroy_fn = void __CLRCALL_PURE_OR_CDECL(void*) _NOEXCEPT_FNPTR;using _Copy_fn    = void* __CLRCALL_PURE_OR_CDECL(const void*);template <class _Ty>static void __CLRCALL_PURE_OR_CDECL _Destroy_impl(void* const _Target) noexcept {::delete static_cast<_Ty*>(_Target);}template <class _Ty>_NODISCARD static void* __CLRCALL_PURE_OR_CDECL _Copy_impl(const void* const _Source) {return ::new _Ty(*static_cast<const _Ty*>(_Source));}_Destroy_fn* _Destroy;_Copy_fn* _Copy;
};struct _Any_small_RTTI { // Hand-rolled vtable for nontrivial types that can be stored internally in an anyusing _Destroy_fn = void __CLRCALL_PURE_OR_CDECL(void*) _NOEXCEPT_FNPTR;using _Copy_fn    = void __CLRCALL_PURE_OR_CDECL(void*, const void*);using _Move_fn    = void __CLRCALL_PURE_OR_CDECL(void*, void*) _NOEXCEPT_FNPTR;template <class _Ty>static void __CLRCALL_PURE_OR_CDECL _Destroy_impl(void* const _Target) noexcept {_Destroy_in_place(*static_cast<_Ty*>(_Target));}template <class _Ty>static void __CLRCALL_PURE_OR_CDECL _Copy_impl(void* const _Target, const void* const _Source) {_Construct_in_place(*static_cast<_Ty*>(_Target), *static_cast<const _Ty*>(_Source));}template <class _Ty>static void __CLRCALL_PURE_OR_CDECL _Move_impl(void* const _Target, void* const _Source) noexcept {_Construct_in_place(*static_cast<_Ty*>(_Target), _STD move(*static_cast<_Ty*>(_Source)));}_Destroy_fn* _Destroy;_Copy_fn* _Copy;_Move_fn* _Move;
};

• 先看big，先用using重定义了两个函数指针类型_Destroy_fn和_Copy_fn，现在写法都流行用using而不是typedef,不过本身using功能也更强大一些，这个结构体成员是这两个函数指针。再定义两个静态的模板函数，用来创建和释放内存，都是调用系统命名空间::下new与delete，不过new实际调用的是一个拷贝构造的函数。其都是重新申请和释放的内存，只是得到的结果是指针而已。
• 再看small，结构基本等同big，只不过多了一个move的函数，支持移动语义。但仔细看它的三个静态成员函数，其并没有直接实现，而是利用了xutility文件中提供的标准模板函数_Construct_in_place与xmemory文件中的_Destroy_in_place标准模板函数。里面也没做什么，调用palcement new进构造函数调用与最后析构函数，也就是没有真正参与内存分配与释放，只是走了内存池那套流程，在已经分配好的内存上玩一圈。可以提供一下代码，其中_Construct_in_place还是可变模板参数的。

// FUNCTION TEMPLATE _Construct_in_place
template <class _Ty, class... _Types>
_CONSTEXPR20_DYNALLOC void _Construct_in_place(_Ty& _Obj, _Types&&... _Args) noexcept(is_nothrow_constructible_v<_Ty, _Types...>) {
#ifdef __cpp_lib_constexpr_dynamic_allocif (_STD is_constant_evaluated()) {_STD construct_at(_STD addressof(_Obj), _STD forward<_Types>(_Args)...);} else
#endif // __cpp_lib_constexpr_dynamic_alloc{::new (_Voidify_iter(_STD addressof(_Obj))) _Ty(_STD forward<_Types>(_Args)...);}
}template <class _Ty>
_CONSTEXPR20_DYNALLOC void _Destroy_in_place(_Ty& _Obj) noexcept {if constexpr (is_array_v<_Ty>) {_Destroy_range(_Obj, _Obj + extent_v<_Ty>);} else {_Obj.~_Ty();}
}

结构体中首先有对应的函数指针，另外，还提供了带模板的静态实现方法，实际用法是定义模板变量来保存 RTTI 结构体实例，实例中保存对应模板静态方法的指针，来为不同的类型提供 RTTI 功能：

template <class _Ty>
inline constexpr _Any_big_RTTI _Any_big_RTTI_obj = {&_Any_big_RTTI::_Destroy_impl<_Ty>, &_Any_big_RTTI::_Copy_impl<_Ty>};template <class _Ty>
inline constexpr _Any_small_RTTI _Any_small_RTTI_obj = {&_Any_small_RTTI::_Destroy_impl<_Ty>, &_Any_small_RTTI::_Copy_impl<_Ty>, &_Any_small_RTTI::_Move_impl<_Ty>};

4.std::any的构造函数

4.1.从std::any构造

    constexpr any() noexcept {}any(const any& _That) {_Storage._TypeData = _That._Storage._TypeData;switch (_Rep()) {case _Any_representation::_Small:_Storage._SmallStorage._RTTI = _That._Storage._SmallStorage._RTTI;_Storage._SmallStorage._RTTI->_Copy(&_Storage._SmallStorage._Data, &_That._Storage._SmallStorage._Data);break;case _Any_representation::_Big:_Storage._BigStorage._RTTI = _That._Storage._BigStorage._RTTI;_Storage._BigStorage._Ptr  = _Storage._BigStorage._RTTI->_Copy(_That._Storage._BigStorage._Ptr);break;case _Any_representation::_Trivial:default:_CSTD memcpy(_Storage._TrivialData, _That._Storage._TrivialData, sizeof(_Storage._TrivialData));break;}}any(any&& _That) noexcept {_Move_from(_That);}

• 无参普通构造什么也没做
• 拷贝构造先拷贝_TypeData，再处理_Storage的联合体，也就是处理对应的类型_Rep（）直接返回类型，其原理也很简单，static_cast<_Any_representation>(_Storage._TypeData & _Rep_mask);,_Rep_mask前面提过是3，就这么轻松把类型提取出来了。再接着就是RTTI指针的拷贝，对于真正的数据，small型栈上move操作，并不真正分配内存，big型是真正new一下内存拷贝构造，trivial更是简单，只需要直接拷贝内存就可以了。
• 移动语义拷贝构造,调用_Move_from，这个其实也简单，相比普通拷贝，small型调用move操作，big型拷贝内存指针，不重新申请内存，平凡性当然移动语义在这意义不大，直接还是内存拷贝。参见代码：

void _Move_from(any& _That) noexcept {_Storage._TypeData = _That._Storage._TypeData;switch (_Rep()) {case _Any_representation::_Small:_Storage._SmallStorage._RTTI = _That._Storage._SmallStorage._RTTI;_Storage._SmallStorage._RTTI->_Move(&_Storage._SmallStorage._Data, &_That._Storage._SmallStorage._Data);break;case _Any_representation::_Big:_Storage._BigStorage._RTTI = _That._Storage._BigStorage._RTTI;_Storage._BigStorage._Ptr  = _That._Storage._BigStorage._Ptr;_That._Storage._TypeData   = 0;break;case _Any_representation::_Trivial:default:_CSTD memcpy(_Storage._TrivialData, _That._Storage._TrivialData, sizeof(_Storage._TrivialData));break;}}

4.2.可变参数模板构造函数

template <class _ValueType, enable_if_t<conjunction_v<negation<is_same<decay_t<_ValueType>, any>>,is_copy_constructible<decay_t<_ValueType>>>,int> = 0>any& operator=(_ValueType&& _Value) {// replace contained value with an object of type decay_t<_ValueType> initialized from _Value*this = any{_STD forward<_ValueType>(_Value)};return *this;}// Modifiers [any.modifiers]template <class _ValueType, class... _Types,enable_if_t<conjunction_v<is_constructible<decay_t<_ValueType>, _Types...>, is_copy_constructible<decay_t<_ValueType>>>,int> = 0>decay_t<_ValueType>& emplace(_Types&&... _Args) {// replace contained value with an object of type decay_t<_ValueType> initialized from _Args...reset();return _Emplace<decay_t<_ValueType>>(_STD forward<_Types>(_Args)...);}template <class _ValueType, class _Elem, class... _Types,enable_if_t<conjunction_v<is_constructible<decay_t<_ValueType>, initializer_list<_Elem>&, _Types...>,is_copy_constructible<decay_t<_ValueType>>>,int> = 0>decay_t<_ValueType>& emplace(initializer_list<_Elem> _Ilist, _Types&&... _Args) {// replace contained value with an object of type decay_t<_ValueType> initialized from _Ilist and _Args...reset();return _Emplace<decay_t<_ValueType>>(_Ilist, _STD forward<_Types>(_Args)...);}

• 一个参数的构造，enable_if_t在以前的文长说过了，主要为了借助SFINAE编译期判断，假设条件不通过，返回并没有定义type，否则返回int，并初始值为0，假如不能通过设为0为报错的，也就是匹配不成功，所有都失败，才会编译错误。就是能用一个参数进行构造，会走这里。
• 可变参数的构造，结构基本同前面分析。注意一下，这个是explicit显式的函数，第一个参数传占位符，后面根构造用的参数。
• 带初始化列表的构造，结构基本同前面分析。注意一下，这个是explicit显式的函数，第一个参数传占位符，第二个是初始化列表，后面跟具体的的参数。

三者的重点其实都落到了，_Emplace函数上了，我们看看具体实现

template <class _Decayed, class... _Types>_Decayed& _Emplace(_Types&&... _Args) { // emplace construct _Decayedif constexpr (_Any_is_trivial<_Decayed>) {// using the _Trivial representationauto& _Obj = reinterpret_cast<_Decayed&>(_Storage._TrivialData);_Construct_in_place(_Obj, _STD forward<_Types>(_Args)...);_Storage._TypeData =reinterpret_cast<uintptr_t>(&typeid(_Decayed)) | static_cast<uintptr_t>(_Any_representation::_Trivial);return _Obj;} else if constexpr (_Any_is_small<_Decayed>) {// using the _Small representationauto& _Obj = reinterpret_cast<_Decayed&>(_Storage._SmallStorage._Data);_Construct_in_place(_Obj, _STD forward<_Types>(_Args)...);_Storage._SmallStorage._RTTI = &_Any_small_RTTI_obj<_Decayed>;_Storage._TypeData =reinterpret_cast<uintptr_t>(&typeid(_Decayed)) | static_cast<uintptr_t>(_Any_representation::_Small);return _Obj;} else {// using the _Big representation_Decayed* const _Ptr       = ::new _Decayed(_STD forward<_Types>(_Args)...);_Storage._BigStorage._Ptr  = _Ptr;_Storage._BigStorage._RTTI = &_Any_big_RTTI_obj<_Decayed>;_Storage._TypeData =reinterpret_cast<uintptr_t>(&typeid(_Decayed)) | static_cast<uintptr_t>(_Any_representation::_Big);return *_Ptr;}}

可以看出_Emplace是any与真正的类型转换实现，这个模板第一个参数作了返回值，是无法推断的，必显示的传入，我们也看到都是显示传入T的退化类型的。有了前部分的分析，也是非常的容易了，先判断是trivial还是small还是big类型，方法已经说过。

• trivial:这种来说，真接内存强转，然后_Construct_in_place实质是STL的方法，就是调用placement new进行构造的，再设置_TypeData，这些都是容易处理的。
• small这里和trivial没有本质上的区别，只是内存变成48字节内了，然后多了一个RTTI指针获取，构造函数也真正起作用，不像tirival
• big类型更是容易，直接new内存进行显示的T（args...）构造，模板参数包展开，他们都是万能引用与完美转发，然后将申请并初始化的内存地址交给了_Storage._BigStorage._Ptr

总结：small型与trivial型都是没有直接进行堆内存再申请，，在any已经有的64个字节内强转操作，不同的small会真正处理调用构造函数，big型来说是进行再次堆内存申请，然后存其指针。

4.3.赋值构造与emplace函数

这个没什么好说的，实际还是调用前面说的拷贝构造与带参的构造,包装过一层而已。

// Assignment [any.assign]any& operator=(const any& _That) {*this = any{_That};return *this;}any& operator=(any&& _That) noexcept {reset();_Move_from(_That);return *this;}template <class _ValueType, enable_if_t<conjunction_v<negation<is_same<decay_t<_ValueType>, any>>,is_copy_constructible<decay_t<_ValueType>>>,int> = 0>any& operator=(_ValueType&& _Value) {// replace contained value with an object of type decay_t<_ValueType> initialized from _Value*this = any{_STD forward<_ValueType>(_Value)};return *this;}// Modifiers [any.modifiers]template <class _ValueType, class... _Types,enable_if_t<conjunction_v<is_constructible<decay_t<_ValueType>, _Types...>, is_copy_constructible<decay_t<_ValueType>>>,int> = 0>decay_t<_ValueType>& emplace(_Types&&... _Args) {// replace contained value with an object of type decay_t<_ValueType> initialized from _Args...reset();return _Emplace<decay_t<_ValueType>>(_STD forward<_Types>(_Args)...);}template <class _ValueType, class _Elem, class... _Types,enable_if_t<conjunction_v<is_constructible<decay_t<_ValueType>, initializer_list<_Elem>&, _Types...>,is_copy_constructible<decay_t<_ValueType>>>,int> = 0>decay_t<_ValueType>& emplace(initializer_list<_Elem> _Ilist, _Types&&... _Args) {// replace contained value with an object of type decay_t<_ValueType> initialized from _Ilist and _Args...reset();return _Emplace<decay_t<_ValueType>>(_Ilist, _STD forward<_Types>(_Args)...);}

从中可以看出，operator=、emplace内部都是调用的_Emplace。

5.reset函数

void reset() noexcept { // transition to the empty stateswitch (_Rep()) {case _Any_representation::_Small:_Storage._SmallStorage._RTTI->_Destroy(&_Storage._SmallStorage._Data);break;case _Any_representation::_Big:_Storage._BigStorage._RTTI->_Destroy(_Storage._BigStorage._Ptr);break;case _Any_representation::_Trivial:default:break;}_Storage._TypeData = 0;}

        reset就是调用析构和释放内存的，对于small来说，不用释放内存，内部直接调用析构，对于big来说，其实际是delete，即析构还释放内存，对trivial来说，不用处理内存相关，最后都将_TypeData清零。

6._Cast函数

template <class _Decayed>_NODISCARD const _Decayed* _Cast() const noexcept {// if *this contains a value of type _Decayed, return a pointer to itconst type_info* const _Info = _TypeInfo();if (!_Info || *_Info != typeid(_Decayed)) {return nullptr;}if constexpr (_Any_is_trivial<_Decayed>) {// get a pointer to the contained _Trivial value of type _Decayedreturn reinterpret_cast<const _Decayed*>(&_Storage._TrivialData);} else if constexpr (_Any_is_small<_Decayed>) {// get a pointer to the contained _Small value of type _Decayedreturn reinterpret_cast<const _Decayed*>(&_Storage._SmallStorage._Data);} else {// get a pointer to the contained _Big value of type _Decayedreturn static_cast<const _Decayed*>(_Storage._BigStorage._Ptr);}}template <class _Decayed>_NODISCARD _Decayed* _Cast() noexcept { // if *this contains a value of type _Decayed, return a pointer to itreturn const_cast<_Decayed*>(static_cast<const any*>(this)->_Cast<_Decayed>());}

_Cast是类型转换，提供const与非const两个版本，也是内存地址强转，big用的_Storage._BigStorage._Ptr，samll用&_Storage._SmallStorage._Data，当然trivial用的是&_Storage._TrivialData。

7.make_any模版函数

template <class _ValueType, class... _Types>
_NODISCARD any make_any(_Types&&... _Args) { // construct an any containing a _ValueType initialized with _Args...return any{in_place_type<_ValueType>, _STD forward<_Types>(_Args)...};
}
template <class _ValueType, class _Elem, class... _Types>
_NODISCARD any make_any(initializer_list<_Elem> _Ilist, _Types&&... _Args) {// construct an any containing a _ValueType initialized with _Ilist and _Args...return any{in_place_type<_ValueType>, _Ilist, _STD forward<_Types>(_Args)...};
}

就是将参数透传到 std::any 的初始化列表构造并执行。

8.std::any_cast函数

template <class _ValueType>
_NODISCARD const _ValueType* any_cast(const any* const _Any) noexcept {// retrieve a pointer to the _ValueType contained in _Any, or nullstatic_assert(!is_void_v<_ValueType>, "std::any cannot contain void.");if constexpr (is_function_v<_ValueType> || is_array_v<_ValueType>) {return nullptr;} else {if (!_Any) {return nullptr;}return _Any->_Cast<_Remove_cvref_t<_ValueType>>();}
}
template <class _ValueType>
_NODISCARD _ValueType* any_cast(any* const _Any) noexcept {// retrieve a pointer to the _ValueType contained in _Any, or nullstatic_assert(!is_void_v<_ValueType>, "std::any cannot contain void.");if constexpr (is_function_v<_ValueType> || is_array_v<_ValueType>) {return nullptr;} else {if (!_Any) {return nullptr;}return _Any->_Cast<_Remove_cvref_t<_ValueType>>();}
}template <class _Ty>
_NODISCARD remove_cv_t<_Ty> any_cast(const any& _Any) {static_assert(is_constructible_v<remove_cv_t<_Ty>, const _Remove_cvref_t<_Ty>&>,"any_cast<T>(const any&) requires remove_cv_t<T> to be constructible from ""const remove_cv_t<remove_reference_t<T>>&");const auto _Ptr = _STD any_cast<_Remove_cvref_t<_Ty>>(&_Any);if (!_Ptr) {_Throw_bad_any_cast();}return static_cast<remove_cv_t<_Ty>>(*_Ptr);
}
template <class _Ty>
_NODISCARD remove_cv_t<_Ty> any_cast(any& _Any) {static_assert(is_constructible_v<remove_cv_t<_Ty>, _Remove_cvref_t<_Ty>&>,"any_cast<T>(any&) requires remove_cv_t<T> to be constructible from remove_cv_t<remove_reference_t<T>>&");const auto _Ptr = _STD any_cast<_Remove_cvref_t<_Ty>>(&_Any);if (!_Ptr) {_Throw_bad_any_cast();}return static_cast<remove_cv_t<_Ty>>(*_Ptr);
}
template <class _Ty>
_NODISCARD remove_cv_t<_Ty> any_cast(any&& _Any) {static_assert(is_constructible_v<remove_cv_t<_Ty>, _Remove_cvref_t<_Ty>>,"any_cast<T>(any&&) requires remove_cv_t<T> to be constructible from remove_cv_t<remove_reference_t<T>>");const auto _Ptr = _STD any_cast<_Remove_cvref_t<_Ty>>(&_Any);if (!_Ptr) {_Throw_bad_any_cast();}return static_cast<remove_cv_t<_Ty>>(_STD move(*_Ptr));
}

所有 std::any_cast 最终都会先取保存的 std::type_info 然后与目标类型相比较，失败则抛出 std::bad_any_cast，否则则返回 value。这里要注意的是返回的类型会根据 std::any_cast 的入参产生变化：

• const any* const -> const _ValueType*
• any* const _Any -> _ValueType*
• const any& _Any -> remove_cv_t<_Ty>
• any& _Any -> remove_cv_t<_Ty>
• any&& _Any -> remove_cv_t<_Ty>

总结起来就是入参的 std::any 为指针时，返回指针，否则返回 remove_cv_t<_Ty>，所以使用时如果对应的是结构体 / 类，应该尽量获取指针或者引用来保持高效，避免内存拷贝降低性能（例子可以看前面的介绍）。

9.总结

        到此我们已经全部分析完毕，任何做技术的都是要知其然，更好知其所以然。只要这样，才能把这些设计手法运用到我们平时的项目当中，只有你能熟练的运用了才是真正的掌握了。还是那句话，纸上得来终觉浅，绝知此事要躬行。

相关推荐阅读

std::is_trivially_copyable

std::is_move_constructible

C++内存分配策略