【weak_ptr导读】 weak_ptr是一种比较特殊的智能指针，不像unique_ptr、shared_ptr一样可以托管原始的指针，它更多扮演着辅助的角色，配合shared_ptr去使用，那它背后的原理是怎样的？
**1. weak_ptr初探 **
weak_ptr不像shared_ptr、unique_ptr一样，有独立的.h文件和.cpp文件加以实现，首先可以看weak_ptr的源码(libstdc++-v3\include\bits\shared_ptr.h)。
template<typename _Tp>class weak_ptr : public __weak_ptr<_Tp>{public: constexpr weak_ptr() noexcept : __weak_ptr<_Tp>() { } template<typename _Tp1, typename = typename std::enable_if<std::is_convertible<_Tp1*, _Tp*>::value>::type> weak_ptr(const weak_ptr<_Tp1>& __r) noexcept : __weak_ptr<_Tp>(__r) { } template<typename _Tp1, typename = typename std::enable_if<std::is_convertible<_Tp1*, _Tp*>::value>::type> weak_ptr(const shared_ptr<_Tp1>& __r) noexcept : __weak_ptr<_Tp>(__r) { } template<typename _Tp1> weak_ptr& operator=(const weak_ptr<_Tp1>& __r) noexcept { this->__weak_ptr<_Tp>::operator=(__r); return *this; } template<typename _Tp1> weak_ptr& operator=(const shared_ptr<_Tp1>& __r) noexcept { this->__weak_ptr<_Tp>::operator=(__r); return *this; } shared_ptr<_Tp> lock() const noexcept { return shared_ptr<_Tp>(*this, std::nothrow); }}
从weak_ptr的实现可以看出，它暴露给外部的接口，只有基本的构造、拷贝赋值以及大家耳熟能详的lock接口，该类内部并没有指针成员及引用计数的成员，因为我们是没法按照下面这种方式去构造一个weak_ptr对象出来的，或者直接使用*获取weak_ptr托管的内存资源。
weak_ptr<char> wp(new char[1024]);
更多的是按照如下的方式去获得一个weak_ptr对象。
shared_ptr<char> sp(new char[1024]);weak_ptr<char> wp = sp;
把一个shared_ptr拷贝赋值给weak_ptr，内部也是调用__weak_ptr模板类的拷贝构造函数。那么我们进一步剖析下__weak_ptr的源码。
2. __weak_ptr初探
template<typename _Tp, _Lock_policy _Lp>class __weak_ptr{
public:
typedef _Tp element_type;
constexpr __weak_ptr() noexcept
: _M_ptr(0) , _M_refcount() {} __weak_ptr(const __weak_ptr&) noexcept = default; __weak_ptr& operator=(const __weak_ptr&) noexcept = default; ~__weak_ptr() = default; template<typename _Tp1, typename = typename std::enable_if<std::is_convertible<_Tp1*, _Tp*>::value>::type> __weak_ptr(const __weak_ptr<_Tp1, _Lp>& __r) noexcept : _M_refcount(__r._M_refcount) { _M_ptr = __r.lock().get(); } template<typename _Tp1, typename = typename std::enable_if<std::is_convertible<_Tp1*, _Tp*>::value>::type> __weak_ptr(const __shared_ptr<_Tp1, _Lp>& __r) noexcept : _M_ptr(__r._M_ptr) , _M_refcount(__r._M_refcount) {} template<typename _Tp1> __weak_ptr& operator=(const __weak_ptr<_Tp1, _Lp>& __r) noexcept { _M_ptr = __r.lock().get(); _M_refcount = __r._M_refcount; return *this; } template<typename _Tp1> __weak_ptr& operator=(const __shared_ptr<_Tp1, _Lp>& __r) noexcept { _M_ptr = __r._M_ptr; _M_refcount = __r._M_refcount; return *this; } __shared_ptr<_Tp, _Lp> lock() const noexcept { return __shared_ptr<element_type, _Lp>(*this, std::nothrow); } long use_count() const noexcept { return _M_refcount._M_get_use_count(); } bool expired() const noexcept { return _M_refcount._M_get_use_count() == 0; } template<typename _Tp1> bool owner_before(const __shared_ptr<_Tp1, _Lp>& __rhs) const { return _M_refcount._M_less(__rhs._M_refcount); } template<typename _Tp1> bool owner_before(const __weak_ptr<_Tp1, _Lp>& __rhs) const { return _M_refcount._M_less(__rhs._M_refcount); } void reset() noexcept { __weak_ptr().swap(*this); }
void swap(__weak_ptr& __s) noexcept { std::swap(_M_ptr, __s._M_ptr); _M_refcount._M_swap(__s._M_refcount); } private: // Used by __enable_shared_from_this. void _M_assign(_Tp* __ptr, const __shared_count<_Lp>& __refcount) noexcept { _M_ptr = __ptr; _M_refcount = __refcount; } template<typename _Tp1, _Lock_policy _Lp1> friend class __shared_ptr; template<typename _Tp1, _Lock_policy _Lp1> friend class __weak_ptr; friend class __enable_shared_from_this<_Tp, _Lp>; friend class enable_shared_from_this<_Tp>; /* 虽然weak_ptr不托管内存，但内部还需要维护一份内的副本_M_ptr 从shared_ptr拷贝构造weak_ptr时，_M_ptr便指向shared_ptr托管的内存地址， 仅仅是浅拷贝而已。调用lock接口将weak_ptr转换成shared_ptr， 也只是将_weak_ptr管理的_M_ptr转换成shared_ptr维护的_M_ptr而已， 同样不涉及深拷贝。 */ _Tp* _M_ptr; __weak_count<_Lp> _M_refcount; // Reference counter.}
__weak_ptr有两个成员变量,托管的普通内存指针_M_ptr、弱引用计数_M_refcount（类型为__weak_count），__weak_ptr的弱引用计数_M_refcount一般是从__shared_ptr或者其它的__weak_ptr的_M_refcount构造而来，正因为如此，用shared_ptr初始化一个weak_ptr并不会再增加shared_ptr托管内存的引用计数。既然拷贝构造不会增加托管内存的引用计数，那weak_ptr的lock方法会增加托管内存的引用计数吗？答案是会的哈！且看如下示例：
调用lock接口，归根结底就是将weak_ptr构造出一个shared_ptr对象出来，回顾上一节《shared_ptr源码剖析》，shared_ptr的构造函数最终会调用到__shared_ptr的构造函数。
shared_ptr(const weak_ptr<_Tp>& __r, std::nothrow_t) : __shared_ptr<_Tp>(__r, std::nothrow){}
__shared_ptr构造函数的源码如下：
__shared_ptr(const __weak_ptr<_Tp, _Lp>& __r, std::nothrow_t) : _M_refcount(__r._M_refcount, std::nothrow){ _M_ptr = _M_refcount._M_get_use_count() ? __r._M_ptr : nullptr;}
weak_ptr的lock接口，最终会用_weak_count去构造一个__shared_count，如果引用计数不为0就正常构造一个shared_ptr出来。那当前shared_ptr的引用计数为何会增加1呢？且看__shared_count的构造函数。
template<_Lock_policy _Lp>inline __shared_count<_Lp>::__shared_count(const __weak_count<_Lp>& __r, std::nothrow_t) :_M_pi(__r._M_pi){ if (_M_pi != nullptr) if (!_M_pi->_M_add_ref_lock_nothrow()) _M_pi = nullptr;}
template<>inline bool _Sp_counted_base<_S_single>::_M_add_ref_lock_nothrow(){ if (_M_use_count == 0) return false; ++_M_use_count; return true;}
__shared_count的构造函数，最终会调用它的成员变量``_M_pi的 _M_add_ref_lock_nothrow接口，进行引用计数的递增操作，也即同一块内存是共用一个_Sp_counted_base的。调用weak_ptr的lock接口，最终还是会增加初始化weak_ptr的shared_ptr对象托管内存的引用计数。即解释了为啥lock接口之后，shared_ptr的引用计数会增加1。那么weak_ptr的引用计数为何也递增1呢？切看weak_ptr的use_count()接口。
long use_count() const noexcept{ return _M_refcount._M_get_use_count(); }
` _M_refcount是__weak_count类型的成员变量，那么进一步剖析__weak_count的源码。 ``
3. __weak_count初探
template<_Lock_policy _Lp>class __weak_count{ public: constexpr __weak_count() noexcept : _M_pi(0) { } __weak_count(const __shared_count<_Lp>& __r) noexcept : _M_pi(__r._M_pi) { if (_M_pi != 0) _M_pi->_M_weak_add_ref(); } ...... ~__weak_count() noexcept { if (_M_pi != 0) _M_pi->_M_weak_release(); } long _M_get_use_count() const noexcept { return _M_pi != 0 ? _M_pi->_M_get_use_count() : 0; } private: friend class __shared_count<_Lp>; _Sp_counted_base<_Lp>* _M_pi; };
从__weak_count的源码可以看出，获取weak_ptr引用计数的接口，最终还是会调用_Sp_counted_base维护的引用计数，该引用计数和shared_ptr是同一份。那么现在大家应该知道为啥weak_ptr lock()之后，weak_ptr的引用计数也会递增1了。 ``
**4. 总结 **
1、weak_ptr更多是对shared_ptr托管内存的一个弱引用，不参与托管内存的生命周期的管理，从__weak_ptr的析构函数可以看出，它并没有对它维护的_M_ptr 执行释放操作。 2、weak_ptr的应用场景，在跨模块传递内存时，A模块申请的内存想传递给B模块使用时，B模块可以使用weak_ptr去接管这份内存，如果A模块没有释放这份内存，那么B模块就拿来使用；反之就不用，B模块不参与A模块的内存管理，同时也极大降低了野指针的风险。
