shared_from_this 幾個值得注意的地方

shared_from_this()是enable_shared_from_this<T>的成員函數，返回shared_ptr<T>。首先需要注意的是，這個函數僅在shared_ptr<T>的構造函數被調用之後才能使用。原因是enable_shared_from_this::weak_ptr並不在構造函數中設置，而是在shared_ptr<T>的構造函數中設置。

如下代碼是錯誤的：

class D:public boost::enable_shared_from_this<D>
{
public:
D()
{
boost::shared_ptr<D> p=shared_from_this();
}
};

複製代碼

原因很簡單，在D的構造函數中雖然可以保證enable_shared_from_this<D>的構造函數已經被調用，但正如前面所說，weak_ptr還沒有設置。

如下代碼也是錯誤的：

class D:public boost::enable_shared_from_this<D>
{
public:
void func()
{
boost::shared_ptr<D> p=shared_from_this();
}
};
void main()
{
D d;
d.func();
}

複製代碼

錯誤原因同上。

如下代碼是正確的：

void main()
{
boost::shared_ptr<D> d(new D);
d->func();
}

複製代碼

這裏boost::shared_ptr<D> d(new D)實際上執行了3個動作：首先調用enable_shared_from_this<D>的構造函數；其次調用D的構造函數；最後調用 shared_ptr<D>的構造函數。是第3個動作設置了enable_shared_from_this<D>的 weak_ptr，而不是第1個動作。這個地方是很違背c++常理和邏輯的，必須小心。

結論是，不要在構造函數中使用shared_from_this；其次，如果要使用shared_ptr，則應該在所有地方均使用，不能使用D d這種方式，也決不要傳遞裸指針。

另一個值得注意的地方是在類的繼承樹中不能有2個或更多個enable_shared_from_this<T>。例如如下代碼是錯誤的：

class A:public boost::enable_shared_from_this<A>
{
public:
A():a(1){}
virtual ~A(){}
boost::shared_ptr<A> get_ptra(){return shared_from_this();}
int a;
};
class B:public A,public boost::enable_shared_from_this
{
public:
B():b(2){}
boost::shared_ptr get_ptrb()
{
return boost::enable_shared_from_this::shared_from_this();
}
int b;
};
int _tmain(int argc, _TCHAR* argv[])
{
{
boost::shared_ptr x(new B);
boost::shared_ptr<A> a1 = x->get_ptra();
boost::shared_ptr b1 = x->get_ptrb();
}
return 0;
}

複製代碼

注意上面代碼中，B同時擁有2個enable_shared_from_this的基類，一個是 enable_shared_from_this<A>，另一個是enable_shared_from_this。在 boost::shared_ptr x(new B);這行代碼中，shared_ptr的構造函數僅會設置2個基類中的一個的weak_ptr。在上面的例子中，僅設置 enable_shared_from_this<A>的。如果修改B的定義爲：

class B:public boost::enable_shared_from_this,public A，

則僅設置enable_shared_from_this的weak_ptr。很明顯都是錯誤的。

那麼enable_shared_from_this以及shared_ptr爲何要如此實現呢？又爲什麼會有如此怪異的結果呢？

首先考察shared_ptr的構造函數：

template<class Y>
explicit shared_ptr( Y * p ): px( p ), pn( p ) // Y must be complete
{
boost::detail::sp_enable_shared_from_this( pn, p, p );
}
template<class T, class Y> void sp_enable_shared_from_this( shared_count const & pn, boost::enable_shared_from_this<T> const * pe, Y const * px )
{
if(pe != 0) pe->_internal_weak_this._internal_assign(const_cast<Y*>(px), pn);
}

複製代碼

注意這個sp_enable_shared_from_this是一個模板函數，而且僅調用了一次，所以不可能2個 enable_shared_from_this基類的weak_ptr都被賦值。但問題在於，在調換了B的定義之後結果居然是不一樣的。這裏有一個很隱祕的編譯器BUG。按道理來說，編譯器在編譯這段代碼時，應該注意到無法真正決斷該怎麼實例化sp_enable_shared_from_this並且報一個錯，但vc 2008並沒有報錯，而是通過編譯了。（g++會在此處報錯）

那麼正確的解法是怎樣的呢？

class B:public A
{
public:
B():b(2){}
boost::shared_ptr get_ptrb()
{
return boost::dynamic_pointer_cast(shared_from_this());
}
int b;
};

複製代碼

注意到這裏B並沒有直接繼承enable_shared_from_this，而是使用dynamic_pointer_cast進行了類型轉換。

關於爲什麼enable_shared_from_this是這樣實現的，可以參看作者原文：

Every enable_shared_from_this base contains a weak_ptr, The shared_ptr constructor looks up the enable_shared_from_this base and initializes its weak_ptr accordingly. This doesn't work when there are
two or more enable_shared_from_this bases, though.

I could put the weak_ptr in a virtual polymorphic base. This would force polymorphism on all clients of enable_shared_from_this... probably acceptable. It will also force a dynamic_pointer_cast in every
shared_from_this, and this may be harder to swallow, particularly in cases where RTTI is off. So I'm not sure.

If you do want the above behavior, it's easy to duplicate, as I already responded in my first post on the topic. Just make FooB return dynamic_pointer_cast( FooA() ) and remove the enable_shared_from_this
base (A needs to be made polymorphic, of course).

注意爲了讓dynamic_pointer_cast能工作，A必須具有虛函數，那麼最簡單的做法當然是令其析構函數爲虛函數（通常一個class如果希望被繼承，析構函數就應該爲虛函數）。