c++智能3种指针源码分析汇总

#include<iostream> using namespace std; /*template <class _From, class _To> bool is_convertible_v = __is_convertible_to(_From, _To); template <bool _Test, class _Ty = void> // no member "type" when !_Test struct enable_if {}; template <class _Ty> // type is _Ty for _Test struct enable_if<true, _Ty> { using type = _Ty; }; template <bool _Test, class _Ty = void> using enable_if_t = typename enable_if<_Test, _Ty>::type;*/ template <class _Ty> struct default_delete { // default deleter for unique_ptr default_delete() = default; template <class _Ty2, enable_if_t<is_convertible_v<_Ty2*, _Ty*>, int> = 0> default_delete(const default_delete<_Ty2>&) noexcept {} void operator()(_Ty* _Ptr) /* strengthened */ { // delete a pointer static_assert(0 < sizeof(_Ty), "can't delete an incomplete type"); delete _Ptr; } }; template <class _Ty> // default deleter for unique_ptr to array of unknown size struct default_delete<_Ty[]> { default_delete() = default; template <class _Uty, enable_if_t<is_convertible_v<_Uty(*)[], _Ty(*)[]>, int> = 0> default_delete(const default_delete<_Uty[]>&) noexcept {} template <class _Uty, enable_if_t<is_convertible_v<_Uty(*)[], _Ty(*)[]>, int> = 0> void operator()(_Uty* _Ptr) /* strengthened */ { // delete a pointer static_assert(0 < sizeof(_Uty), "can't delete an incomplete type"); delete[] _Ptr; } }; //////////////////////////////////////////////////////////////////////////////////// // class for reference counted resource management template <class _Ty> class shared_ptr : public _Ptr_base<_Ty> { private: using _Mybase = _Ptr_base<_Ty>; public: /*class _Ref_count_base { private: _Atomic_counter_t _Uses = 1; _Atomic_counter_t _Weaks = 1;}; template <class _Ty> class _Ptr_base { private: element_type* _Ptr{ nullptr }; _Ref_count_base* _Rep{ nullptr }; public: using element_type = remove_extent_t<_Ty>; }; template <class _Ty> struct remove_extent { using type = _Ty;}; template <class _Ty, size_t _Ix> struct remove_extent<_Ty[_Ix]> {using type = _Ty;}; template <class _Ty> struct remove_extent<_Ty[]> { using type = _Ty;}; template <class _Ty> using remove_extent_t = typename remove_extent<_Ty>::type; */ using typename _Mybase::element_type; shared_ptr() = default; shared_ptr(nullptr_t) {} // construct empty shared_ptr /* template <class _From, class _To> struct is_convertible : bool_constant<__is_convertible_to(_From, _To)> { // determine whether _From is convertible to _To }; */ /* template <class _Yty, class _Ty> struct _SP_convertible : is_convertible<_Yty*, _Ty*>::type {}; template <class _Yty, class _Uty> struct _SP_convertible<_Yty, _Uty[]> : is_convertible<_Yty (*)[], _Uty (*)[]>::type {}; template <class _Yty, class _Uty, size_t _Ext> struct _SP_convertible<_Yty, _Uty[_Ext]> : is_convertible<_Yty (*)[_Ext], _Uty (*)[_Ext]>::type {}; */ /* template <class _Yty, class = void> struct _Can_scalar_delete : false_type {}; template <class _Yty> struct _Can_scalar_delete< //数量 _Yty, void_t<decltype(delete _STD declval<_Yty*>())> > : true_type {}; template <class _Yty, class = void> struct _Can_array_delete : false_type {}; template <class _Yty> struct _Can_array_delete< _Yty, void_t<decltype(delete[] _STD declval<_Yty*>())> > : true_type {}; */ /* // Choose _Ty1 if _Test is true, and _Ty2 otherwise template <bool _Test, class _Ty1, class _Ty2> struct conditional { using type = _Ty1;}; template <class _Ty1, class _Ty2> struct conditional<false, _Ty1, _Ty2> { using type = _Ty2;}; template <bool _Test, class _Ty1, class _Ty2> using conditional_t = typename conditional<_Test, _Ty1, _Ty2>::type; */ /* template <bool _First_value, class _First, class... _Rest> struct _Conjunction { using type = _First;};// handle false trait or last trait template <class _True, class _Next, class... _Rest> struct _Conjunction<true, _True, _Next, _Rest...> { using type = typename _Conjunction<_Next::value, _Next, _Rest...>::type; };// the first trait is true, try the next one template <class... _Traits> struct conjunction : true_type {}; // If _Traits is empty, true_type template <class _First, class... _Rest> struct conjunction<_First, _Rest...> : _Conjunction<_First::value, _First, _Rest...>::type {}; // the first false trait in _Traits, or the last trait if none are false template <class... _Traits> bool conjunction_v = conjunction<_Traits...>::value; */ template <class _Ux, enable_if_t< conjunction_v< conditional_t<is_array_v<_Ty>, _Can_array_delete<_Ux>, _Can_scalar_delete<_Ux>>, _SP_convertible<_Ux, _Ty> >, int> = 0> explicit shared_ptr(_Ux* _Px) { // construct shared_ptr object that owns _Px if (is_array_v<_Ty>) { _Setpd(_Px, default_delete<_Ux[]>{}); //定义在本类 } /* // determine whether type argument is an array template <class> bool is_array_v = false; template <class _Ty, size_t _Nx> bool is_array_v<_Ty[_Nx]> = true; template <class _Ty> bool is_array_v<_Ty[]> = true; */ /* template <class _UxptrOrNullptr, class _Dx> // take ownership of _Px, deleter _Dt void _Setpd(const _UxptrOrNullptr _Px, _Dx _Dt) { _Temporary_owner_del<_UxptrOrNullptr, _Dx> _Owner(_Px, _Dt); _Set_ptr_rep_and_enable_shared( _Owner._Ptr, new _Ref_count_resource<_UxptrOrNullptr, _Dx>(_Owner._Ptr, _STD move(_Dt)) ); _Owner._Call_deleter = false; } */ /* template <class _UxptrOrNullptr, class _Dx> struct _Temporary_owner_del { _UxptrOrNullptr _Ptr; _Dx& _Dt; bool _Call_deleter = true; explicit _Temporary_owner_del(const _UxptrOrNullptr _Ptr_, _Dx& _Dt_) noexcept : _Ptr(_Ptr_), _Dt(_Dt_) {} _Temporary_owner_del(const _Temporary_owner_del&) = delete; _Temporary_owner_del& operator=(const _Temporary_owner_del&) = delete; ~_Temporary_owner_del() { if (_Call_deleter) _Dt(_Ptr); } }; */ /* template <class _Ty1, class _Ty2> class _Compressed_pair<_Ty1, _Ty2, false> final{ public: _Ty1 _Myval1; _Ty2 _Myval2;} template <class _Resource, class _Dx> class _Ref_count_resource : public _Ref_count_base {public: _Ref_count_resource(_Resource _Px, _Dx _Dt) :_Ref_count_base(), _Mypair(_One_then_variadic_args_t{}, _STD move(_Dt), _Px) {} private: _Compressed_pair<_Dx, _Resource> _Mypair; }; */ else { _Temporary_owner<_Ux> _Owner(_Px); _Set_ptr_rep_and_enable_shared(_Owner._Ptr, new _Ref_count<_Ux>(_Owner._Ptr)); _Owner._Ptr = nullptr; } } /* template <class _Ux> struct _Temporary_owner { _Ux* _Ptr; explicit _Temporary_owner(_Ux* const _Ptr_) : _Ptr(_Ptr_) {} _Temporary_owner(const _Temporary_owner&) = delete; _Temporary_owner& operator=(const _Temporary_owner&) = delete; ~_Temporary_owner() { delete _Ptr; } }; */ /* template <class _Ty> class _Ref_count : public _Ref_count_base { public: explicit _Ref_count(_Ty* _Px) : _Ref_count_base(), _Ptr(_Px) {} private: _Ty* _Ptr; }; */ /* template <class _Ux> // take ownership of _Px void _Set_ptr_rep_and_enable_shared(_Ux* const _Px, _Ref_count_base* const _Rx) { this->_Ptr = _Px; this->_Rep = _Rx; if (conjunction_v< negation<is_array<_Ty>>, negation<is_volatile<_Ux>>, _Can_enable_shared<_Ux> >) { if (_Px && _Px->_Wptr.expired()) _Px->_Wptr = shared_ptr<remove_cv_t<_Ux>>(*this, const_cast<remove_cv_t<_Ux>*>(_Px)); } } */ /*