首页 > 代码库 > 如何用enable_shared_from_this 来得到指向自身的shared_ptr 及对enable_shared_from_this 的理解
如何用enable_shared_from_this 来得到指向自身的shared_ptr 及对enable_shared_from_this 的理解
在看《Linux多线程服务端编程：使用muduo C++网络库》 的时候，在说到如何防止在将对象的 this 指针作为返回值返回给了调用者时可能会造成的 core dump。需使用 enable_share_from_this。
首先要说明的一个问题是如何安全地将 this 指针返回给调用者。一般来说，我们不能直接将 this 指针返回。想象这样的情况，该函数将 this 指针返回到外部某个变量保存，然后这个对象自身已经析构了，但外部变量并不知道，那么此时如果外部变量使用这个指针，就会使得程序崩溃。
那么使用智能指针 shared_ptr 呢？当然，使得 c++ 指针安全目前来说最有效也使用最多的办法就是使用智能指针 shared_ptr。但问题是这里要怎么去使用它。首先假设你已经理解shared_ptr 的工作原理。然后我们来看下面一份代码：
#include <iostream>#include <memory>class Bad {public: Bad() { std::cout << "Bad()" << std::endl; } ~Bad() { std::cout << "~Bad()" << std::endl; } std::shared_ptr<Bad> getPtr() { return std::shared_ptr<Bad>(this); }};int main(int argc, char const *argv[]){ std::shared_ptr<Bad> bp1(new Bad); std::shared_ptr<Bad> bp2 = bp1->getPtr(); std::cout << "bp2.use_count: " << bp2.use_count() << std::endl; return 0;}
程序执行结果为：
Bad()bp2.use_count: 1~Bad()~Bad()a(822,0x7fff737b5300) malloc: *** error for object 0x7fe74bc04b50: pointer being freed was not allocated
我们可以看到，对象只构造了一次，但却析构了两次。并且在增加一个指向的时候 shared_ptr的计数并没有增加。也就是说，这个时候 bp1 和 bp2 都认为只有自己才是这个智能指针的拥有者。其实也就是说，这里建了两个智能指针同时处理 this 指针。每个智能指针在计数为0的时候都会调用一次Bad对象的析构函数。所以会出问题。
其实现在问题就变成了，如何在对象中获得一个指向当前对象的 shared_ptr 对象。如果我们能够做到这个，那么直接将这个shared_ptr 对象返回，就不会造成新建 shared_ptr 的问题了。
下面来看看 enable_shared_from_this；
enable_shared_from_this 是一个以其派生类为模板类型实参的基类模板，继承它，派生类的this指针就能变成一个 shared_ptr。先来看下面一份代码：
#include <iostream>#include <memory>class Good: public std::enable_shared_from_this<Good>{public: Good() { std::cout << "Good()" << std::endl; } ~Good() { std::cout << "~Good()" << std::endl; } std::shared_ptr<Good> getPtr() { return shared_from_this(); }};int main(int argc, char const *argv[]){ std::shared_ptr<Good> bp1(new Good); std::shared_ptr<Good> bp2 = bp1->getPtr(); std::cout << "bp2.use_count: " << bp2.use_count() << std::endl; return 0;}
执行结果：
Good()bp2.use_count: 2~Good()
解决问题了。
那么下面就来看看 enable_shared_from_this 到底是怎么工作的：这是它的实现源码：
template<class T> class enable_shared_from_this{protected: enable_shared_from_this() BOOST_NOEXCEPT { } enable_shared_from_this(enable_shared_from_this const &) BOOST_NOEXCEPT { } enable_shared_from_this & operator=(enable_shared_from_this const &) BOOST_NOEXCEPT { return *this; } ~enable_shared_from_this() BOOST_NOEXCEPT // ~weak_ptr<T> newer throws, so this call also must not throw { }public: shared_ptr<T> shared_from_this() { shared_ptr<T> p( weak_this_ ); BOOST_ASSERT( p.get() == this ); return p; } shared_ptr<T const> shared_from_this() const { shared_ptr<T const> p( weak_this_ ); BOOST_ASSERT( p.get() == this ); return p; }public: // actually private, but avoids compiler template friendship issues // Note: invoked automatically by shared_ptr; do not call template<class X, class Y> void _internal_accept_owner( shared_ptr<X> const * ppx, Y * py ) const { if( weak_this_.expired() ) { weak_this_ = shared_ptr<T>( *ppx, py ); } }private: mutable weak_ptr<T> weak_this_;};
我们重点看 shared_from_this 的实现。因为我们就是用它来返回一个指向 this 的智能指针对象的。我们可以看到，这个函数使用一个 weak_ptr 对象来构造一个 shared_ptr 对象，然后将其返回。注意这个 weak_ptr 是实例对象的一个成员，所以对于一个对象来说它一直是同一个，每次在调用 shared_from_this 的时候，就会根据 weak_ptr 来构造一个临时shared_ptr对象。
也许看到这里会产生疑问，这里的 shared_ptr 也是一个临时对象，和前面有什么区别？还有，为什么enable_shared_from_this 不直接保存一个 shared_ptr 成员？
首先对于第一个问题，这里的每一个shared_ptr都是根据 weak_ptr 来构造的，而每次构造shared_ptr的时候使用的参数是一样的。所以这里根据相同的weak_ptr来构造多个临时 shared_ptr 等价于用一个shared_ptr进行拷贝。
我们首先要理解，类对象肯定是外部函数通过某种机制分配的，并且如果要使用 shared_ptr 来进行管理的话，那么必须在分配完成后立即交给 shared_ptr。然后在其他地方需要用到这个对象的话也应该使用这个 shared_ptr 作为参数进行拷贝构造或赋值。而我们使用一个 weak_ptr 来进行构造 shared_ptr，作用是一样的（如果理解weak_ptr的工作原理，这个就不难理解了， weak_ptr本身就是为了协同 shared_ptr 的工作而生的）。
那么enable_shared_from_this为什么不直接保存一个 shared_ptr 成员呢？假设我再类里面储存了一个指向自身的 shared_ptr，那么这个shared_ptr的计数最少都会是1，也就是说，这个对象永远不能析构，所以这样做是错误的。而 weak_ptr 不会引起 shared_ptr 计数的增加。
enable_shared_from_this 的成员变量在enable_shared_from_this构造的时候是没有指向任何对象的，在第一次调用 shared_ptr 的时候，由 shared_ptr 调用 boost::detail::sp_enable_shared_from_this 然后调用enable_shared_from_this 的 _internal_accept_owner来对其进行初始化。看下面的过程就明白了。
shared_ptr的构造：
template<class Y> explicit shared_ptr( Y * p ): px( p ), pn( p ) { boost::detail::sp_enable_shared_from_this( this, p, p ); }
这里使用了 boost::detail::sp_enable_shared_from_this
template< class X, class Y, class T > inline void sp_enable_shared_from_this( boost::shared_ptr<X> const * ppx, Y const * py, boost::enable_shared_from_this< T > const * pe ){ if( pe != 0 ) { pe->_internal_accept_owner( ppx, const_cast< Y* >( py ) ); }}
而在这里面又调用 enable_shared_from_this 的 _internal_accept_owner
template<class X, class Y> void _internal_accept_owner( shared_ptr<X> const * ppx, Y * py ) const { if( weak_this_.expired() ) // 成员函数expired()的功能等价于use_count()==0 { weak_this_ = shared_ptr<T>( *ppx, py ); } }
从这个构造过程可以看出，当 weak_ptr 第一次指向一个对象后，它就担起了观察者的角色，一直观察着同一个对象。
从上面的介绍也可以看出，我们不能对一个普通对象去获取shared_ptr，比如：
Good g;std::shared_ptr<Good> gp = g.shared_from_this();这样会产生错误，因为 g 并不在堆而在栈区，然后shared_ptr试图去删除一个栈区上构造的对象，就会产生未定义行为。
如何用enable_shared_from_this 来得到指向自身的shared_ptr 及对enable_shared_from_this 的理解