C++智能指针shared_ptrweak_ptr源码解析

Posted 2021-06-16 彼方丶

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了C++智能指针shared_ptrweak_ptr源码解析相关的知识，希望对你有一定的参考价值。

1、前言

本文仅对C++智能指针shared_ptr、weak_ptr源码进行解析，需要读者有一定的C++基础并且对智能指针有所了解，本文并不对智能指针的使用方法、使用场景、效率等方面进行阐述分析，这些知识需自行查阅相关书籍去了解

2、源码准备

本文是基于gcc-4.9.0的源代码进行分析，shared_ptr和weak_ptr是C++11才加入标准的，所以低版本的gcc源码是没有shared_ptr和weak_ptr的，建议选择4.9.0或更新的版本去学习，不同版本的gcc源码差异应该不小，但是原理和设计思想的一样的，下面给出源码下载地址
http://ftp.gnu.org/gnu/gcc

3、智能指针概念

智能指针（Smart pointers）是存储“指向动态分配（在堆上）的对象的指针”的对象。也就是说，智能指针其实是个对象。不过它的行为很像C++的内建指针，只是它们可以在适当的时候自动删除它们所指向的对象。智能指针在面对异常时有非常显著的作用，它们可以确保动态分配对象的完全析构。它们还可以用于跟踪多主人共享的动态分配对象。在概念上，智能指针可以看作拥有它所指向的对象，并因此在对象不再需要时负责将它删除。

4、源码解析

4.1、shared_ptr解析

4.1.1、shared_ptr

shared_ptr的实现位于libstdc++-v3\\include\\bits\\shared_ptr.h中

template<typename _Tp>
class shared_ptr : public __shared_ptr<_Tp>
{
public:
...
	// 构造函数
	template<typename _Tp1>
	explicit shared_ptr(_Tp1* __p)
		:__shared_ptr<_Tp>(__p)
	{
	}
...
};

由于源代码过长，这里就只贴出其中一部分进行分析：

该类没有类成员
该类继承于__shared_ptr，构造函数也只是调用了__shared_ptr的构造函数而已，将接管的普通指针传递给__shared_ptr
该类没有重载*和->运算符，从这点看shared_ptr似乎无法实现普通指针的功能，推测这两个运算符的重载是在父类__shared_ptr实现的
该类没有析构函数，从智能指针最终会自动释放内存的特性来看，释放工作肯定不是在该类进行了，接下来分析父类__shared_ptr的实现

4.1.2、__shared_ptr

__shared_ptr的实现位于libstdc++-v3\\include\\bits\\shared_ptr_base.h中

template<typename _Tp, _Lock_policy _Lp>
class __shared_ptr
{
public:
    typedef _Tp element_type;
...
	// 构造函数
	template<typename _Tp1>
	explicit __shared_ptr(_Tp1* __p)
		:_M_ptr(__p), _M_refcount(__p)
	{
		__glibcxx_function_requires(_ConvertibleConcept<_Tp1*, _Tp*>)
		static_assert( !is_void<_Tp>::value, "incomplete type" );
		static_assert( sizeof(_Tp1) > 0, "incomplete type" );
		__enable_shared_from_this_helper(_M_refcount, __p, __p);
	}

	// 析构函数
	~__shared_ptr() = default;

	typename std::add_lvalue_reference<_Tp>::type
	operator*() const noexcept
	{
		_GLIBCXX_DEBUG_ASSERT(_M_ptr != 0);
		return *_M_ptr;
	}

	_Tp*
	operator->() const noexcept
	{
		_GLIBCXX_DEBUG_ASSERT(_M_ptr != 0);
		return _M_ptr;
	}
...

private:
    _Tp* _M_ptr;    // Contained pointer.
    __shared_count<_Lp> _M_refcount;    // Reference counter.
};

同样的，源代码比较长且不是分析的重点，所以只贴出一部分进行分析：

可以看到里面有两个类成员：_M_ptr(由智能指针接管的普通指针)、_M_refcount(引用计数器)
从构造函数看，_M_ptr获得了接管的普通指针的值，而_M_refcount的构造也同样需要这个值
重载了*和->运算符，由shared_ptr继承使用，使得智能指针最终能拥有和普通指针一样行为，尽管智能指针本质上是一个对象
从析构函数来看，里面啥也没做，说明接管的普通指针也不是在这里释放的，所以有可能是由_M_refcount来完成释放内存这个工作，下面分析__shared_count的实现

4.1.3、__shared_count

__shared_count的实现位于libstdc++-v3\\include\\bits\\shared_ptr_base.h中

template<_Lock_policy _Lp>
class __shared_count
{
public:
    constexpr __shared_count() noexcept : _M_pi(0)
    {
    }

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

    template<typename _Ptr, typename _Deleter>
    __shared_count(_Ptr __p, _Deleter __d)
        :__shared_count(__p, std::move(__d), allocator<void>())
    {
    }

    template<typename _Ptr, typename _Deleter, typename _Alloc>
    __shared_count(_Ptr __p, _Deleter __d, _Alloc __a)
        :_M_pi(0)
    {
        typedef _Sp_counted_deleter<_Ptr, _Deleter, _Alloc, _Lp> _Sp_cd_type;
        typedef typename allocator_traits<_Alloc>::template rebind_traits<_Sp_cd_type> _Alloc_traits;
        typename _Alloc_traits::allocator_type __a2(__a);
        _Sp_cd_type* __mem = 0;
        __try
        {
            __mem = _Alloc_traits::allocate(__a2, 1);
            _Alloc_traits::construct(__a2, __mem, __p, std::move(__d), std::move(__a));
            _M_pi = __mem;
        }
        __catch(...)
        {
            __d(__p); // Call _Deleter on __p.
            if (__mem)
                _Alloc_traits::deallocate(__a2, __mem, 1);
            __throw_exception_again;
        }
    }

    template<typename _Tp, typename _Alloc, typename... _Args>
    __shared_count(_Sp_make_shared_tag, _Tp*, const _Alloc& __a, _Args&&... __args)
        :_M_pi(0)
    {
        typedef _Sp_counted_ptr_inplace<_Tp, _Alloc, _Lp> _Sp_cp_type;
        typedef typename allocator_traits<_Alloc>::template rebind_traits<_Sp_cp_type> _Alloc_traits;
        typename _Alloc_traits::allocator_type __a2(__a);
        _Sp_cp_type* __mem = _Alloc_traits::allocate(__a2, 1);
        __try
        {
            _Alloc_traits::construct(__a2, __mem, std::move(__a),
            std::forward<_Args>(__args)...);
            _M_pi = __mem;
        }
        __catch(...)
        {
            _Alloc_traits::deallocate(__a2, __mem, 1);
            __throw_exception_again;
        }
    }

    // Special case for unique_ptr<_Tp,_Del> to provide the strong guarantee.
    template<typename _Tp, typename _Del>
    explicit __shared_count(std::unique_ptr<_Tp, _Del>&& __r)
        :_M_pi(0)
    {
        using _Ptr = typename unique_ptr<_Tp, _Del>::pointer;
        using _Del2 = typename conditional<is_reference<_Del>::value, reference_wrapper<typename remove_reference<_Del>::type>, _Del>::type;
        using _Sp_cd_type = _Sp_counted_deleter<_Ptr, _Del2, allocator<void>, _Lp>;
        using _Alloc = allocator<_Sp_cd_type>;
        using _Alloc_traits = allocator_traits<_Alloc>;
        _Alloc __a;
        _Sp_cd_type* __mem = _Alloc_traits::allocate(__a, 1);
        _Alloc_traits::construct(__a, __mem, __r.release(), __r.get_deleter());  // non-throwing
        _M_pi = __mem;
    }

    // Throw bad_weak_ptr when __r._M_get_use_count() == 0.
    explicit __shared_count(const __weak_count<_Lp>& __r);

    // Does not throw if __r._M_get_use_count() == 0, caller must check.
    explicit __shared_count(const __weak_count<_Lp>& __r, std::nothrow_t);

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

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

    void _M_swap(__shared_count& __r) noexcept
    {
        _Sp_counted_base<_Lp>* __tmp = __r._M_pi;
        __r._M_pi = _M_pi;
        _M_pi = __tmp;
    }

    long _M_get_use_count() const noexcept
    { return _M_pi != 0 ? _M_pi->_M_get_use_count() : 0; }

    bool _M_unique() const noexcept
    { return this->_M_get_use_count() == 1; }

    void* _M_get_deleter(const std::type_info& __ti) const noexcept
    { return _M_pi ? _M_pi->_M_get_deleter(__ti) : nullptr; }

    bool _M_less(const __shared_count& __rhs) const noexcept
    { return std::less<_Sp_counted_base<_Lp>*>()(this->_M_pi, __rhs._M_pi); }

    bool _M_less(const __weak_count<_Lp>& __rhs) const noexcept
    { return std::less<_Sp_counted_base<_Lp>*>()(this->_M_pi, __rhs._M_pi); }

    // Friend function injected into enclosing namespace and found by ADL
    friend inline bool operator==(const __shared_count& __a, const __shared_count& __b) noexcept
    { return __a._M_pi == __b._M_pi; }

private:
    friend class __weak_count<_Lp>;
    _Sp_counted_base<_Lp>* _M_pi;
}

从源代码可以获得以下几点信息：

有一个类成员：_M_pi(计数器)
只有构造函数为_M_pi分配了内存，并且该类并没有直接持有从前面一直传递过来的那个普通指针，而是继续将其传递给_M_pi，所以内存的释放也不是直接在该类进行的。
拷贝构造函数没有分配内容，而是把拷贝对象的_M_pi直接拿过来了，有点类似于浅拷贝的意思，然后调用了_M_pi的_M_add_ref_copy方法（后面会讲），增加了一次引用计数。赋值函数也是同样的道理，但是由于赋值函数的特殊性（当赋值对象原先就存在时调用赋值函数，否则调用拷贝构造函数），要先调用_M_pi的_M_release方法（后面会讲）将自己持有的内存释放掉，其余操作和拷贝构造函数是一样的
从析构函数中可以看到，里面并没有直接释放掉为_M_pi分配的内存，而是调用了_M_pi的_M_release方法，可以大概猜测是通过_M_release方法释放了_M_pi的内存(delete this指针，后面会讲)
由于__shared_count里面的方法都是借助_M_pi实现的，并且到这里都还没有见到释放那个普通指针的代码，所以还是得继续看_M_pi究竟做了什么事，接下来继续看_Sp_counted_base的实现

4.1.4、_Sp_counted_base

_Sp_counted_base的实现位于libstdc++-v3\\include\\bits\\shared_ptr_base.h中

template<_Lock_policy _Lp = __default_lock_policy>
class _Sp_counted_base : public _Mutex_base<_Lp>
{
public:
    _Sp_counted_base() noexcept
        : _M_use_count(1), _M_weak_count(1)
    {
    }
  
    virtual ~_Sp_counted_base() noexcept
    {
    }

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

    virtual void* _M_get_deleter(const std::type_info&) noexcept = 0;

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

    void _M_add_ref_lock();

    bool _M_add_ref_lock_nothrow();

    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)
            {
                _GLIBCXX_READ_MEM_BARRIER;
                _GLIBCXX_WRITE_MEM_BARRIER;
            }

            // 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_add_ref() noexcept
    { __gnu_cxx::__atomic_add_dispatch(&_M_weak_count, 1); }

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

    long _M_get_use_count() const noexcept
    {
        // No memory barrier is used here so there is no synchronization
        // with other threads.
        return __atomic_load_n(&_M_use_count, __ATOMIC_RELAXED);
    }

private:
    _Sp_counted_base(_Sp_counted_base const&) = delete;
    _Sp_counted_base& operator=(_Sp_counted_base const&) = delete;

    _Atomic_word  _M_use_count;     // #shared
    _Atomic_word  _M_weak_count;    // #weak + (#shared != 0)
};

从源代码可以获得以下几点信息：

有两个类成员：_M_use_count(引用计数)、_M_weak_count(弱引用计数)
_M_release方法是该类的关键，可以看到首先判断_M_use_count是否为1(无其他人引用)，如果为1，则调用_M_dispose方法(虚函数，由派生类实现，估计是释放前面一直说的那个裸指针以及其他的一些操作)。接下来判断_M_weak_count是否为1(无其他人引用)，如果为1，则调用_M_destroy方法，而_M_destroy方法里面释放了this指针，和前面的猜测一致
从_M_release可以看出，智能指针所接管的那个普通指针只和_M_use_count有关，当_M_use_count减完时就会将其释放了，
而_M_weak_count也是有作用的，他负责释放_Sp_counted_base本身，这也就是为什么weak_ptr可以保证智能指针这个对象有效，但不保证
其引用的普通指针有效的原因了（这点和shared_ptr、weak_ptr的定义是完全一致的）
其他的方法就很简单了，比如_M_add_ref_copy方法将引用计数_M_use_count加一，_M_weak_add_ref方法将弱引用计数_M_weak_count加一，这里就不赘述了，大家可以自行看一下具体实现

4.1.5、_Sp_counted_ptr

_Sp_counted_ptr的实现位于libstdc++-v3\\include\\bits\\shared_ptr_base.h中

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

从源代码中可以看到_Sp_counted_ptr是_Sp_counted_base的派生类，并且__shared_count在初始化_M_pi时用的也是_Sp_counted_ptr。
接着看_M_dispose方法的实现，里面确实删除了一开始shared_ptr接管的指针，_M_destroy
以上是关于C++智能指针shared_ptrweak_ptr源码解析的主要内容，如果未能解决你的问题，请参考以下文章

C++11之智能指针（unique_ptrshared_ptrweak_ptrauto_ptr）浅谈内存管理

C++｜深入理解智能指针

C++智能指针详解:智能指针的引入

C++智能指针

C++ 智能指针性能

C++ 和智能指针——智能指针在这种情况下有啥帮助？

C++智能指针shared_ptrweak_ptr源码解析