C++中 share_from_this類的作用和實現原理

轉載地址：http://blog.csdn.net/acs713/article/details/29174191

boost庫中的share_from_this 已經在c11標準中實現。理論與boost相同，以下是按照boost的文檔來解釋該問題。

使用boost庫時，經常會看到如下的類

class A:public enable_share_from_this<A>

在什麼情況下要使類A繼承enable_share_from_this？

使用場合：當類A被share_ptr管理，且在類A的成員函數裏需要把當前類對象作爲參數傳給其他函數時，就需要傳遞一個指向自身的share_ptr。

我們就使類A繼承enable_share_from_this，然後通過其成員函數share_from_this()返回當指向自身的share_ptr。

以上有2個疑惑：

1.把當前類對象作爲參數傳給其他函數時，爲什麼要傳遞share_ptr呢？直接傳遞this指針不可以嗎？

一個裸指針傳遞給調用者，誰也不知道調用者會幹什麼？假如調用者delete了該對象，而share_tr此時還指向該對象。

2.這樣傳遞share_ptr可以嗎？share_ptr<this>

這樣會造成2個非共享的share_ptr指向一個對象，最後造成2次析構該對象。

boost官方文檔中一個非常典型的例子：http://www.boost.org/doc/libs/1_55_0/doc/html/boost_asio/tutorial/tutdaytime3/src.html

部分代碼：

 1 class tcp_connection
 2   : public boost::enable_shared_from_this<tcp_connection>
 3 {
 4 public:
 5   typedef boost::shared_ptr<tcp_connection> pointer;
 6 
 7   static pointer create(boost::asio::io_service& io_service)
 8   {
 9     return pointer(new tcp_connection(io_service));
10   }
11 
12   tcp::socket& socket()
13   {
14     return socket_;
15   }
16 
17   void start()
18   {
19     message_ = make_daytime_string();
20 
21     boost::asio::async_write(socket_, boost::asio::buffer(message_),
22         boost::bind(&tcp_connection::handle_write, shared_from_this(),
23           boost::asio::placeholders::error,
24           boost::asio::placeholders::bytes_transferred));
25   }
26 
27 private:
28   tcp_connection(boost::asio::io_service& io_service)
29     : socket_(io_service)
30   {
31   }
32 
33   void handle_write(const boost::system::error_code& /*error*/,
34       size_t /*bytes_transferred*/)
35   {
36   }
37 
38   tcp::socket socket_;
39   std::string message_;
40 };

類tcp_connection繼承enable_share_from_this，在22行裏，它的成員函數start()，通過share_from_this返回指向自身的share_ptr。

實現原理：

share_from_this()是如何返回指向該對象的share_ptr的？顯然它不能直接return share_ptr<this>。因爲它返回的share_ptr必須和管理該對象的share_ptr是共享的，也就是說返回的share_ptr的引用計數和管理該對象的share_ptr的引用計數是相同的。其實enable_share_from_this就存儲了管理該對象的share_ptr的引用計數，通過weak_ptr來實現。在enable_share_from_this，裏有一個成員weak_this_。

但現在的問題是：何時初始化這個 weak_ptr ？因爲類對象生成時還沒有生成相應的用來管理這個對象的 shared_ptr 。其實是通過share_ptr的構造函數中初始化這個weak_ptr的.

shared_ptr 定義瞭如下構造函數：

1  template<class Y>
2 explicit shared_ptr( Y * p ): px( p ), pn() // Y must be complete
3 {
4   boost::detail::sp_pointer_construct( this, p, pn );
5 }

裏面調用了  boost::detail::sp_pointer_construct 

1 template< class T, class Y > inline void sp_pointer_construct( boost::shared_ptr< T > * ppx, Y * p, boost::detail::shared_count & pn )
2 {
3    boost::detail::shared_count( p ).swap( pn );
4    boost::detail::sp_enable_shared_from_this( ppx, p, p );
5 }

 裏面又調用了boost::detail::sp_enable_shared_from_this

 

share_ptr有2個該重載函數

1 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 )
2 {
3   if( pe != 0 )
4  {
5    pe->_internal_accept_owner( ppx, const_cast< Y* >( py ) );
6  }
7 }

1 inline void sp_enable_shared_from_this( ... )
2 {
3 }

由於我們的類是繼承enable_share_from_this，所以調用的是前者

裏面又調用了 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() )
  {
    weak_this_ = shared_ptr<T>( *ppx, py );
  }
}

最後，在這裏對enable_shared_from_this 的成員 weak_this_ 進行拷貝賦值，使得整個 weak_ptr 作爲類對象shared_ptr 的一個觀察者。當調用share_from_this()時，就可以從這個 weak_ptr 來生成了，且引用計數是相同的。

1 shared_ptr<T const> shared_from_this() const
2 {
3  shared_ptr<T const> p( weak_this_ );
4  BOOST_ASSERT( p.get() == this );
5  return p;
6 }