vs2019 cpp 20规范 智能指针和STL常用容器类模板的源码注释以及 string 类

// map standard header // Copyright (c) Microsoft Corporation. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception #pragma once #ifndef _MAP_ #define _MAP_ #include <yvals_core.h> #if _STL_COMPILER_PREPROCESSOR #include <tuple> #include <xtree> #if _HAS_CXX17 #include <xpolymorphic_allocator.h> #endif // _HAS_CXX17 #pragma pack(push, _CRT_PACKING) #pragma warning(push, _STL_WARNING_LEVEL) #pragma warning(disable : _STL_DISABLED_WARNINGS) _STL_DISABLE_CLANG_WARNINGS #pragma push_macro("new") #undef new _STD_BEGIN template <class _Alloc> struct _Alloc_construct_ptr { // pointer used to help construct 1 _Alloc::value_type without EH using pointer = _Alloc_ptr_t<_Alloc>; _Alloc& _Al; pointer _Ptr; explicit _Alloc_construct_ptr(_Alloc& _Al_) : _Al(_Al_), _Ptr(nullptr) {} pointer _Release() { return _STD exchange(_Ptr, nullptr); } // disengage *this and return contained pointer 解除*this并返回包含的指针 void _Allocate() { _Ptr = nullptr; _Ptr = _Al.allocate(1); } // disengage *this, then allocate a new memory block 解除这个，然后分配一个新的内存块 // if allocate throws, prevents double-free ~_Alloc_construct_ptr() { if (_Ptr) _Al.deallocate(_Ptr, 1); } // if this instance is engaged, deallocate storage _Alloc_construct_ptr(const _Alloc_construct_ptr&) = delete; _Alloc_construct_ptr& operator=(const _Alloc_construct_ptr&) = delete; }; template <class _Alnode> struct _Tree_temp_node_alloc : _Alloc_construct_ptr<_Alnode> { // EH helper for _Tree_temp_node explicit _Tree_temp_node_alloc(_Alnode& _Al_) : _Alloc_construct_ptr<_Alnode>(_Al_) { _Alloc_construct_ptr<_Alnode>::_Allocate(); } _Tree_temp_node_alloc(const _Tree_temp_node_alloc&) = delete; _Tree_temp_node_alloc& operator=(const _Tree_temp_node_alloc&) = delete; }; template <class _Alnode> struct _Tree_temp_node : _Tree_temp_node_alloc<_Alnode> { // temporarily stores a constructed tree node 临时存储构造的树节点 using _Alnode_traits = allocator_traits<_Alnode>; using _Nodeptr = typename _Alnode_traits::pointer; enum _Redbl { _Red, _Black };// colors for link to parent template <class... _Valtys> explicit _Tree_temp_node(_Alnode& _Al_, _Nodeptr _Myhead, _Valtys&&... _Vals) : _Tree_temp_node_alloc<_Alnode>(_Al_) { _Alnode_traits::construct(this->_Al, _STD addressof(this->_Ptr->_Myval), _STD forward<_Valtys>(_Vals)...); _Construct_in_place(this->_Ptr->_Left, _Myhead); _Construct_in_place(this->_Ptr->_Parent, _Myhead); _Construct_in_place(this->_Ptr->_Right, _Myhead); this->_Ptr->_Color = _Red; this->_Ptr->_Isnil = false; } _Tree_temp_node(const _Tree_temp_node&) = delete; _Tree_temp_node& operator=(const _Tree_temp_node&) = delete; ~_Tree_temp_node() { if (this->_Ptr) { _Destroy_in_place(this->_Ptr->_Left); _Destroy_in_place(this->_Ptr->_Parent); /* template <class _Ty> void destroy_at(_Ty* const _Location) { if constexpr (is_array_v<_Ty>) _Destroy_range(_STD begin(*_Location), _STD end(*_Location)); else _Location->~_Ty(); } template <class _Ty> void _Destroy_in_place(_Ty& _Obj) { if constexpr (is_array_v<_Ty>) _Destroy_range(_Obj, _Obj + extent_v<_Ty>); else _Obj.~_Ty(); } template <class _Alloc> struct _Default_allocator_traits { template <class _Uty> static void destroy(_Alloc&, _Uty* const _Ptr) { _STD destroy_at(_Ptr); } }; */ _Destroy_in_place(this->_Ptr->_Right); _Alnode_traits::destroy(this->_Al, _STD addressof(this->_Ptr->_Myval)); } } }; //----------------------------------------------------------------------------------- template <class _Alnode, class _Scary_val> struct _Tree_head_scoped_ptr { // temporary storage for allocated node pointers to ensure exception safety //为确保异常安全而分配的节点指针的临时存储 _Alnode& _Al; _Scary_val* _Mycont; _Tree_head_scoped_ptr(_Alnode& _Al_, _Scary_val& _Mycont_) : _Al(_Al_), _Mycont(_STD addressof(_Mycont_)) { _Mycont->_Myhead = _Alnode::value_type::_Buyheadnode(_Al); } void _Release() { _Mycont = nullptr; } ~_Tree_head_scoped_ptr() { if (_Mycont) _Mycont->_Erase_head(_Al); } }; //----------------------------------------------------------------------------------- /* struct _Iterator_base0 { void _Adopt(const void*) {} const _Container_base0* _Getcont() { return nullptr; } static bool _Unwrap_when_unverified = true; }; */ template <class _Mytree, class _Base = _Iterator_base0> class _Tree_unchecked_const_iterator : public _Base { public: using iterator_category = bidirectional_iterator_tag; using _Nodeptr = typename _Mytree::_Nodeptr; using value_type = typename _Mytree::value_type; using difference_type = typename _Mytree::difference_type; using pointer = typename _Mytree::const_pointer; using reference = const value_type&; _Nodeptr _Ptr; // pointer to node _Tree_unchecked_const_iterator() noexcept : _Ptr() {} _Tree_unchecked_const_iterator(_Nodeptr _Pnode, const _Mytree* _Plist) : _Ptr(_Pnode) { this->_Adopt(_Plist); } /* struct _Iterator_base12 { bool _Unwrap_when_unverified = _ITERATOR_DEBUG_LEVEL == 0; mutable _Container_proxy* _Myproxy = nullptr; mutable _Iterator_base12* _Mynextiter = nullptr; void _Adopt_unlocked(const _Container_base12* _Parent) noexcept { if (!_Parent) { _Orphan_me_unlocked_v3(); return; } _Container_proxy* _Parent_proxy = _Parent->_Myproxy; if (_Myproxy != _Parent_proxy) { // change parentage if (_Myproxy) _Orphan_me_unlocked_v3(); // adopted, remove self from list _Mynextiter = _Parent_proxy->_Myfirstiter; _Parent_proxy->_Myfirstiter = this; _Myproxy = _Parent_proxy; } } void _Adopt_locked(const _Container_base12* _Parent) { _Lockit _Lock(_LOCK_DEBUG); _Adopt_unlocked(_Parent); } void _Adopt(const _Container_base12* _Parent) { if (_STD is_constant_evaluated()) _Adopt_unlocked(_Parent); else _Adopt_locked(_Parent); } }; */ reference operator*() { return _Ptr->_Myval; } /* template <class _Value_type, class _Voidptr> struct _Tree_node using value_type = _Value_type; value_type _Myval; }; template <class _Kty, class _Ty, class _Pr, class _Alloc, bool _Mfl> class _Tmap_traits {public: using key_type = _Kty; using value_type = pair<const _Kty, _Ty>; using node_type = _Node_handle<_Tree_node<value_type, typename allocator_traits<_Alloc>::void_pointer>, _Alloc, _Node_handle_map_base, _Kty, _Ty>; }; template <class _Kty, class _Ty, class _Pr = less<_Kty>, class _Alloc = allocator<pair<const _Kty, _Ty>>> class map : public _Tree<_Tmap_traits<_Kty, _Ty, _Pr, _Alloc, false>> {}; */ /* 对 **this 的解读为调用 reference operator*() {return this->_Ptr->_Myval;} */ /* template <class _Ty> struct pointer_traits {