C++ enable_shared_from_this 具体实现
C++ enable_shared_from_this 具体实现
C++ 中使用 std::shared_ptr 智能指针不当有可能会造成循环引用，因为 std::shared_ptr 内部是基于引用计数来实现的， 当引用计数为 0 时，就会释放内部持有的裸指针。但是当 a 持有 b， b 也持有 a 时，相当于 a 和 b 的引用计数都至少为 1，因此得不到释放，RAII 此时也无能为力。这时就需要使用 weak_ptr 来打破循环引用。
通过 weak_ptr 来避免循环引用
来看一个比较典型的 delegate/observer 的场景：
#include <iostream>
#include <memory>
class DataFetcher {
public:
class Delegate {
public:
~Delegate() = default;
virtual void OnDataReady(void* any_data) = 0;
};
DataFetcher(std::weak_ptr<Delegate> delegate) : delegate_(delegate) {}
void FetchData() {
// ... fetch data from somewhere asynchronously
// and call back
auto delegate = delegate_.lock();
delegate->OnDataReady(nullptr);
}
private:
std::weak_ptr<Delegate> delegate_;
};
class DataManager : public DataFetcher::Delegate,
public std::enable_shared_from_this<DataManager> {
public:
DataManager() {}
void FetchData() {
if (!data_fetcher_) {
data_fetcher_ = std::make_shared<DataFetcher>(shared_from_this());
}
std::cout << "Will fetch data with data_fetcher_" << std::endl;
data_fetcher_->FetchData();
}
void OnDataReady(void* any_data) override {
std::cout << "Got Data!" << std::endl;
}
private:
std::shared_ptr<DataFetcher> data_fetcher_;
};
int main(int argc, char *argv[]) {
auto manager = std::make_shared<DataManager>();
manager->FetchData();
}
这里例子里， DataManager 通过 std::shared_ptr<DataFetcher> data_fetcher_ 强持有 DataFetcher，DataFetch 通过 std::weak_ptr<Delegate> delegate_ 弱持有 DataManager。如果这里是 使用 std::shared_ptr<Delegate> delegate_ 强持有 DataManager 的话，那么 DataManager 和 DataFetch 将会造成循环引用，都得不到释放，造成内存泄漏。
可以看到，在构造 DataFetch 的时候， 我们使用了 shared_from_this() 作为参数：
data_fetcher_ = std::make_shared<DataFetcher>(shared_from_this());
它是 std::enable_shared_from_this<T> 类的一个方法。因为我们继承了 std::enable_shared_from_thi<T>，因此就可以拿到这个方法，它返回的是一个当前指针的 std::shared_ptr<T>.
那么它是怎么实现的呢？ 查看文档， 有如下描述：
A common implementation for enable_shared_from_this is to hold a weak reference (such as std::weak_ptr) to this. The constructors of std::shared_ptr detect the presence of an unambiguous and accessible (ie. public inheritance is mandatory) (since C++17) enable_shared_from_this base and assign the newly created std::shared_ptr to the internally stored weak reference if not already owned by a live std::shared_ptr (since C++17).
意思就是说，内部会持有一个 weak_ptt<T> wp, shared_from_this() 内部检查是否实现了 enable_shared_from_this 基类，如果实现了，就会基于 wp 创建一个 shared_ptr 返回出来. 这样看起来挺巧妙。那么这个 weakptr 的指针是什么时候创建的呢？
enable_shared_from_this 源码实现
我们来扒一扒源码，先来看一下 enable_shared_from_this 模版类的实现，代码虽然不多，但是为了简单清晰，我把涉及不到的方法给移除掉了：
template<class _Tp>
class _LIBCPP_TEMPLATE_VIS enable_shared_from_this
{
// private 的 weak_ptr 指针：
mutable weak_ptr<_Tp> __weak_this_;
public:
_LIBCPP_INLINE_VISIBILITY
shared_ptr<_Tp> shared_from_this()
{return shared_ptr<_Tp>(__weak_this_);}
#if _LIBCPP_STD_VER > 14
_LIBCPP_INLINE_VISIBILITY
weak_ptr<_Tp> weak_from_this() _NOEXCEPT
{ return __weak_this_; }
#endif // _LIBCPP_STD_VER > 14
template <class _Up> friend class shared_ptr;
};有这么几点需要注意的：
- 内部持有了 private 的 weak_ptr 指针
__weak_this_:mutable weak_ptr<_Tp> __weak_this_\ shared_from_this()直接返回的是shared_ptr<_Tp>(__weak_this_)， 并不是__weak_this_.lock()， 原因是前者如果__weak_this_如果为空，将会抛出异常，后者会返回一个存储nullptr的std::shared_ptr对象。- C++ 14 之后，有
weak_from_this()方法直接返回__weak_this_ - 把
class shared_ptr设置为友元类，也就是说shared_ptr可以访问enable_shared_from_this的私有属性__weak_this_
但是看不到什么时候给 __weak_this_ 初始化的。
shared_ptr 的部分源码
我们再拿出来 shared_ptr 源码来看下, shared_ptr 的源码较多，这里同样去掉一些不影响理解的逻辑。
template<class _Tp>
class shared_ptr
{
public:
explicit shared_ptr(_Yp* __p) : __ptr_(__p) {
unique_ptr<_Yp> __hold(__p);
typedef typename __shared_ptr_default_allocator<_Yp>::type _AllocT;
typedef __shared_ptr_pointer<_Yp*, __shared_ptr_default_delete<_Tp, _Yp>, _AllocT > _CntrlBlk;
__cntrl_ = new _CntrlBlk(__p, __shared_ptr_default_delete<_Tp, _Yp>(), _AllocT());
__hold.release();
// 注意这里，在创建 shared_ptr 的时候，会调用 __enable_weak_this 这样一个方法：
__enable_weak_this(__p, __p);
}
private:
// __enable_weak_this 主实现：
template <class _Yp, class _OrigPtr>
typename enable_if<is_convertible<_OrigPtr*,
const enable_shared_from_this<_Yp>*
>::value,
void>::type
__enable_weak_this(const enable_shared_from_this<_Yp>* __e,
_OrigPtr* __ptr) _NOEXCEPT
{
typedef typename remove_cv<_Yp>::type _RawYp;
if (__e && __e->__weak_this_.expired())
{
__e->__weak_this_ = shared_ptr<_RawYp>(*this,
const_cast<_RawYp*>(static_cast<const _Yp*>(__ptr)));
}
}
// __enable_weak_this 的兜底实现：
void __enable_weak_this(...) _NOEXCEPT {}
};
我们可以注意到在 shared_ptr 的构造函数里，会调用 __enable_weak_this() 这样一个方法，有两个参数，把包装的裸指针 __p 传入进去
__enable_weak_this 函数主实现使用了模版源编程 Template meta programming，不熟悉的话，可能乍一看有点蒙，这个稍后再说，先看函数体：
__enable_weak_this(const enable_shared_from_this<_Yp>* __e,
_OrigPtr* __ptr) _NOEXCEPT
{
typedef typename remove_cv<_Yp>::type _RawYp;
// 检查 __e->__weak_this_ 是否为空，expired() 返回 true 表示内部对象为空
// 如果为空的话，则通过this 指针和 ptr 构造出来一个 shared_ptr, 并存入 __weak_this_ 中。
if (__e && __e->__weak_this_.expired())
{
__e->__weak_this_ = shared_ptr<_RawYp>(*this,
const_cast<_RawYp*>(static_cast<const _Yp*>(__ptr)));
}
}
到这里我们搞清楚了，enable_shared_from_this 里的 __weak_this_ 是谁创建的，以及在什么时机创建的：
Answer: 在创建 shared_ptr<T> 的时候(T 继承自 enable_shared_from_this<T>), 初始化了 enable_shared_from_this<T> 里的 __weak_this_ 指针。
Note: 如果仔细看的话，发现构造
shared_ptr的时候有点奇怪，第一个参数是shared_ptr<T>类型，第二个是__ptr也就是当前shared_ptr对象管理的裸指针。 shared_ptr<_RawYp>(*this, const_cast<_RawYp*>(static_cast<const _Yp*>(__ptr))) 这个调用的是std::shared_ptr的别名构造函数（The aliasing constructor），意思是说，共享 r 参数的引用计数， 但是.get()返回的是 ptr 指针。 template< class Y > shared_ptr( const shared_ptr<Y>& r, element_type* ptr ) noexcept; // (8)
现在就剩下一个疑惑了，shared_ptr 怎么知道一个类型有没有继承自 enable_shared_from_this 呢？
这个就需要我们回过头来看 __enable_weak_this 的返回值类型，也就是下面这一坨：
typename enable_if<
is_convertible<_OrigPtr*, const enable_shared_from_this<_Yp>*>::value,
void>::type对，这一坨最终会在编译期塌缩成一个类型，最终返回 void 或者空。当返回 void 时，__enable_weak_this 函数签名就是
void __enable_weak_this(const enable_shared_from_this<_Yp>* __e,
_OrigPtr* __ptr)当塌缩成空时，__enable_weak_this 函数签名就是
__enable_weak_this(const enable_shared_from_this<_Yp>* __e,
_OrigPtr* __ptr)显然这是一个不合法的签名，因此编译期发现整个不合法，就不生成这个函数了。
这个就是模板元编程的特点，编译器生成模版函数和我们手写函数的逻辑完全不同，我们手写的函数不合法，编译器就会报错，但是如果编译器生成出来的发现不合法，编译器就会不生成这个函数。
这个就是所谓的 SFINAE (Substitue Failure Is Not An Error) ，翻译过来就是：（模版）替换失败不是一个错误。
现在有两个问题：
- 什么条件下返回
void以及 空 呢？ - 如果不生成
__enable_weak_this函数， 那构造里调用的函数，是调的哪个呢？
对于第二个问题，比较简单，上面我们发现有个兜底的 __enable_weak_this 函数, 调用的就是这个了，内部实现是空的，也就是什么也不做。
// __enable_weak_this 的兜底实现：
void __enable_weak_this(...) _NOEXCEPT {}
对于第一个问题，就是 enable_if 起的作用：
enable_if<bool 值， 类型T>::type 的意思是说，如果bool值为true，enable_if 返回的就是第二个模版参数 类型T, 如果为false，返回空（不是void，而是什么也没有）
那么看下：
enable_if<is_convertible<_OrigPtr*, const enable_shared_from_this<_Yp>*>::value, void>::type意思就是说，如果 is_convertible<_OrigPtr*, const enable_shared_from_this<_Yp>*>::value 返回 true 的话，也就是说我们的裸指针可以转换为 enable_shared_from_this<_Yp>*>::value, 其实也就是说，我们的裸指针类型是继承自 enable_shared_from_this<_Yp> 的。
所以这句话的意思就是说，如果传入的裸指针类型是继承自 enable_shared_from_this 的，那么 返回 void 类型，否则返回空，让 __enable_weak_this 函数替换失败，导致内部无法创建 __weak_this_ 指针，也就没办法通过 shared_from_this() 函数拿到当前this指针对应的 shared_ptr.
以上。