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

2024-05-24 06:52
文章标签 c++ 源码 剖析 std 三剑客

本文主要是介绍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++内存分配策略

这篇关于C++三剑客之std::any(二) : 源码剖析的文章就介绍到这儿,希望我们推荐的文章对编程师们有所帮助!



http://www.chinasem.cn/article/997683

相关文章

【C++ Primer Plus习题】13.4

大家好,这里是国中之林! ❥前些天发现了一个巨牛的人工智能学习网站,通俗易懂,风趣幽默,忍不住分享一下给大家。点击跳转到网站。有兴趣的可以点点进去看看← 问题: 解答: main.cpp #include <iostream>#include "port.h"int main() {Port p1;Port p2("Abc", "Bcc", 30);std::cout <<

C++包装器

包装器 在 C++ 中,“包装器”通常指的是一种设计模式或编程技巧,用于封装其他代码或对象,使其更易于使用、管理或扩展。包装器的概念在编程中非常普遍,可以用于函数、类、库等多个方面。下面是几个常见的 “包装器” 类型: 1. 函数包装器 函数包装器用于封装一个或多个函数,使其接口更统一或更便于调用。例如,std::function 是一个通用的函数包装器,它可以存储任意可调用对象(函数、函数

C++11第三弹:lambda表达式 | 新的类功能 | 模板的可变参数

🌈个人主页: 南桥几晴秋 🌈C++专栏: 南桥谈C++ 🌈C语言专栏: C语言学习系列 🌈Linux学习专栏: 南桥谈Linux 🌈数据结构学习专栏: 数据结构杂谈 🌈数据库学习专栏: 南桥谈MySQL 🌈Qt学习专栏: 南桥谈Qt 🌈菜鸡代码练习: 练习随想记录 🌈git学习: 南桥谈Git 🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈�

JAVA智听未来一站式有声阅读平台听书系统小程序源码

智听未来,一站式有声阅读平台听书系统 🌟&nbsp;开篇:遇见未来,从“智听”开始 在这个快节奏的时代,你是否渴望在忙碌的间隙,找到一片属于自己的宁静角落?是否梦想着能随时随地,沉浸在知识的海洋,或是故事的奇幻世界里?今天,就让我带你一起探索“智听未来”——这一站式有声阅读平台听书系统,它正悄悄改变着我们的阅读方式,让未来触手可及! 📚&nbsp;第一站:海量资源,应有尽有 走进“智听

【C++】_list常用方法解析及模拟实现

相信自己的力量,只要对自己始终保持信心,尽自己最大努力去完成任何事,就算事情最终结果是失败了,努力了也不留遗憾。💓💓💓 目录   ✨说在前面 🍋知识点一:什么是list? •🌰1.list的定义 •🌰2.list的基本特性 •🌰3.常用接口介绍 🍋知识点二:list常用接口 •🌰1.默认成员函数 🔥构造函数(⭐) 🔥析构函数 •🌰2.list对象

06 C++Lambda表达式

lambda表达式的定义 没有显式模版形参的lambda表达式 [捕获] 前属性 (形参列表) 说明符 异常 后属性 尾随类型 约束 {函数体} 有显式模版形参的lambda表达式 [捕获] <模版形参> 模版约束 前属性 (形参列表) 说明符 异常 后属性 尾随类型 约束 {函数体} 含义 捕获:包含零个或者多个捕获符的逗号分隔列表 模板形参:用于泛型lambda提供个模板形参的名

6.1.数据结构-c/c++堆详解下篇(堆排序,TopK问题)

上篇:6.1.数据结构-c/c++模拟实现堆上篇(向下,上调整算法,建堆,增删数据)-CSDN博客 本章重点 1.使用堆来完成堆排序 2.使用堆解决TopK问题 目录 一.堆排序 1.1 思路 1.2 代码 1.3 简单测试 二.TopK问题 2.1 思路(求最小): 2.2 C语言代码(手写堆) 2.3 C++代码(使用优先级队列 priority_queue)

Java ArrayList扩容机制 (源码解读)

结论:初始长度为10,若所需长度小于1.5倍原长度,则按照1.5倍扩容。若不够用则按照所需长度扩容。 一. 明确类内部重要变量含义         1:数组默认长度         2:这是一个共享的空数组实例,用于明确创建长度为0时的ArrayList ,比如通过 new ArrayList<>(0),ArrayList 内部的数组 elementData 会指向这个 EMPTY_EL

如何在Visual Studio中调试.NET源码

今天偶然在看别人代码时,发现在他的代码里使用了Any判断List<T>是否为空。 我一般的做法是先判断是否为null,再判断Count。 看了一下Count的源码如下: 1 [__DynamicallyInvokable]2 public int Count3 {4 [__DynamicallyInvokable]5 get

【C++高阶】C++类型转换全攻略:深入理解并高效应用

📝个人主页🌹:Eternity._ ⏩收录专栏⏪:C++ “ 登神长阶 ” 🤡往期回顾🤡:C++ 智能指针 🌹🌹期待您的关注 🌹🌹 ❀C++的类型转换 📒1. C语言中的类型转换📚2. C++强制类型转换⛰️static_cast🌞reinterpret_cast⭐const_cast🍁dynamic_cast 📜3. C++强制类型转换的原因📝