devbox
喵喵爱编程
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

GNU C++ 智能指针16- 解析__shared_ptr类4_ptr4类型

作者：喵喵爱编程 | 2024-08-19 00:54:18

赞

踩

ptr4类型

目录

一、关键点解析

1、_S_raw_ptr

2、__addressof

4、static_pointer_cast、const_pointer_cast和dynamic_pointer_cast

5、与bool类型的转换

6、与nullptr_t的比较

二、源码分析

一、关键点解析

1、_S_raw_ptr

  1.       template<typename _Tp1>
  2. 	static _Tp1*
  3. 	_S_raw_ptr(_Tp1* __ptr)
  4. 	{ return __ptr; }
  5.  
  6.       template<typename _Tp1>
  7. 	static auto
  8. 	_S_raw_ptr(_Tp1 __ptr) -> decltype(std::__addressof(*__ptr))
  9. 	{ return std::__addressof(*__ptr); }

    对于C ++ 11，如果您想使用auto作为返回类型，则需要以这种方式描述有效的返回类型

auto funcName (args...) -> returnType

2、__addressof

  1. namespace std _GLIBCXX_VISIBILITY(default)
  2. {
  3. _GLIBCXX_BEGIN_NAMESPACE_VERSION
  4.  
  5.   // Used, in C++03 mode too, by allocators, etc.
  6.   /**
  7.    *  @brief Same as C++11 std::addressof
  8.    *  @ingroup utilities
  9.    */
  10.   template<typename _Tp>
  11.     inline _Tp*
  12.     __addressof(_Tp& __r) _GLIBCXX_NOEXCEPT
  13.     {
  14.       return reinterpret_cast<_Tp*>
  15. 	(&const_cast<char&>(reinterpret_cast<const volatile char&>(__r)));
  16.     }
  17.  
  18. _GLIBCXX_END_NAMESPACE_VERSION
  19. } // namespace

__r的类型为__Tp
（1）将__r转为const volatile char&有几个作用
  （a）防止后面用&操作符获取地址时出发原类型(即__Tp)的重载操作(operator&).
  （b）reinterpret_cast操作符总是可以合法的在原类型的基础上加const或volatile, 但是如果__Tp原来带有const或volatile的话, 通过reinterpret_cast去掉是不允许的, 因此需要加上const volatile来避免编译器报错, 也就是不用在管__Tp是否是const或volatile了.
 （c）转换为char&, 因为换成其他类型有可能回触发强制地址对齐的操作, 这样的话真实地址就可能会改变, 造成Undefined Behavior.
（2）const_cast将const或volatile去掉. 因为后面我们要将获取的地址转换回__Tp*, 因为我们前面加了const, 所以这里我们再去掉。
（3）通过取地址符&获取地址后, 再通过reinterpret_cast转换回__Tp*(会保留__Tp的const或volatile如果它有这个修饰符的话)

3、operator==

  template<typename _Tp1, typename _Tp2, _Lock_policy _Lp>
    inline bool
    operator==(const __shared_ptr<_Tp1, _Lp>& __a,
           const __shared_ptr<_Tp2, _Lp>& __b) noexcept
    { return __a.get() == __b.get(); }

调用

      _Tp*
      get() const noexcept
      { return _M_ptr; }


       _Tp*              _M_ptr;         // Contained pointer.

       operator==还是比较包含的裸指针是否相等。

4、static_pointer_cast、const_pointer_cast和dynamic_pointer_cast

  1.   // 20.7.2.2.9 shared_ptr casts
  2.  
  3.   // The seemingly equivalent code:
  4.   // shared_ptr<_Tp, _Lp>(static_cast<_Tp*>(__r.get()))
  5.   // will eventually result in undefined behaviour, attempting to
  6.   // delete the same object twice.
  7.   /// static_pointer_cast
  8.   template<typename _Tp, typename _Tp1, _Lock_policy _Lp>
  9.     inline __shared_ptr<_Tp, _Lp>
  10.     static_pointer_cast(const __shared_ptr<_Tp1, _Lp>& __r) noexcept
  11.     { return __shared_ptr<_Tp, _Lp>(__r, static_cast<_Tp*>(__r.get())); }
  12.  
  13.   // The seemingly equivalent code:
  14.   // shared_ptr<_Tp, _Lp>(const_cast<_Tp*>(__r.get()))
  15.   // will eventually result in undefined behaviour, attempting to
  16.   // delete the same object twice.
  17.   /// const_pointer_cast
  18.   template<typename _Tp, typename _Tp1, _Lock_policy _Lp>
  19.     inline __shared_ptr<_Tp, _Lp>
  20.     const_pointer_cast(const __shared_ptr<_Tp1, _Lp>& __r) noexcept
  21.     { return __shared_ptr<_Tp, _Lp>(__r, const_cast<_Tp*>(__r.get())); }
  22.  
  23.   // The seemingly equivalent code:
  24.   // shared_ptr<_Tp, _Lp>(dynamic_cast<_Tp*>(__r.get()))
  25.   // will eventually result in undefined behaviour, attempting to
  26.   // delete the same object twice.
  27.   /// dynamic_pointer_cast
  28.   template<typename _Tp, typename _Tp1, _Lock_policy _Lp>
  29.     inline __shared_ptr<_Tp, _Lp>
  30.     dynamic_pointer_cast(const __shared_ptr<_Tp1, _Lp>& __r) noexcept
  31.     {
  32.       if (_Tp* __p = dynamic_cast<_Tp*>(__r.get()))
  33. 	return __shared_ptr<_Tp, _Lp>(__r, __p);
  34.       return __shared_ptr<_Tp, _Lp>();
  35.     }

       shared_ptr<_Tp, _Lp>(static_cast<_Tp*>(__r.get()))这种代码会造成二次释放，产生未定义的结果，shared_ptr<_Tp, _Lp>(const_cast<_Tp*>(__r.get()))和shared_ptr<_Tp, _Lp>(dynamic_cast<_Tp*>(__r.get()))也是一样的。所以提供了特殊版本static_pointer_cast、const_pointer_cast和dynamic_pointer_cast用来转换。

    语句return __shared_ptr<_Tp, _Lp>(__r, static_cast<_Tp*>(__r.get()))会调用下面的构造函数：

      template<typename _Tp1>
    __shared_ptr(const __shared_ptr<_Tp1, _Lp>& __r, _Tp* __p) noexcept
    : _M_ptr(__p), _M_refcount(__r._M_refcount) // never throws
    { }

   _M_refcount(__r._M_refcount)会调用下面的构造函数：

  __shared_count(const __shared_count& __r) noexcept
      : _M_pi(__r._M_pi)
      {
    if (_M_pi != 0)
      _M_pi->_M_add_ref_copy();
      }

5、与bool类型的转换

  1.       explicit operator bool() const // never throws
  2.       { return _M_ptr == 0 ? false : true; }

   通过重载操作符与bool类型进行转换。

6、与nullptr_t的比较

  template<typename _Tp, _Lock_policy _Lp>
    inline bool
    operator==(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept
    { return !__a; }

     这个会调用到5中的内容，先转换到bool类型，然后再取反。
 

二、源码分析

  1.   template<typename _Tp, _Lock_policy _Lp>
  2.     class __shared_ptr
  3.     {
  4.     public:
  5.       typedef _Tp   element_type;// element_type即为_Tp类型
  6.  
  7.       constexpr __shared_ptr() noexcept//constexpr 构造函数
  8.       : _M_ptr(0), _M_refcount()
  9.       { }
  10.  
  11.       template<typename _Tp1>
  12. 	explicit __shared_ptr(_Tp1* __p)
  13.         : _M_ptr(__p), _M_refcount(__p)
  14. 	{
  15. 	  __glibcxx_function_requires(_ConvertibleConcept<_Tp1*, _Tp*>)//指针时可以赋值的
  16. 	  static_assert( !is_void<_Tp1>::value, "incomplete type" );//不是void类型
  17. 	  static_assert( sizeof(_Tp1) > 0, "incomplete type" );//类型大小大于0
  18. 	  __enable_shared_from_this_helper(_M_refcount, __p, __p);//添加一个弱引用
  19. 	}
  20.  
  21.       template<typename _Tp1, typename _Deleter>
  22. 	__shared_ptr(_Tp1* __p, _Deleter __d)
  23. 	: _M_ptr(__p), _M_refcount(__p, __d)//构造函数
  24. 	{
  25. 	  __glibcxx_function_requires(_ConvertibleConcept<_Tp1*, _Tp*>)
  26. 	  // TODO requires _Deleter CopyConstructible and __d(__p) well-formed
  27. 	  __enable_shared_from_this_helper(_M_refcount, __p, __p);
  28. 	}
  29.  
  30.       template<typename _Tp1, typename _Deleter, typename _Alloc>
  31. 	__shared_ptr(_Tp1* __p, _Deleter __d, _Alloc __a)//构造函数
  32. 	: _M_ptr(__p), _M_refcount(__p, __d, std::move(__a))
  33. 	{
  34. 	  __glibcxx_function_requires(_ConvertibleConcept<_Tp1*, _Tp*>)
  35. 	  // TODO requires _Deleter CopyConstructible and __d(__p) well-formed
  36. 	  __enable_shared_from_this_helper(_M_refcount, __p, __p);
  37. 	}
  38.  
  39.       template<typename _Deleter>
  40. 	__shared_ptr(nullptr_t __p, _Deleter __d)
  41. 	: _M_ptr(0), _M_refcount(__p, __d)
  42. 	{ }
  43.  
  44.       template<typename _Deleter, typename _Alloc>
  45.         __shared_ptr(nullptr_t __p, _Deleter __d, _Alloc __a)
  46. 	: _M_ptr(0), _M_refcount(__p, __d, std::move(__a))
  47. 	{ }
  48.  
  49.       template<typename _Tp1>
  50. 	__shared_ptr(const __shared_ptr<_Tp1, _Lp>& __r, _Tp* __p) noexcept
  51. 	: _M_ptr(__p), _M_refcount(__r._M_refcount) // never throws
  52. 	{ }
  53.  
  54.       __shared_ptr(const __shared_ptr&) noexcept = default;
  55.       __shared_ptr& operator=(const __shared_ptr&) noexcept = default;
  56.       ~__shared_ptr() = default;
  57.  
  58.       template<typename _Tp1, typename = typename
  59. 	       std::enable_if<std::is_convertible<_Tp1*, _Tp*>::value>::type>
  60. 	__shared_ptr(const __shared_ptr<_Tp1, _Lp>& __r) noexcept
  61. 	: _M_ptr(__r._M_ptr), _M_refcount(__r._M_refcount)
  62. 	{ }
  63.  
  64.       __shared_ptr(__shared_ptr&& __r) noexcept//右值构造函数实现move语义
  65.       : _M_ptr(__r._M_ptr), _M_refcount()
  66.       {
  67. 	_M_refcount._M_swap(__r._M_refcount);//调用__shared_count类中的_M_swap
  68. 	__r._M_ptr = 0;
  69.       }
  70.  
  71.       template<typename _Tp1, typename = typename
  72. 	       std::enable_if<std::is_convertible<_Tp1*, _Tp*>::value>::type>
  73. 	__shared_ptr(__shared_ptr<_Tp1, _Lp>&& __r) noexcept
  74. 	: _M_ptr(__r._M_ptr), _M_refcount()
  75. 	{
  76. 	  _M_refcount._M_swap(__r._M_refcount);
  77. 	  __r._M_ptr = 0;
  78. 	}
  79.  
  80.       template<typename _Tp1>
  81. 	explicit __shared_ptr(const __weak_ptr<_Tp1, _Lp>& __r)
  82. 	: _M_refcount(__r._M_refcount) // may throw
  83. 	{
  84. 	  __glibcxx_function_requires(_ConvertibleConcept<_Tp1*, _Tp*>)
  85.  
  86. 	  // It is now safe to copy __r._M_ptr, as
  87. 	  // _M_refcount(__r._M_refcount) did not throw.
  88. 	  _M_ptr = __r._M_ptr;
  89. 	}
  90.  
  91.       // If an exception is thrown this constructor has no effect.
  92.       template<typename _Tp1, typename _Del>
  93. 	__shared_ptr(std::unique_ptr<_Tp1, _Del>&& __r)
  94. 	: _M_ptr(__r.get()), _M_refcount()
  95. 	{
  96. 	  __glibcxx_function_requires(_ConvertibleConcept<_Tp1*, _Tp*>)
  97. 	  auto __raw = _S_raw_ptr(__r.get());
  98. 	  _M_refcount = __shared_count<_Lp>(std::move(__r));
  99. 	  __enable_shared_from_this_helper(_M_refcount, __raw, __raw);
  100. 	}
  101.  
  102. #if _GLIBCXX_USE_DEPRECATED
  103.       // Postcondition: use_count() == 1 and __r.get() == 0
  104.       template<typename _Tp1>
  105. 	__shared_ptr(std::auto_ptr<_Tp1>&& __r);
  106. #endif
  107.  
  108.       /* TODO: use delegating constructor */
  109.       constexpr __shared_ptr(nullptr_t) noexcept
  110.       : _M_ptr(0), _M_refcount()
  111.       { }
  112.  
  113.       template<typename _Tp1>
  114. 	__shared_ptr&
  115. 	operator=(const __shared_ptr<_Tp1, _Lp>& __r) noexcept
  116. 	{
  117. 	  _M_ptr = __r._M_ptr;
  118. 	  _M_refcount = __r._M_refcount; // __shared_count::op= doesn't throw
  119. 	  return *this;
  120. 	}
  121.  
  122. #if _GLIBCXX_USE_DEPRECATED
  123.       template<typename _Tp1>
  124. 	__shared_ptr&
  125. 	operator=(std::auto_ptr<_Tp1>&& __r)
  126. 	{
  127. 	  __shared_ptr(std::move(__r)).swap(*this);
  128. 	  return *this;
  129. 	}
  130. #endif
  131.  
  132.       __shared_ptr&
  133.       operator=(__shared_ptr&& __r) noexcept
  134.       {
  135. 	__shared_ptr(std::move(__r)).swap(*this);
  136. 	return *this;
  137.       }
  138.  
  139.       template<class _Tp1>
  140. 	__shared_ptr&
  141. 	operator=(__shared_ptr<_Tp1, _Lp>&& __r) noexcept
  142. 	{
  143. 	  __shared_ptr(std::move(__r)).swap(*this);
  144. 	  return *this;
  145. 	}
  146.  
  147.       template<typename _Tp1, typename _Del>
  148. 	__shared_ptr&
  149. 	operator=(std::unique_ptr<_Tp1, _Del>&& __r)
  150. 	{
  151. 	  __shared_ptr(std::move(__r)).swap(*this);
  152. 	  return *this;
  153. 	}
  154.  
  155.       void
  156.       reset() noexcept
  157.       { __shared_ptr().swap(*this); }
  158.  
  159.       template<typename _Tp1>
  160. 	void
  161. 	reset(_Tp1* __p) // _Tp1 must be complete.
  162. 	{
  163. 	  // Catch self-reset errors.
  164. 	  _GLIBCXX_DEBUG_ASSERT(__p == 0 || __p != _M_ptr);
  165. 	  __shared_ptr(__p).swap(*this);
  166. 	}
  167.  
  168.       template<typename _Tp1, typename _Deleter>
  169. 	void
  170. 	reset(_Tp1* __p, _Deleter __d)
  171. 	{ __shared_ptr(__p, __d).swap(*this); }
  172.  
  173.       template<typename _Tp1, typename _Deleter, typename _Alloc>
  174. 	void
  175.         reset(_Tp1* __p, _Deleter __d, _Alloc __a)
  176.         { __shared_ptr(__p, __d, std::move(__a)).swap(*this); }
  177.  
  178.       // Allow class instantiation when _Tp is [cv-qual] void.
  179.       typename std::add_lvalue_reference<_Tp>::type
  180.       operator*() const noexcept
  181.       {
  182. 	_GLIBCXX_DEBUG_ASSERT(_M_ptr != 0);
  183. 	return *_M_ptr;
  184.       }
  185.  
  186.       _Tp*
  187.       operator->() const noexcept
  188.       {
  189. 	_GLIBCXX_DEBUG_ASSERT(_M_ptr != 0);
  190. 	return _M_ptr;
  191.       }
  192.  
  193.       _Tp*
  194.       get() const noexcept
  195.       { return _M_ptr; }
  196.  
  197.       explicit operator bool() const // never throws
  198.       { return _M_ptr == 0 ? false : true; }
  199.  
  200.       bool
  201.       unique() const noexcept
  202.       { return _M_refcount._M_unique(); }
  203.  
  204.       long
  205.       use_count() const noexcept
  206.       { return _M_refcount._M_get_use_count(); }
  207.  
  208.       void
  209.       swap(__shared_ptr<_Tp, _Lp>& __other) noexcept
  210.       {
  211. 	std::swap(_M_ptr, __other._M_ptr);
  212. 	_M_refcount._M_swap(__other._M_refcount);
  213.       }
  214.  
  215.       template<typename _Tp1>
  216. 	bool
  217. 	owner_before(__shared_ptr<_Tp1, _Lp> const& __rhs) const
  218. 	{ return _M_refcount._M_less(__rhs._M_refcount); }
  219.  
  220.       template<typename _Tp1>
  221. 	bool
  222. 	owner_before(__weak_ptr<_Tp1, _Lp> const& __rhs) const
  223. 	{ return _M_refcount._M_less(__rhs._M_refcount); }
  224.  
  225. #ifdef __GXX_RTTI
  226.     protected:
  227.       // This constructor is non-standard, it is used by allocate_shared.
  228.       template<typename _Alloc, typename... _Args>
  229. 	__shared_ptr(_Sp_make_shared_tag __tag, const _Alloc& __a,
  230. 		     _Args&&... __args)
  231. 	: _M_ptr(), _M_refcount(__tag, (_Tp*)0, __a,
  232. 				std::forward<_Args>(__args)...)
  233. 	{
  234. 	  // _M_ptr needs to point to the newly constructed object.
  235. 	  // This relies on _Sp_counted_ptr_inplace::_M_get_deleter.
  236. 	  void* __p = _M_refcount._M_get_deleter(typeid(__tag));
  237. 	  _M_ptr = static_cast<_Tp*>(__p);
  238. 	  __enable_shared_from_this_helper(_M_refcount, _M_ptr, _M_ptr);
  239. 	}
  240. #else
  241.       template<typename _Alloc>
  242.         struct _Deleter
  243.         {
  244.           void operator()(_Tp* __ptr)
  245.           {
  246. 	    typedef allocator_traits<_Alloc> _Alloc_traits;
  247. 	    _Alloc_traits::destroy(_M_alloc, __ptr);
  248. 	    _Alloc_traits::deallocate(_M_alloc, __ptr, 1);
  249.           }
  250.           _Alloc _M_alloc;
  251.         };
  252.  
  253.       template<typename _Alloc, typename... _Args>
  254. 	__shared_ptr(_Sp_make_shared_tag __tag, const _Alloc& __a,
  255. 		     _Args&&... __args)
  256. 	: _M_ptr(), _M_refcount()
  257.         {
  258. 	  typedef typename _Alloc::template rebind<_Tp>::other _Alloc2;
  259.           _Deleter<_Alloc2> __del = { _Alloc2(__a) };
  260. 	  typedef allocator_traits<_Alloc2> __traits;
  261.           _M_ptr = __traits::allocate(__del._M_alloc, 1);
  262. 	  __try
  263. 	    {
  264. 	      // _GLIBCXX_RESOLVE_LIB_DEFECTS
  265. 	      // 2070. allocate_shared should use allocator_traits<A>::construct
  266. 	      __traits::construct(__del._M_alloc, _M_ptr,
  267. 		                  std::forward<_Args>(__args)...);
  268. 	    }
  269. 	  __catch(...)
  270. 	    {
  271. 	      __traits::deallocate(__del._M_alloc, _M_ptr, 1);
  272. 	      __throw_exception_again;
  273. 	    }
  274.           __shared_count<_Lp> __count(_M_ptr, __del, __del._M_alloc);
  275.           _M_refcount._M_swap(__count);
  276. 	  __enable_shared_from_this_helper(_M_refcount, _M_ptr, _M_ptr);
  277.         }
  278. #endif
  279.  
  280.       template<typename _Tp1, _Lock_policy _Lp1, typename _Alloc,
  281. 	       typename... _Args>
  282. 	friend __shared_ptr<_Tp1, _Lp1>
  283. 	__allocate_shared(const _Alloc& __a, _Args&&... __args);
  284.  
  285.       // This constructor is used by __weak_ptr::lock() and
  286.       // shared_ptr::shared_ptr(const weak_ptr&, std::nothrow_t).
  287.       __shared_ptr(const __weak_ptr<_Tp, _Lp>& __r, std::nothrow_t)
  288.       : _M_refcount(__r._M_refcount, std::nothrow)
  289.       {
  290. 	_M_ptr = _M_refcount._M_get_use_count() ? __r._M_ptr : nullptr;
  291.       }
  292.  
  293.       friend class __weak_ptr<_Tp, _Lp>;
  294.  
  295.     private:
  296.       void*
  297.       _M_get_deleter(const std::type_info& __ti) const noexcept
  298.       { return _M_refcount._M_get_deleter(__ti); }
  299.  
  300.       template<typename _Tp1>
  301. 	static _Tp1*
  302. 	_S_raw_ptr(_Tp1* __ptr)
  303. 	{ return __ptr; }
  304.  
  305.       template<typename _Tp1>
  306. 	static auto
  307. 	_S_raw_ptr(_Tp1 __ptr) -> decltype(std::__addressof(*__ptr))
  308. 	{ return std::__addressof(*__ptr); }
  309.  
  310.       template<typename _Tp1, _Lock_policy _Lp1> friend class __shared_ptr;
  311.       template<typename _Tp1, _Lock_policy _Lp1> friend class __weak_ptr;
  312.  
  313.       template<typename _Del, typename _Tp1, _Lock_policy _Lp1>
  314. 	friend _Del* get_deleter(const __shared_ptr<_Tp1, _Lp1>&) noexcept;
  315.  
  316.       _Tp*	   	   _M_ptr;         // Contained pointer.
  317.       __shared_count<_Lp>  _M_refcount;    // Reference counter.
  318.     };
  319.  // 20.7.2.2.7 shared_ptr comparisons
  320.   template<typename _Tp1, typename _Tp2, _Lock_policy _Lp>
  321.     inline bool
  322.     operator==(const __shared_ptr<_Tp1, _Lp>& __a,
  323. 	       const __shared_ptr<_Tp2, _Lp>& __b) noexcept
  324.     { return __a.get() == __b.get(); }
  325.  
  326.   template<typename _Tp, _Lock_policy _Lp>
  327.     inline bool
  328.     operator==(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept
  329.     { return !__a; }
  330.  
  331.   template<typename _Tp, _Lock_policy _Lp>
  332.     inline bool
  333.     operator==(nullptr_t, const __shared_ptr<_Tp, _Lp>& __a) noexcept
  334.     { return !__a; }
  335.  
  336.   template<typename _Tp1, typename _Tp2, _Lock_policy _Lp>
  337.     inline bool
  338.     operator!=(const __shared_ptr<_Tp1, _Lp>& __a,
  339. 	       const __shared_ptr<_Tp2, _Lp>& __b) noexcept
  340.     { return __a.get() != __b.get(); }
  341.  
  342.   template<typename _Tp, _Lock_policy _Lp>
  343.     inline bool
  344.     operator!=(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept
  345.     { return (bool)__a; }
  346.  
  347.   template<typename _Tp, _Lock_policy _Lp>
  348.     inline bool
  349.     operator!=(nullptr_t, const __shared_ptr<_Tp, _Lp>& __a) noexcept
  350.     { return (bool)__a; }
  351.  
  352.   template<typename _Tp1, typename _Tp2, _Lock_policy _Lp>
  353.     inline bool
  354.     operator<(const __shared_ptr<_Tp1, _Lp>& __a,
  355. 	      const __shared_ptr<_Tp2, _Lp>& __b) noexcept
  356.     {
  357.       typedef typename std::common_type<_Tp1*, _Tp2*>::type _CT;
  358.       return std::less<_CT>()(__a.get(), __b.get());
  359.     }
  360.  
  361.   template<typename _Tp, _Lock_policy _Lp>
  362.     inline bool
  363.     operator<(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept
  364.     { return std::less<_Tp*>()(__a.get(), nullptr); }
  365.  
  366.   template<typename _Tp, _Lock_policy _Lp>
  367.     inline bool
  368.     operator<(nullptr_t, const __shared_ptr<_Tp, _Lp>& __a) noexcept
  369.     { return std::less<_Tp*>()(nullptr, __a.get()); }
  370.  
  371.   template<typename _Tp1, typename _Tp2, _Lock_policy _Lp>
  372.     inline bool
  373.     operator<=(const __shared_ptr<_Tp1, _Lp>& __a,
  374. 	       const __shared_ptr<_Tp2, _Lp>& __b) noexcept
  375.     { return !(__b < __a); }
  376.  
  377.   template<typename _Tp, _Lock_policy _Lp>
  378.     inline bool
  379.     operator<=(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept
  380.     { return !(nullptr < __a); }
  381.  
  382.   template<typename _Tp, _Lock_policy _Lp>
  383.     inline bool
  384.     operator<=(nullptr_t, const __shared_ptr<_Tp, _Lp>& __a) noexcept
  385.     { return !(__a < nullptr); }
  386.  
  387.   template<typename _Tp1, typename _Tp2, _Lock_policy _Lp>
  388.     inline bool
  389.     operator>(const __shared_ptr<_Tp1, _Lp>& __a,
  390. 	      const __shared_ptr<_Tp2, _Lp>& __b) noexcept
  391.     { return (__b < __a); }
  392.  
  393.   template<typename _Tp, _Lock_policy _Lp>
  394.     inline bool
  395.     operator>(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept
  396.     { return std::less<_Tp*>()(nullptr, __a.get()); }
  397.  
  398.   template<typename _Tp, _Lock_policy _Lp>
  399.     inline bool
  400.     operator>(nullptr_t, const __shared_ptr<_Tp, _Lp>& __a) noexcept
  401.     { return std::less<_Tp*>()(__a.get(), nullptr); }
  402.  
  403.   template<typename _Tp1, typename _Tp2, _Lock_policy _Lp>
  404.     inline bool
  405.     operator>=(const __shared_ptr<_Tp1, _Lp>& __a,
  406. 	       const __shared_ptr<_Tp2, _Lp>& __b) noexcept
  407.     { return !(__a < __b); }
  408.  
  409.   template<typename _Tp, _Lock_policy _Lp>
  410.     inline bool
  411.     operator>=(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept
  412.     { return !(__a < nullptr); }
  413.  
  414.   template<typename _Tp, _Lock_policy _Lp>
  415.     inline bool
  416.     operator>=(nullptr_t, const __shared_ptr<_Tp, _Lp>& __a) noexcept
  417.     { return !(nullptr < __a); }
  418.  
  419.   template<typename _Sp>
  420.     struct _Sp_less : public binary_function<_Sp, _Sp, bool>
  421.     {
  422.       bool
  423.       operator()(const _Sp& __lhs, const _Sp& __rhs) const noexcept
  424.       {
  425. 	typedef typename _Sp::element_type element_type;
  426. 	return std::less<element_type*>()(__lhs.get(), __rhs.get());
  427.       }
  428.     };
  429.  
  430.   template<typename _Tp, _Lock_policy _Lp>
  431.     struct less<__shared_ptr<_Tp, _Lp>>
  432.     : public _Sp_less<__shared_ptr<_Tp, _Lp>>
  433.     { };
  434.  
  435.   // 20.7.2.2.8 shared_ptr specialized algorithms.
  436.   template<typename _Tp, _Lock_policy _Lp>
  437.     inline void
  438.     swap(__shared_ptr<_Tp, _Lp>& __a, __shared_ptr<_Tp, _Lp>& __b) noexcept
  439.     { __a.swap(__b); }
  440.  
  441.   // 20.7.2.2.9 shared_ptr casts
  442.  
  443.   // The seemingly equivalent code:
  444.   // shared_ptr<_Tp, _Lp>(static_cast<_Tp*>(__r.get()))
  445.   // will eventually result in undefined behaviour, attempting to
  446.   // delete the same object twice.
  447.   /// static_pointer_cast
  448.   template<typename _Tp, typename _Tp1, _Lock_policy _Lp>
  449.     inline __shared_ptr<_Tp, _Lp>
  450.     static_pointer_cast(const __shared_ptr<_Tp1, _Lp>& __r) noexcept
  451.     { return __shared_ptr<_Tp, _Lp>(__r, static_cast<_Tp*>(__r.get())); }
  452.  
  453.   // The seemingly equivalent code:
  454.   // shared_ptr<_Tp, _Lp>(const_cast<_Tp*>(__r.get()))
  455.   // will eventually result in undefined behaviour, attempting to
  456.   // delete the same object twice.
  457.   /// const_pointer_cast
  458.   template<typename _Tp, typename _Tp1, _Lock_policy _Lp>
  459.     inline __shared_ptr<_Tp, _Lp>
  460.     const_pointer_cast(const __shared_ptr<_Tp1, _Lp>& __r) noexcept
  461.     { return __shared_ptr<_Tp, _Lp>(__r, const_cast<_Tp*>(__r.get())); }
  462.  
  463.   // The seemingly equivalent code:
  464.   // shared_ptr<_Tp, _Lp>(dynamic_cast<_Tp*>(__r.get()))
  465.   // will eventually result in undefined behaviour, attempting to
  466.   // delete the same object twice.
  467.   /// dynamic_pointer_cast
  468.   template<typename _Tp, typename _Tp1, _Lock_policy _Lp>
  469.     inline __shared_ptr<_Tp, _Lp>
  470.     dynamic_pointer_cast(const __shared_ptr<_Tp1, _Lp>& __r) noexcept
  471.     {
  472.       if (_Tp* __p = dynamic_cast<_Tp*>(__r.get()))
  473. 	return __shared_ptr<_Tp, _Lp>(__r, __p);
  474.       return __shared_ptr<_Tp, _Lp>();
  475.     }

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/喵喵爱编程/article/detail/999984
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号