[STL] std::shared_ptr笔记

已于 2022-10-14 11:12:19 修改
阅读量551 收藏
点赞数
分类专栏： [笔记] 文章标签： c++ 开发语言
于 2022-08-23 20:51:13 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_38734472/article/details/126486549
版权

[STL] std::shared_ptr笔记

std::shared_ptr 简易uml(只简单包含member variable&重要member function)

std::shared_ptr 简易uml

初始化以及引起引用计数变化的原因

这里暂时省略了std::make_shared<>的初始化。使用Tp *ptr指针初始化std::shared_ptr时，如果ptr == nullptr，那么_M_ptr和_M_refcount都是nullptr。否则，_M_ptr = ptr，然后申请控制块的内存。

      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 _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_use_count和_M_weak_count都为1。这两个字段代表shared的引用计数以及弱引用计数。引起_M_use_count和_M_weak_count的情况包括：

  1. std::shared_ptr的复制构造：_M_use_count => _M_use_count + 1
  2. 复制拷贝: _M_use_count => _M_use_count + 1，同时会调用_M_release()导致_M_use_count和_M_weak_count减1。
      __shared_count&
      operator=(const __shared_count& __r) noexcept
      {
	_Sp_counted_base<_Lp>* __tmp = __r._M_pi;
	if (__tmp != _M_pi)
	  {
	    if (__tmp != nullptr)
	      __tmp->_M_add_ref_copy();
	    if (_M_pi != nullptr)
	      _M_pi->_M_release();
	    _M_pi = __tmp;
	  }
	return *this;
      }
  1. reset() : 与初始化的std::shared_ptr执行swap操作，然后依赖~shared_ptr减少_M_use_count和_M_weak_count。
      void
      reset() noexcept
      { __shared_ptr().swap(*this); }

      ~__shared_count() noexcept
      {
	if (_M_pi != nullptr)
	  _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();
              }
	  }
      }

std::weak_ptr

  template<typename _Tp>
    class shared_ptr : public __shared_ptr<_Tp>
    {
    	// ...
    	friend class weak_ptr<_Tp>;
    }

std::weak_ptr使用std::shared_ptr对象初始化，它们公用由std::shared_ptr(不为nullptr的情况下)创建的控制块。初始化完毕后_M_weak_count+1。

lock

      shared_ptr<_Tp>
      lock() const noexcept
      { return shared_ptr<_Tp>(*this, std::nothrow); }


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

      // This constructor is used by __weak_ptr::lock() and
      // shared_ptr::shared_ptr(const weak_ptr&, std::nothrow_t).
      __shared_ptr(const __weak_ptr<_Tp, _Lp>& __r, std::nothrow_t) noexcept
      : _M_refcount(__r._M_refcount, std::nothrow)
      {
	_M_ptr = _M_refcount._M_get_use_count() ? __r._M_ptr : nullptr;
      }


  template<>
    inline bool
    _Sp_counted_base<_S_atomic>::
    _M_add_ref_lock_nothrow() noexcept
    {
      // Perform lock-free add-if-not-zero operation.
      _Atomic_word __count = _M_get_use_count();
      do
	{
	  if (__count == 0)
	    return false;
	  // Replace the current counter value with the old value + 1, as
	  // long as it's not changed meanwhile.
	}
      while (!__atomic_compare_exchange_n(&_M_use_count, &__count, __count + 1,
					  true, __ATOMIC_ACQ_REL,
					  __ATOMIC_RELAXED));
      return true;
    }

调用栈为:
lock调用栈
lock()其实就是判断_M_use_count是否大于0，如果大于0则创建一个新的shared_ptr对象，这里用到了诸如std::atomic_compare_exchange_weak的原子操作。当对_M_use_count更新成功时，使用的是memory order是memory_order_acq_rel。

_M_release()内存屏障

在_M_release()函数中，它的_M_dispose()函数其实是一个读操作，在当前线程使用memory fence可以确保在其之后的if条件语句重排到_M_dispose()之前。否则先delete this再delete _M_ptr则会coredump。如果另一个线程在执行_M_weak_release()而产生data race，那么说明_M_release()对_M_weak_count同步于_M_weak_release()线程的同时，因为线程__atomic_thread_fence限制了_M_dispose()的重排，weak线程也有一个__atomic_thread_fence也限制了_M_destroy()的重排，所以_M_dispose()先序于_M_destroy()。

      virtual void
      _M_dispose() noexcept
      { delete _M_ptr; }

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

    void
    _M_weak_release() noexcept
    {
      // 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);
        if (_Mutex_base<_Lp>::_S_need_barriers)
        {
          // See _M_release(),
          // destroy() must observe results of dispose()
          __atomic_thread_fence(__ATOMIC_ACQ_REL);
        }
        _M_destroy();
      }
    }

单线程shared_ptr实现

#pragma once
#include <cstddef>

namespace TinyNet {
template <typename T> class ThreadUnsafeSharedPtr;
template <typename T> class ThreadUnsafeWeakPtr;
template <typename Tp> class shared_weak_count;

template <typename Tp> class shared_weak_count {
public:
  constexpr shared_weak_count() noexcept
      : m_use_count{0}, m_weak_count{0}, m_ptr{nullptr} {}

  template <typename Yp>
  explicit shared_weak_count(Yp *ptr)
      : m_use_count{1}, m_weak_count{1}, m_ptr{ptr} {}

  inline void add_ref_copy() { m_use_count += 1; }

  inline void add_weak_copy() { m_weak_count += 1; }

  inline int get_use_count() { return m_use_count; }

  inline void dispose() { delete m_ptr; }

  inline void destroy() { delete this; }

  void release() {
    if (--m_use_count == 0) {
      dispose();
      if (--m_weak_count == 0) {
        destroy();
      }
    }
  }

  void weak_release() {
    if (--m_weak_count == 0) {
      destroy();
    }
  }

private:
  // friend class ThreadUnsafeSharedPtr<Tp>;
  // friend class ThreadUnsafeWeakPtr<Tp>;
  int m_use_count;
  int m_weak_count;
  Tp *m_ptr;
};

// todo: operator->和operator *
template <typename T> class ThreadUnsafeSharedPtr {

public:
  constexpr ThreadUnsafeSharedPtr() : m_ptr{nullptr}, m_refcount{nullptr} {}

  constexpr ThreadUnsafeSharedPtr(nullptr_t) noexcept
      : ThreadUnsafeSharedPtr() {}

  template <typename Yp>
  ThreadUnsafeSharedPtr(Yp *ptr)
      : m_ptr{ptr}, m_refcount{new shared_weak_count<Yp>(ptr)} {}

  ThreadUnsafeSharedPtr(const ThreadUnsafeWeakPtr<T> &r) noexcept
      : m_refcount{r.m_weakcount} {
    if (m_refcount == nullptr) [[unlikely]] {
      m_ptr = nullptr;
    } else {
      /**
       * 如果lock失败, 返回的ThreadUnsafeSharedPtr应为初始状态
       * 即m_ptr = nullptr, m_refcount = nullptr
       */
      bool lockSucc = m_refcount->get_use_count() > 0;
      if (lockSucc) [[likely]] {
        m_ptr = r.m_ptr;
        m_refcount->add_ref_copy(); // 如果能够lock, use_count引用+1
      } else {
        m_ptr = nullptr;
        m_refcount = nullptr;
      }
    }
  }

  ThreadUnsafeSharedPtr(const ThreadUnsafeSharedPtr &r)
      : m_ptr{r.m_ptr}, m_refcount{r.m_refcount} {
    if (m_refcount != nullptr) {
      m_refcount->add_ref_copy();
    }
  }

  ThreadUnsafeSharedPtr(ThreadUnsafeSharedPtr &&r)
      : m_ptr{r.m_ptr}, m_refcount{r.m_refcount} {
    r.m_ptr = nullptr;
    r.m_refcount = nullptr;
  }

  ThreadUnsafeSharedPtr &operator=(const ThreadUnsafeSharedPtr &r) {
    m_ptr = r.m_ptr;
    shared_weak_count<T> *tmp = r.m_refcount;
    if (tmp != m_refcount) {
      if (tmp != nullptr) {
        tmp->add_ref_copy();
      }

      if (m_refcount != nullptr) {
        m_refcount->release();
      }

      m_refcount = tmp;
    }
    return *this;
  }

  ThreadUnsafeSharedPtr &operator=(ThreadUnsafeSharedPtr &&r) {
    m_ptr = r.m_ptr;
    // 如果this对象不为nullptr, 则release
    if (m_refcount != nullptr) {
      m_refcount->release();
    }
    m_refcount = r.m_refcount;
    r.m_ptr = nullptr;
    r.m_refcount = nullptr;
    return *this;
  }

  T *operator->() const noexcept { return m_ptr; }

  T *get() const noexcept { return m_ptr; }

  T &operator*() const noexcept { return *m_ptr; }

  int use_count() const noexcept {
    return m_refcount ? m_refcount->get_use_count() : 0;
  }

  explicit operator bool() const noexcept { return m_ptr != nullptr; }

  ~ThreadUnsafeSharedPtr() {
    if (m_refcount != nullptr) {
      m_refcount->release();
    }
  }

private:
  friend class ThreadUnsafeWeakPtr<T>;
  T *m_ptr;
  shared_weak_count<T> *m_refcount;
};

template <typename T> class ThreadUnsafeWeakPtr {
public:
  constexpr ThreadUnsafeWeakPtr() : m_ptr{nullptr}, m_weakcount{nullptr} {}

  constexpr ThreadUnsafeWeakPtr(nullptr_t) noexcept : ThreadUnsafeWeakPtr() {}

  ThreadUnsafeWeakPtr(const ThreadUnsafeSharedPtr<T> &r) noexcept
      : m_ptr{r.m_ptr}, m_weakcount{r.m_refcount} {
    if (m_weakcount != nullptr) {
      m_weakcount->add_weak_copy();
    }
  }

  ThreadUnsafeWeakPtr(const ThreadUnsafeWeakPtr &r)
      : m_ptr{r.m_ptr}, m_weakcount{r.m_weakcount} {
    if (m_weakcount != nullptr) {
      m_weakcount->add_weak_copy();
    }
  }

  ThreadUnsafeWeakPtr(ThreadUnsafeWeakPtr &&r) noexcept
      : m_ptr{r.m_ptr}, m_weakcount{r.m_weakcount} {
    r.m_ptr = nullptr;
    r.m_weakcount = nullptr;
  }

  ThreadUnsafeWeakPtr &operator=(const ThreadUnsafeWeakPtr &r) noexcept {
    m_ptr = r.m_ptr;
    shared_weak_count<T> *tmp = r.m_weakcount;
    // 如果r对象不为null, 则增加其weak_count
    if (tmp != nullptr) {
      tmp->add_weak_copy();
    }

    // 如果this对象不为null, 则需要减少其weak_count
    if (m_weakcount != nullptr) {
      m_weakcount->weak_release();
    }
    m_weakcount = tmp;
    return *this;
  }

  ThreadUnsafeWeakPtr &operator=(ThreadUnsafeWeakPtr &&r) noexcept {
    m_ptr = r.m_ptr;
    if (m_weakcount != nullptr) {
      m_weakcount->weak_release(); // 更新this对象的weakcount状态
    }
    m_weakcount = r.m_weakcount;
    r.m_ptr = nullptr;
    r.m_weakcount = nullptr;
    return *this;
  }

  ~ThreadUnsafeWeakPtr() {
    if (m_weakcount != nullptr) {
      m_weakcount->weak_release();
    }
  }

  ThreadUnsafeSharedPtr<T> lock() const noexcept {
    return ThreadUnsafeSharedPtr<T>(*this);
  }

  int use_count() const noexcept {
    return m_weakcount != nullptr ? m_weakcount->get_use_count() : 0;
  }

private:
  friend class ThreadUnsafeSharedPtr<T>;
  T *m_ptr;
  shared_weak_count<T> *m_weakcount;
};

template <typename Tp>
inline bool operator==(const ThreadUnsafeSharedPtr<Tp> &a, nullptr_t) noexcept {
  return !a;
}
}; // namespace TinyNet
1nv1s1ble
关注
专栏目录
Boost库之shared_ptr应用
hlj_include的博客
08-29 764
概解：      shared_ptr非常有价值、非常重要、非常有用！      shared_ptr是一个最像指针的"智能指针"，是boost::smart_ptr库中最有价值、最重要的组成部分，也是最有用的，Boost库中许多组件--甚至还包括其他一些领域的智能指针都使用了shared_ptr。      shared_ptr与scoped_ptr一样包装了new操作符在堆上分配的动态对
《C++标准库》学习笔记 — STL — 并发 — 线程同步与并发 — mutex 与 lock
coding-hwz
12-08 1420
《C++标准库》学习笔记 — STL — 并发 — 线程同步与并发一、线程同步与并发并发问题1、出错情况（1）未同步化的数据访问（2）写至半途的数据（3）重新安排的语句2、解决问题需要的特征3、C++并发的支持 一、线程同步与并发并发问题 1、出错情况 （1）未同步化的数据访问 并行运行的两个线程分别读和写同一个数据。 std:;vector<int> vec; if (!vec.empty()) { std::cout << v.front() << std::end
C++11 std::make_shared 与 std::shared_ptr双剑合璧
msdb198901的博客
05-10 4599
项目做完上线，发现存在内存泄漏。因为客户端链接到服务器时传统new出来对象，断开链接后没有进行释放。 一、定时检测对象释放情况 代码如下： //1、开启服务监听 bool CWebServer::StartServer(const std::string& strIp, uint16 nPort) { try{ boost::system::error_code ec; #i...
使用智能指针std::shared_ptr std::make_shared管理申请通用内存，含例子
weixin_41176628的博客
02-21 1470
一、介绍 首先shared_ptr类型是 C++ 标准库中的一个智能指针，是为多个所有者可能必须管理对象在内存中的生命周期的方案设计的。 在您初始化一个 shared_ptr 之后，您可复制它，按值将其传入函数参数，然后将其分配给其他 shared_ptr 实例。 所有实例均指向同一个对象，并共享对一个“控制块”（每当新的 shared_ptr 添加、超出范围或重置时增加和减少引用计数）的访问权限...
Modern C++——无所有权指针的安全性保障
最新发布
方亮的专栏
08-31 1734
weak_ptr::lock没有任何原子操作，只是会生成一个shared_ptr副本。因为shared_ptr副本的生成，导致其引用计数原子递增，从而保证在使用该副本期间，它所管理的对象不会被释放。
【C++】std::make_shared函数的详解与示例
不定时分享，互相学习，共同进步
08-01 5213
在C++中，智能指针是一种非常重要的资源管理技术，用于自动管理动态分配的内存，以防止内存泄漏。std::shared_ptr是C++标准库中的一个智能指针类型，它通过使用引用计数来确保当最后一个shared_ptr被销毁或重置时，它所指向的对象也会被自动删除。而std::make_shared则是C++11引入的一个模板函数，用于更高效地创建std::shared_ptr实例。本文将详细解析std::make_shared函数的原理，并提供相关示例。
C/C++｜我们为什么应该使用 `std::make_shared` 创建 `std::shared_ptr`
糖炒栗子
05-31 2370
std::make_shared 是 C++11 引入的一个工厂函数，用于创建 std::shared_ptr。与直接使用 new 并将其传递给 std::shared_ptr 构造函数相比，std::make_shared 提供了一种更高效、更安全的方法来分配和管理动态内存。前置知识1：这一步创建了一个对象，分配了控制块的内存。控制块包含了引用计数等等信息。前置知识2：当你使用 std::make_shared 时，这两个步骤被合并为一个原子操作，。好了，从前置知识里我们应该就能大概猜到。
linux C++共享指针（std::shared_ptr、std::make_shared）共享对象，reset()重置共享指针，use_count()查看引用计数，与unique_ptr区别
Dontla的博客
02-14 2557
共享指针是一种智能指针，它提供了与 std::unique_ptr 相似的语法，但是它允许多个指针共享同一对象的所有权。可以在共享对象的析构函数中设置标识，然后在确定引用计数为0后，检查这个标识以确定共享对象是否已销毁。然后我们复制这个指针到了 event2，现在两个指针都指向了同一个字符串。当不再需要该对象时，共享指针会自动计数，并在没有任何指针指向该对象时释放它。时，因为两个指针都不再引用这个字符串，所以这个字符串就会被销毁。创建了一个指向字符串的。上面代码中，我们通过。
std::shared_ptr data
08-24
- *2* *3* [[STL] std::shared_ptr笔记](https://blog.csdn.net/weixin_38734472/article/details/126486549)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt...
初探boost之smart_ptr库学习笔记
wangxiaobupt的专栏
07-15 2309
概述   Boost.smart
STL_Sources:学习《 STL源码剖析》，存放相关的个人代码及学习笔记
03-23
6. **智能指针**：虽然不是STL的原始部分，但在C++11及以后的版本中，shared_ptr、unique_ptr和weak_ptr等智能指针成为标准库的一部分，它们自动管理对象的生命周期，降低了内存管理的复杂性。 7. **内存管理**：...
深入理解C++ `std::shared_ptr` 和 `std::make_shared`
深耕嵌入式领用多年， 致力于分享嵌入式领域技术!
04-02 461
深入理解C++ `std::shared_ptr` 和 `std::make_shared`
shared_ptr 和 make_shared 的使用（以及qt信号和槽连接）
biao2488890051的博客
07-27 4047
它能够记录多少个shared_ptr共同指向一个对象，从而消除显示的调用delete，当引用计数变为零的时候就会将对象自动删除。主要功能是在动态内存中分配一个对象并初始化它，stdshared_ptr可以通过。方法来获取原始指针，通过。来查看一个对象的引用计数。.........
std::make_shared特点
春夜喜雨的专栏
06-19 5178
std::make_shared的使用，从堆上内存分配的角度来看，对比直接使用std::shared_ptr构造，可以减少一次堆内存的申请。
shared_ptr 和 make_shared 简介
SimpleLearning
12-12 1423
shared_ptr 和 make_shared 简介
智能指针 与 shared_from_this 源码解析
Z1042300201的专栏
04-20 675
本文讲述智能指针和shared_from_this的原理与源码解析
源码分析shared_ptr实现
qq_29426201的博客
05-29 733
智能指针是C++中一项很常用的技术，合理的使用智能指针可以更方便的管理内存，降低内存泄漏的风险，这里只介绍C++11后官方的智能指针。 智能指针的种类 unique_ptr shared_ptr weak_ptr 关于智能指针使用以及区别可以自行查找资料，这里主要介绍智能指针的实现原理 shared_ptr的实现 我们平时看文档都知道shared_ptr内部是使用引用计数来记录托管指针被引用的次数，当托管指针的引用计数为0时会释放托管的内存，这里通过gcc源码探究shared_ptr内部究竟是如
pragma comment(linker,"/SECTION:shared,RWS")
weixin_33804990的博客
06-26 261
2019独角兽企业重金招聘Python工程师标准>>> ...
Effective Modern C++ 条款21 比起直接使用new，更偏爱使用std::make_unique和std::make_shared
大黄鸭
08-28 5333
Effective Modern C++ 条款21
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值