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

如下程式碼是錯誤的：

1. class D:public boost::enable_shared_from_this<D>
2. {
3. public:
4.     D()
5.     {
6.         boost::shared_ptr<D> p=shared_from_this();
7.     }
8. };

複製程式碼原 因很簡單，在D的建構函式中雖然可以保證enable_shared_from_this<D>的建構函式已經被呼叫，但正如前面所 說，weak_ptr還沒有設定。 

如下程式碼也是錯誤的：

1. class D:public boost::enable_shared_from_this<D>
2. {
3. public:
4.     void func()
5.     {
6.         boost::shared_ptr<D> p=shared_from_this();
7.     }
8. };
9. void main()
10. {
11.     D d;
12.     d.func();
13. }

複製程式碼錯 誤原因同上。 

如下程式碼是正確的：

1. void main()
2. {
3.     boost::shared_ptr<D> d(new D);
4.     d->func();
5. }

複製程式碼這 裡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>。例如如下程式碼是錯誤的：

1. class A:public boost::enable_shared_from_this<A>
2. {
3. public:
4.     A():a(1){}
5.     virtual ~A(){}
6.     boost::shared_ptr<A> get_ptra(){return shared_from_this();}
7.     int a;
8. };
9. class B:public A,public boost::enable_shared_from_this<B>
10. {
11. public:
12.     B():b(2){}
13.     boost::shared_ptr<B> get_ptrb()
14.     {
15.         return boost::enable_shared_from_this<B>::shared_from_this();
16.     }
17.     int b;
18. };
19. int _tmain(int argc, _TCHAR* argv[])
20. {
21.     {
22.         boost::shared_ptr<B> x(new B);
23.         boost::shared_ptr<A> a1 = x->get_ptra();
24.         boost::shared_ptr<B> b1 = x->get_ptrb();
25.     }
26.     return 0;
27. }

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

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

則僅設定enable_shared_from_this<B>的weak_ptr。很明顯都是錯誤的。 

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

首先考察shared_ptr的建構函式：

1. template<class Y>
2. explicit shared_ptr( Y * p ): px( p ), pn( p ) // Y must be complete
3. {
4.     boost::detail::sp_enable_shared_from_this( pn, p, p );
5. }
6. 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 )
7. {
8.     if(pe != 0) pe->_internal_weak_this._internal_assign(const_cast<Y*>(px), pn);
9. }

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

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

1. class B:public A
2. {
3. public:
4.     B():b(2){}
5.     boost::shared_ptr<B> get_ptrb()
6.     {
7.         return boost::dynamic_pointer_cast<B>(shared_from_this());
8.     }
9.     int b;
10. };

複製程式碼注 意到這裡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<B>( FooA() ) and remove the enable_shared_from_this<B>
base (A needs to be made polymorphic, of course). 

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