shared_ptr 源码分析

最新推荐文章于 2025-03-06 21:55:11 发布
原创 最新推荐文章于 2025-03-06 21:55:11 发布 · 1.6k 阅读 · 2 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#c++ #开发语言 #后端

  1. 共享指针

    • 说明

      • shared_ptr类提供类的行为接口.

      • 有专门的父类提供数据管理接口.

    • 实现

      • 涉及到继承,以及引用计数是否需要多线程安全.

      • 控制块的类型.

  2. 源码

    • shared_ptr

       template<typename _Tp>
   class shared_ptr : public __shared_ptr<_Tp>
   {
         
         
     template<typename... _Args>
 using _Constructible = typename enable_if<
   is_constructible<__shared_ptr<_Tp>, _Args...>::value
 >::type;

     template<typename _Arg>
 using _Assignable = typename enable_if<
   is_assignable<__shared_ptr<_Tp>&, _Arg>::value, shared_ptr&
 >::type;

   public:

     using element_type = typename __shared_ptr<_Tp>::element_type;

#if __cplusplus > 201402L
# define __cpp_lib_shared_ptr_weak_type 201606
     using weak_type = weak_ptr<_Tp>;
#endif
     /**
      *  @brief  Construct an empty %shared_ptr.
      *  @post   use_count()==0 && get()==0
      */
     constexpr shared_ptr() noexcept : __shared_ptr<_Tp>() {
         
          }

     shared_ptr(const shared_ptr&) noexcept = default;

     /**
      *  @brief  Construct a %shared_ptr that owns the pointer @a __p.
      *  @param  __p  A pointer that is convertible to element_type*.
      *  @post   use_count() == 1 && get() == __p
      *  @throw  std::bad_alloc, in which case @c delete @a __p is called.
      */
     template<typename _Yp, typename = _Constructible<_Yp*>>
 explicit
 shared_ptr(_Yp* __p) : __shared_ptr<_Tp>(__p) {
         
          }

     /**
      *  @brief  Construct a %shared_ptr that owns the pointer @a __p
      *          and the deleter @a __d.
      *  @param  __p  A pointer.
      *  @param  __d  A deleter.
      *  @post   use_count() == 1 && get() == __p
      *  @throw  std::bad_alloc, in which case @a __d(__p) is called.
      *
      *  Requirements: _Deleter's copy constructor and destructor must
      *  not throw
      *
      *  __shared_ptr will release __p by calling __d(__p)
      */
     template<typename _Yp, typename _Deleter,
        typename = _Constructible<_Yp*, _Deleter>>
 shared_ptr(_Yp* __p, _Deleter __d)
       : __shared_ptr<_Tp>(__p, std::move(__d)) {
         
          }

     /**
      *  @brief  Construct a %shared_ptr that owns a null pointer
      *          and the deleter @a __d.
      *  @param  __p  A null pointer constant.
      *  @param  __d  A deleter.
      *  @post   use_count() == 1 && get() == __p
      *  @throw  std::bad_alloc, in which case @a __d(__p) is called.
      *
      *  Requirements: _Deleter's copy constructor and destructor must
      *  not throw
      *
      *  The last owner will call __d(__p)
      */
     template<typename _Deleter>
 shared_ptr(nullptr_t __p, _Deleter __d)
       : __shared_ptr<_Tp>(__p, std::move(__d)) {
         
          }

     /**
      *  @brief  Construct a %shared_ptr that owns the pointer @a __p
      *          and the deleter @a __d.
      *  @param  __p  A pointer.
      *  @param  __d  A deleter.
      *  @param  __a  An allocator.
      *  @post   use_count() == 1 && get() == __p
      *  @throw  std::bad_alloc, in which case @a __d(__p) is called.
      *
      *  Requirements: _Deleter's copy constructor and destructor must
      *  not throw _Alloc's copy constructor and destructor must not
      *  throw.
      *
      *  __shared_ptr will release __p by calling __d(__p)
      */
     template<typename _Yp, typename _Deleter, typename _Alloc,
        typename = _Constructible<_Yp*, _Deleter, _Alloc>>
 shared_ptr(_Yp* __p, _Deleter __d, _Alloc __a)
 : __shared_ptr<_Tp>(__p, std::move(__d), std::move(__a)) {
         
          }

     /**
      *  @brief  Construct a %shared_ptr that owns a null pointer
      *          and the deleter @a __d.
      *  @param  __p  A null pointer constant.
      *  @param  __d  A deleter.
      *  @param  __a  An allocator.
      *  @post   use_count() == 1 && get() == __p
      *  @throw  std::bad_alloc, in which case @a __d(__p) is called.
      *
      *  Requirements: _Deleter's copy constructor and destructor must
      *  not throw _Alloc's copy constructor and destructor must not
      *  throw.
      *
      *  The last owner will call __d(__p)
      */
     template<typename _Deleter, typename _Alloc>
 shared_ptr(nullptr_t __p, _Deleter __d, _Alloc __a)
 : __shared_ptr<_Tp>(__p, std::move(__d), std::move(__a)) {
         
          }

     // Aliasing constructor

     /**
      *  @brief  Constructs a %shared_ptr instance that stores @a __p
      *          and shares ownership with @a __r.
      *  @param  __r  A %shared_ptr.
      *  @param  __p  A pointer that will remain valid while @a *__r is valid.
      *  @post   get() == __p && use_count() == __r.use_count()
      *
      *  This can be used to construct a @c shared_ptr to a sub-object
      *  of an object managed by an existing @c shared_ptr.
      *
      * @code
      * shared_ptr< pair<int,int> > pii(new pair<int,int>());
      * shared_ptr<int> pi(pii, &pii->first);
      * assert(pii.use_count() == 2);
      * @endcode
      */
     template<typename _Yp>
 shared_ptr(const shared_ptr<_Yp>& __r, element_type* __p) noexcept
 : __shared_ptr<_Tp>(__r, __p) {
         
          }

     /**
      *  @brief  If @a __r is empty, constructs an empty %shared_ptr;
      *          otherwise construct a %shared_ptr that shares ownership
      *          with @a __r.
      *  @param  __r  A %shared_ptr.
      *  @post   get() == __r.get() && use_count() == __r.use_count()
      */
     template<typename _Yp,
        typename = _Constructible<const shared_ptr<_Yp>&>>
 shared_ptr(const shared_ptr<_Yp>& __r) noexcept
       : __shared_ptr<_Tp>(__r) {
         
          }

     /**
      *  @brief  Move-constructs a %shared_ptr instance from @a __r.
      *  @param  __r  A %shared_ptr rvalue.
      *  @post   *this contains the old value of @a __r, @a __r is empty.
      */
     shared_ptr(shared_ptr&& __r) noexcept
     : __shared_ptr<_Tp>(std::move(__r)) {
         
          }

     /**
      *  @brief  Move-constructs a %shared_ptr instance from @a __r.
      *  @param  __r  A %shared_ptr rvalue.
      *  @post   *this contains the old value of @a __r, @a __r is empty.
      */
     template<typename _Yp, typename = _Constructible<shared_ptr<_Yp>>>
 shared_ptr(shared_ptr<_Yp>&& __r) noexcept
 : __shared_ptr<_Tp>(std::move(__r)) {
         
          }

     /**
      *  @brief  Constructs a %shared_ptr that shares ownership with @a __r
      *          and stores a copy of the pointer stored in @a __r.
      *  @param  __r  A weak_ptr.
      *  @post   use_count() == __r.use_count()
      *  @throw  bad_weak_ptr when __r.expired(),
      *          in which case the constructor has no effect.
      */
     template<typename _Yp, typename = _Constructible<const weak_ptr<_Yp>&>>
 explicit shared_ptr(const weak_ptr<_Yp>& __r)
 : __shared_ptr<_Tp>(__r) {
         
          }

#if _GLIBCXX_USE_DEPRECATED
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
     template<typename _Yp, typename = _Constructible<auto_ptr<_Yp>>>
 shared_ptr(auto_ptr<_Yp>&& __r);
#pragma GCC diagnostic pop
#endif

     // _GLIBCXX_RESOLVE_LIB_DEFECTS
     // 2399. shared_ptr's constructor from unique_ptr should be constrained
     template<typename _Yp, typename _Del,
        typename = _Constructible<unique_ptr<_Yp, _Del>>>
 shared_ptr(unique_ptr<_Yp, _Del>&& __r)
 : __shared_ptr<_Tp>(std::move(__r)) {
         
          }

#if __cplusplus <= 201402L && _GLIBCXX_USE_DEPRECATED
     // This non-standard constructor exists to support conversions that
     // were possible in C++11 and C++14 but are ill-formed in C++17.
     // If an exception is thrown this constructor has no effect.
     template<typename _Yp, typename _Del,
   _Constructible<unique_ptr<_Yp, _Del>, __sp_array_delete>* = 0>
 shared_ptr(unique_ptr<_Yp, _Del>&& __r)
 : __shared_ptr<_Tp>(std::move(__r), __sp_array_delete()) {
         
          }
#endif

     /**
      *  @brief  Construct an empty %shared_ptr.
      *  @post   use_count() == 0 && get() == nullptr
      */
     constexpr shared_ptr(nullptr_t) noexcept : shared_ptr() {
         
          }

     shared_ptr& operator=(const shared_ptr&) noexcept = default;

     template<typename _Yp>
 _Assignable<const shared_ptr<_Yp>&>
 operator=(const shared_ptr<_Yp>& __r) noexcept
 {
         
         
   this->__shared_ptr<_Tp>::operator=(__r);
   return *this;
 }

#if _GLIBCXX_USE_DEPRECATED
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
     template<typename _Yp>
 _Assignable<auto_ptr<_Yp>>
 operator=(auto_ptr<_Yp>&& __r)
 {
         
         
   this->__shared_ptr<_Tp>::operator=(std::move(__r));
   return *this;
 }
#pragma GCC diagnostic pop
#endif

     shared_ptr&
     operator=(shared_ptr&& __r) noexcept
     {
         
         
 this->__shared_ptr<_Tp>::operator=(std::move(__r));
 return *this;
     }

     template<class _Yp>
 _Assignable<shared_ptr<_Yp>>
 operator=(shared_ptr<_Yp>&& __r) noexcept
 {
         
         
   this->__shared_ptr<_Tp>::operator=(std::move(__r));
   return *this;
 }

     template<typename _Yp, typename _Del>
 _Assignable<unique_ptr<_Yp, _Del>>
 operator=(unique_ptr<_Yp, _Del>&& __r)
 {
         
         
   this->__shared_ptr<_Tp>::operator=(std::move(__r));
   return *this;
 }

   private:
     // This constructor is non-standard, it is used by allocate_shared.
     template<typename _Alloc, typename... _Args>
 shared_ptr(_Sp_make_shared_tag __tag, const _Alloc& __a,
      _Args&&... __args)
 : __shared_ptr<_Tp>(__tag, __a, std::forward<_Args>(__args)...)
 {
         
          }

     template<typename _Yp, typename _Alloc, typename... _Args>
 friend shared_ptr<_Yp>
 allocate_shared(const _Alloc& __a, _Args&&... __args);

     // This constructor is non-standard, it is used by weak_ptr::lock().
     shared_ptr(const weak_ptr<_Tp>& __r, std::nothrow_t)
     : __shared_ptr<_Tp>(__r, std::nothrow) {
         
          }

     friend class weak_ptr<_Tp>;
   };

      • 可以看到父类__shared_ptr,shared_ptr没有提供任何成员变量.

    • 说明

      • 提供的都是一些数据操作函数.

  3. 数据类

    • 源码

       template<typename _Tp, _Lock_policy _Lp>
   class __shared_ptr
   : public __shared_ptr_access<_Tp, _Lp>
   {
         
         
   public:
     using element_type = typename remove_extent<_Tp>::type;

   private:
     // Constraint for taking ownership of a pointer of type _Yp*:
     template<typename _Yp>
 using _SafeConv
   = typename enable_if<__sp_is_constructible<_Tp, _Yp>::value>::type;

     // Constraint for construction from shared_ptr and weak_ptr:
     template<typename _Yp, typename _Res = void>
 using _Compatible = typename
   enable_if<__sp_compatible_with<_Yp*, _Tp*>::value, _Res>::type;

     // Constraint for assignment from shared_ptr and weak_ptr:
     template<typename _Yp>
 using _Assignable = _Compatible<_Yp, __shared_ptr&>;

     // Constraint for construction from unique_ptr:
     template<typename _Yp, typename _Del, typename _Res = void,
        typename _Ptr = typename unique_ptr<_Yp, _Del>::pointer>
 using _UniqCompatible = typename enable_if<__and_<
   __sp_compatible_with<_Yp*, _Tp*>, is_convertible<_Ptr, element_type*>
   >::value, _Res>::type;

     // Constraint for assignment from unique_ptr:
     template<typename _Yp, typename _Del>
 using _UniqAssignable = _UniqCompatible<_Yp, _Del, __shared_ptr&>;

   public:

#if __cplusplus > 201402L
     using weak_type = __weak_ptr<_Tp, _Lp>;
#endif

     constexpr __shared_ptr() noexcept
     : _M_ptr(0), _M_refcount()
     {
         
          }

     template<typename _Yp, typename = _SafeConv<_Yp>>
 explicit
 __shared_ptr(_Yp* __p)
 : _M_ptr(__p), _M_refcount(__p, typename is_array<_Tp>::type())
 {
         
         
   static_assert( !is_void<_Yp>::value, "incomplete type" );
   static_assert( sizeof(_Yp) > 0, "incomplete type" );
   _M_enable_shared_from_this_with(__p);
 }

     template<typename _Yp, typename _Deleter, typename = _SafeConv<_Yp>>
 __shared_ptr(_Yp* __p, _Deleter __d)
 : _M_ptr(__p), _M_refcount(__p, std::move(__d))
 {
         
         
   static_assert(__is_invocable<_Deleter&, _Yp*&>::value,
       "deleter expression d(p) is well-formed");
   _M_enable_shared_from_this_with(__p);
 }

     template<typename _Yp, typename _Deleter, typename _Alloc,
        typename = _SafeConv<_Y
最低0.47元/天 解锁文章
C++11中的智能指针unique_ptr、shared_ptr和weak_ptr详解
dvlinker的技术专栏
05-28 3万+
详细讲解C++11中引入的智能指针unique_ptr、shared_ptr和weak_ptr。
shared_ptr源码分析
愤怒的弱鸡
08-08 2364
shared_ptr是从C++11开始提供的智能指针，用于管理多个指针对同一实体的资源释放问题，保证在多个指针指向同一实体时，仅最后一个指针解除指向时才会释放资源。 shared_ptr构造 shared_ptr<_Tp>继承自__shared_ptr<_Tp>，其功能主要由其实现。让我们以单值构造函数为切入点开始分析。 template<typename _Yp, typename = _Constructible<_Yp*>> explici
shared_ptr源码剖析
王学门徒
05-20 967
shared_ptr的源码： 主要又下列这几个文件组成：main.cpp sp_config.h sp_counted_base.h sp_counted_impl.h shared_count.h shared_ptr.h sp_config.h #ifndef _SP_CONFIG_H #define _SP_CONFIG_H #define DISPLAY//配置：在构造和析构的时候是否打印对应的字符串 #endif shared_ptr.h #ifndef _SHREAD_PTR_H #d
C++ 智能指针（shared_ptr/weak_ptr）源码
06-10
C++ 智能指针（shared_ptr/weak_ptr）源码 源码位置：gcc-6.1.0\gcc-6.1.0\libstdc++-v3\include\tr1 这里只单列shared_ptr.h文件用于分析
C++ shared_ptr源码剖析
morning_color的博客
12-25 1724
/**    *  @brief  A smart pointer with reference-counted copy semantics.    *    *  The object pointed to is deleted when the last shared_ptr pointing to    *  it is destroyed or reset.   */ sha
std:shared_ptr源码解读
u013516079的博客
10-10 717
加锁的策略 _Lock_policy 这个模板类型，最终传递给了内部属性 _Sp_counted_base* _M_pi。_M_pi 继承了_Mutex_base，这个基类一看名字就知道是进行互斥控制的类。_Sp_counted_base 类中 有个属性：_Atomic_word _M_use_count ，引用计数数值，int类型。shared_ptr继承自__shared_ptr，其功能主要由父类__shared_ptr 实现。就是构造时传入的指针指向类型，
GCC STL源码解析 —— shared_ptr & weak_ptr
文天_Teddy的专栏
02-21 537
GCC STL 源码解析 —— shared_ptr & weak_ptr
C++深度探索 - shared_ptr源码分析
Huuaaaaa的博客
01-13 1969
简要分析 gcc 4.9.0版本下 shared_ptr源码。
shared_ptr智能指针源码分析
irislin1988的博客
05-25 1377
先写应用代码 #include <iostream> #include <memory> int main() { std::shared_ptr<int> sptr(new int(42)); // sptr1 = std::make_shared<int>(32); std::shared_ptr<int> sp2 = sptr; std::weak_ptr<int >wptr; wptr = sptr; std::co
shared_ptr智能指针源码剖析
Moxiao__墨箫
02-10 810
C++ 智能指针shared_ptr线程安全源码分析
C++ 智能指针（shared_ptr/weak_ptr）源码分析
热门推荐
gigglesun的专栏
05-29 1万+
C++11目前已经引入了unique_ptr, shared_ptr, weak_ptr等智能指针以及相关的模板类enable_shared_from_this等。shared_ptr实现了C++中的RAII机制，它不仅仅具有一般指针(build-in/raw)的特性，更重要的是它可以自动管理用户在堆上创建的对象的生命周期，让用户不用为内存回收操心，避免内存泄漏。一般的智能指针都定义为一个模板类，...
shared_ptr源码解读
飞翔的大象
07-24 726
1  介绍 众所周知，auto_ptr由于它的破坏性复制语义，无法满足标准容器对元素的要求，因而不能放在标准容器中；如果我们希望当容器析构时能自动把它容纳的指针元素所指的对象删除时，通常采用一些间接的方式来实现，显得比较繁琐。boost库中提供了一种新型的智能指针 shared_ptr，它解决了在多个指针间共享对象所有权的问题，同时也满足容器对元素的要求，因而可以安全地放入容器中。现在我们可以这
《shared_ptr源码剖析》
边城梦溪
01-05 1190
本文将以Centos标准库为基础，剖析shared_ptr的源码，shared_ptr主要包含两个部分：shared_ptr_base.h和shared_ptr.h，虽然涉及的文件不多，但为了实现一套完备的内存托管方案出来，gcc还是设计很多类出来。且看如下图片，笔者将结合图片逐步为您剖析shared_ptr托管内存的原理和细节。1. shared_ptr结构和源码。
STL源码阅读小记(五)——Shared_ptr
ninesnow_c的博客
04-21 1125
前言 感觉好久没看stl了，中间跑去看图形学入门了，图形学是真的有趣，但是也是真难，不过接着补坑，把unique_ptr的好兄弟shared_ptr也看了。 STL版本 本文所使用的stl版本为libc++ 13.0，属于LLVM项目。 LLVM项目Github 如果遇到不熟悉的宏定义可以参考文档Symbol Visibility Macros Shared_ptr 应该算是c++中的老熟人，应该绝大部分人应该使用过，或者在面试中见过它，对它的引用计数器印象深刻吧。这次我们看看stl的源码中shared_p
MSVC版std::shared_ptr源码解读
最新发布
2403_88366942的博客
03-06 520
还有就是通过new去创建的共享指针的资源对象，这个对象它在共享指针类型中的对应的资源指针真正的数据类型可能是有两种的，作为共享指针的直接成员的资源对象的指针是其资源对象的基类(如果有，没有就是自身的)类型，作为控制块(Ref_count)的成员的资源对象的指针才是实际的对象的类型(如果传入的对象是一个子类对象的话，控制块中的资源对象的指针类型是这个子类类型)。采用new的方式它会创建一个_Ref_count类型的控制块。创建智能指针对象和用。
智能指针篇------STL源码分析：shared_ptr 和 weak_ptr、unique_ptr
weixin_44835655的博客
12-27 1409
探究STL中 shared_ptr 和 weak_ptr 源码，分析其各种机制的实现原理：例如 析构动作在创建时捕获、weak_count 的作用、enable_shared_from_this 的实现机制
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值