shared_ptr源码分析

最新推荐文章于 2023-01-13 00:39:09 发布
最新推荐文章于 2023-01-13 00:39:09 发布
阅读量1.8k 收藏 7
点赞数 5
分类专栏： C/CXX
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37654704/article/details/107885315
版权

shared_ptr是从C++11开始提供的智能指针，用于管理多个指针对同一实体的资源释放问题，保证在多个指针指向同一实体时，仅最后一个指针解除指向时才会释放资源。

shared_ptr构造

shared_ptr<_Tp>继承自__shared_ptr<_Tp>，其功能主要由其实现。让我们以单值构造函数为切入点开始分析。

      template<typename _Yp, typename = _Constructible<_Yp*>>
	explicit
	shared_ptr(_Yp* __p) : __shared_ptr<_Tp>(__p) { }

从中我们可以看到，调用了基类的构造函数，定义如下

      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);
	}

其初始化了成员变量_M_ptr和_M_refcount，这两个成员变量的定义如下。element_type就是构造时传入的指针指向类型，这里我们可以看到，share_ptr的实现就是最基本的指针加上引用计数。

element_type*	   _M_ptr;         // Contained pointer.
__shared_count<_Lp>  _M_refcount;    // Reference counter.

让我们接下看看_M_refcount的构造过程，其调用如下构造函数，我们能够看到他初始化了数据成员_M_pi。

      template<typename _Ptr>
        explicit
	__shared_count(_Ptr __p) : _M_pi(0)
	{
	  __try
	    {
	      _M_pi = new _Sp_counted_ptr<_Ptr, _Lp>(__p);
	    }
	  __catch(...)
	    {
	      delete __p;
	      __throw_exception_again;
	    }
	}

数据成员_M_pi的定义如下，他是一个基类的指针，可以指向任何派生类，所以_M_pi = new _Sp_counted_ptr<_Ptr, _Lp>(__p)并不存在任何语法问题。

_Sp_counted_base<_Lp>*  _M_pi;

让我们接着查看代码，首先是_Sp_counted_ptr<_Ptr, _Lp>(__p)的构造，其初始化了数据成员_Ptr _M_ptr，这里我们可以发现_Sp_counted_ptr存在一个指针指向其引用的对象。

explicit
_Sp_counted_ptr(_Ptr __p) noexcept
: _M_ptr(__p) { }

从上面的代码中我们可以看出，其没有显式调用基类构造函数，所以使用基类默认构造函数，其默认构造函数如下：

_Sp_counted_base() noexcept
: _M_use_count(1), _M_weak_count(1) { }

其初始化数据成员_M_use_count，_M_weak_count。_M_use_count表示的为共有多少share_ptr指向内存实体，当_M_use_count == 0时便会释放内存所指向的实体。之后的析构分析我们便会看到其如何使用，_M_weak_count是供weak_ptr使用，保证weak_ptr能够感知其实体是否依然存在。

      _Atomic_word  _M_use_count;     // #shared
      _Atomic_word  _M_weak_count;    // #weak + (#shared != 0)
赋值分析

赋值包括两个主要操作：copy construc和operator=。查看相应的函数，我们可以看到他们的定义如下：

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

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

基类和子类的copy construc和operator=都使用默认方法，也就是说其在调用时会分别调用成员变量的copy construc和operator=。派生类没有数据成员，而基类__shared_ptr包含成员变量。

 element_type*	   _M_ptr;         // Contained pointer.
 __shared_count<_Lp>  _M_refcount;    // Reference counter.

_M_ptr为最基本的指针，所以每次都会进行重新赋值。而__shared_count<_Lp>为自定义class，我们继续跟踪其行为。

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

      __shared_count&
      operator=(const __shared_count& __r) noexcept
      {
	_Sp_counted_base<_Lp>* __tmp = __r._M_pi;
	if (__tmp != _M_pi)
	  {
	    if (__tmp != 0)
	      __tmp->_M_add_ref_copy();
	    if (_M_pi != 0)
	      _M_pi->_M_release();
	    _M_pi = __tmp;
	  }
	return *this;
      }

在进行复制构造时，我们可以看到其令this->_M_pi = other._M_pi，这里_M_pi的定义为_Sp_counted_base<_Lp>* _M_pi。他是一个指针，因此在复制构造时，此结构直接指向被复制对象的实体，保证了多个share_ptr只有一个引用计数实体。operator=操作不同的是会先取消之前的引用计数（如果计数归零还需要释放空间），再添加新的计数。

      
      void
      _M_add_ref_copy()
      { __gnu_cxx::__atomic_add_dispatch(&_M_use_count, 1); }

      void
      _M_release() noexcept
      {
        // Be race-detector-friendly.  For more info see bits/c++config.
        _GLIBCXX_SYNCHRONIZATION_HAPPENS_BEFORE(&_M_use_count);
	if (__gnu_cxx::__exchange_and_add_dispatch(&_M_use_count, -1) == 1)
	  {
            _GLIBCXX_SYNCHRONIZATION_HAPPENS_AFTER(&_M_use_count);
	    _M_dispose();
	    // There must be a memory barrier between dispose() and destroy()
	    // to ensure that the effects of dispose() are observed in the
	    // thread that runs destroy().
	    // See http://gcc.gnu.org/ml/libstdc++/2005-11/msg00136.html
	    if (_Mutex_base<_Lp>::_S_need_barriers)
	      {
		__atomic_thread_fence (__ATOMIC_ACQ_REL);
	      }

            // Be race-detector-friendly.  For more info see bits/c++config.
            _GLIBCXX_SYNCHRONIZATION_HAPPENS_BEFORE(&_M_weak_count);
	    if (__gnu_cxx::__exchange_and_add_dispatch(&_M_weak_count,
						       -1) == 1)
              {
                _GLIBCXX_SYNCHRONIZATION_HAPPENS_AFTER(&_M_weak_count);
	        _M_destroy();
              }
	  }
      }

上述两个便是_Sp_counted_base的_M_add_ref_copy()和 M_release()，对于_M_add_ref_copy()其就是_M_use_count + 1。而对于M_release()，在析构时再详细介绍。

析构分析

当shared_ptr超出其definite scope时，需要智能释放对应内存，即当其为最后一个引用时需要释放内存，而如果还存在其他引用则不进行释放。
shared_ptr和__shared_ptr都没有定义析构函数，所以我们直接查看__shared_count<_Lp> _M_refcount数据成员的析构函数。其定义如下

      ~__shared_count() noexcept
      {
	if (_M_pi != nullptr)
	  _M_pi->_M_release();
      }

依旧是调用_M_pi->_M_release()，现在让我们来看看其具体过程如何。

      void
      _M_release() noexcept
      {
        // Be race-detector-friendly.  For more info see bits/c++config.
        _GLIBCXX_SYNCHRONIZATION_HAPPENS_BEFORE(&_M_use_count);
	if (__gnu_cxx::__exchange_and_add_dispatch(&_M_use_count, -1) == 1)
	  {
            _GLIBCXX_SYNCHRONIZATION_HAPPENS_AFTER(&_M_use_count);
	    _M_dispose();
	    // There must be a memory barrier between dispose() and destroy()
	    // to ensure that the effects of dispose() are observed in the
	    // thread that runs destroy().
	    // See http://gcc.gnu.org/ml/libstdc++/2005-11/msg00136.html
	    if (_Mutex_base<_Lp>::_S_need_barriers)
	      {
		__atomic_thread_fence (__ATOMIC_ACQ_REL);
	      }

            // Be race-detector-friendly.  For more info see bits/c++config.
            _GLIBCXX_SYNCHRONIZATION_HAPPENS_BEFORE(&_M_weak_count);
	    if (__gnu_cxx::__exchange_and_add_dispatch(&_M_weak_count,
						       -1) == 1)
              {
                _GLIBCXX_SYNCHRONIZATION_HAPPENS_AFTER(&_M_weak_count);
	        _M_destroy();
              }
	  }
      }

其先对_M_use_count -- == 1进行判断，注意这里判断的是减之前的值，如果值为1表示这是最后一个引用的shared_ptr，此时会调用_M_dispose()函数。

	  // Called when _M_use_count drops to zero, to release the resources
      // managed by *this.
      virtual void
      _M_dispose() noexcept = 0;

其为虚函数，其实现由派生类实现，让我们查看其中一个派生类 _Sp_counted_ptr<_Ptr, _Lp>(__p)的实现，其完整代码如下

  // Counted ptr with no deleter or allocator support
  template<typename _Ptr, _Lock_policy _Lp>
    class _Sp_counted_ptr final : public _Sp_counted_base<_Lp>
    {
    public:
      explicit
      _Sp_counted_ptr(_Ptr __p) noexcept
      : _M_ptr(__p) { }

      virtual void
      _M_dispose() noexcept
      { delete _M_ptr; }

      virtual void
      _M_destroy() noexcept
      { delete this; }

      virtual void*
      _M_get_deleter(const std::type_info&) noexcept
      { return nullptr; }

      _Sp_counted_ptr(const _Sp_counted_ptr&) = delete;
      _Sp_counted_ptr& operator=(const _Sp_counted_ptr&) = delete;

    private:
      _Ptr             _M_ptr;
    };

_M_ptr为一个指针，其在构造时由__shared_count传入，指向shared_ptr所对应的内存空间，因此我们可以发现，内存管理的任务全部交由_M_pi处理。

      void
      _M_release() noexcept
      {
        // Be race-detector-friendly.  For more info see bits/c++config.
        _GLIBCXX_SYNCHRONIZATION_HAPPENS_BEFORE(&_M_use_count);
	if (__gnu_cxx::__exchange_and_add_dispatch(&_M_use_count, -1) == 1)
	  {
            _GLIBCXX_SYNCHRONIZATION_HAPPENS_AFTER(&_M_use_count);
	    _M_dispose();
	    // There must be a memory barrier between dispose() and destroy()
	    // to ensure that the effects of dispose() are observed in the
	    // thread that runs destroy().
	    // See http://gcc.gnu.org/ml/libstdc++/2005-11/msg00136.html
	    if (_Mutex_base<_Lp>::_S_need_barriers)
	      {
		__atomic_thread_fence (__ATOMIC_ACQ_REL);
	      }

            // Be race-detector-friendly.  For more info see bits/c++config.
            _GLIBCXX_SYNCHRONIZATION_HAPPENS_BEFORE(&_M_weak_count);
	    if (__gnu_cxx::__exchange_and_add_dispatch(&_M_weak_count,
						       -1) == 1)
              {
                _GLIBCXX_SYNCHRONIZATION_HAPPENS_AFTER(&_M_weak_count);
	        _M_destroy();
              }
	  }
      }

_M_dispose()执行完之后，会再对&_M_weak_count - 1并判断，如果原始值为0则销毁_M_pi。
这里不直接销毁的原因是weak_ptr也会引用这个内存数据，我们必须在weak_ptr都不进行引用时才能对其销毁。

劲蜡鸡腿堡
关注
  • 5
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
std:shared_ptr源码解读
u013516079的博客
10-10 506
加锁的策略 _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 实现。就是构造时传入的指针指向类型，
STL源码剖析---shared_ptr
仰望星空
10-03 4474
目录 一、 引言 二、 代码实现 2.1 模拟实现shared_ptr 2.2 测试用例 三、 潜在问题分析 你可能还需要了解模拟实现C++标准库中的auto_ptr 一、 引言 与auto_ptr大同小异，shared_ptr也是一个类。可以实现多个指针指向同一个对象（引用计数）。发生拷贝的话都指向相同的内存。 每使用一次，内部引用计数加1； 每析构一次，内部引用计数减...
shared_ptr线程安全性全面分析
09-05
正如boost文档所宣称的，boost为shared_ptr提供了与内置类型同级别的线程安全性。这包括：1. 同一个shared_ptr对象可以被多线程同时读取。2. 不同的shared_ptr对象可以被多线程同时修改成
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要加锁的详细介绍
09-05
本篇文章介绍了，在C++中为什么多线程读写shared_ptr要加锁的详细说明。需要的朋友参考下
详解C++中shared_ptr的使用教程
09-02
shared_ptr能够记录对象被引用的次数,主要被用来管理动态创建的对象的销毁,这里我们就来详解C++中shared_ptr的使用教程,需要的朋友可以参考下
C++11 std::shared_ptr总结与使用示例代码详解
08-19
主要介绍了C++11 std::shared_ptr总结与使用,本文通过示例代码给大家介绍的非常详细，对大家的学习或工作具有一定的参考借鉴价值，需要的朋友可以参考下
c++11 shared_ptr 与 make_shared源码剖析
私房菜
09-16 3226
所谓智能指针，可以从字面上理解为“智能”的指针。具体来讲，智能指针和普通指针的用法是相似的，不同之处在于，智能指针可以在适当时机自动释放分配的内存。也就是说，使用智能指针可以很好地避免“忘记释放内存而导致内存泄漏”问题出现。由此可见，C++ 也逐渐开始支持垃圾回收机制了，尽管目前支持程度还有限。c++11 中发布了shared_ptrunique_ptrweak_ptr用以资源的管理，都是定义在memory 这个头文件中。
shared_ptr智能指针源码分析
irislin1988的博客
05-25 1126
先写应用代码 #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
《Effective Modern C++》学习笔记 - Item 19: 使用 std::shared_ptr 管理共享性资源（附MSVC源码解析）
アルタイル
12-28 982
很多编程语言中垃圾回收（GC）的确是非常便利的特性，但它们执行的时间往往不可预期；而C++98的全手动资源管理又显得过于“原始”了一点。将能够自动进行操作（GC）以及操作的时机可预期（析构函数）这两个优势结合在一起的，就是C++11的 std::shared_ptr。 任一个 std::shared_ptr 都不拥有它管理的对象；但它们共同确保对象不再被需要时会被销毁。其中主要的实现机制是 引用计数（reference count）：一个资源被多少个 std::shared_ptr 指向的计数。st..
C++11新特性之智能指针(shared_ptr/unique_ptr/weak_ptr)
09-01
主要介绍了C++11新特性之智能指针,包括shared_ptr, unique_ptr和weak_ptr的基本使用，感兴趣的小伙伴们可以参考一下
C++智能指针shared_ptr分析
12-26
C++智能指针shared_ptr分析 概要： shared_ptr是c++智能指针中适用场景多，功能实现较多的智能指针。它采取引用计数的方法来实现释放指针所指向的资源。下面是我代码实现的基本功能。 实例代码： template class sharedptr { public: sharedptr(T* ptr) :_ptr(ptr) , _refCount(new int(1)) {} sharedptr(sharedptr& sp) :_ptr(sp._ptr) , _refCount(sp._refCount) {
C++ unique_ptr weak_ptr shared_ptr auto_ptr智能指针.doc
07-23
四种智能指针的使用、机制和缺陷分析
C++11 智能指针之shared_ptr代码详解
08-19
主要介绍了 C++11 智能指针之shared_ptr的相关知识，本文通过实例代码给大家介绍的非常详细，对大家的学习或工作具有一定的参考借鉴价值,需要的朋友可以参考下
shared_ptr源码结构分析
PPprogrammer的博客
02-10 547
shared_ptr是智能指针的一种，相较于unique_ptr，引入了引用计数的概念，可以支持多个智能指针指向同一资源，由引用计数的增减来描述资源的共享或内存释放，引用计数降为0的时候，资源所占用的内存空间会被释放。 观察其源码结构，可以发现shared_ptr是一个模板派生类，_Ptr_base为它的基类。 Shared_ptr模板类分析 shared_ptr模板类没有自己的数据成员，而是只提供了一些供调用的接口，其中包括：构造函数(有多个不同版本的构造函数，对应不同的函数参数)，值得注意的是，其中有
C++深度探索 - shared_ptr源码分析
Huuaaaaa的博客
01-13 1214
简要分析 gcc 4.9.0版本下 shared_ptr源码。
shared_ptr源码剖析
王学门徒
05-20 828
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
std::shared_ptr 详解
热门推荐
darkGer的博客
07-13 6万+
##一、介绍 shared_ptr是一种智能指针（smart pointer），作用有如同指针，但会记录有多少个shared_ptrs共同指向一个对象。这便是所谓的引用计数（reference counting）。 一旦最后一个这样的指针被销毁，也就是一旦某个对象的引用计数变为0，这个对象会被自动删除。 ##二、shared_ptr的构造和析构 #include <iostream> ...
shared_ptr源码
最新发布
10-17
shared_ptr是C++11中引入的一种智能指针，用于管理动态分配的内存。它可以自动释放内存，避免了手动释放内存的繁琐过程，同时也避免了内存泄漏和悬空指针的问题。 shared_ptr的源码实现主要包括两个部分：引用计数和内存释放。 引用计数是指在多个shared_ptr对象共享同一个指针时，通过计数器来记录指针被引用的次数。每当一个新的shared_ptr对象指向该指针时，计数器加1；当一个shared_ptr对象被销毁时，计数器减1。当计数器为0时，表示没有任何shared_ptr对象指向该指针，此时可以释放该指针所指向的内存。 内存释放是指在引用计数为0时，释放该指针所指向的内存。shared_ptr使用delete操作符来释放内存，因此需要保证该指针是通过new操作符分配的内存。 下面是shared_ptr的简化版源码实现： ```c++ template<typename T> class shared_ptr { public: shared_ptr(T* ptr = nullptr) : ptr_(ptr), count_(new int(1)) {} ~shared_ptr() { if (--(*count_) == 0) { delete ptr_; delete count_; } } shared_ptr(const shared_ptr& other) : ptr_(other.ptr_), count_(other.count_) { ++(*count_); } shared_ptr& operator=(const shared_ptr& other) { if (this != &other) { if (--(*count_) == 0) { delete ptr_; delete count_; } ptr_ = other.ptr_; count_ = other.count_; ++(*count_); } return *this; } private: T* ptr_; int* count_; }; ``` 在上面的代码中，ptr_表示指向动态分配内存的指针，count_表示引用计数。构造函数中，如果ptr_为空，则count_初始化为1；否则，count_初始化为新分配的int类型指针，其值为1。析构函数中，如果引用计数为0，则释放ptr_和count_所指向的内存。拷贝构造函数和赋值运算符重载函数中，需要先将原有的引用计数减1，然后再将新的引用计数加1。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值