为什么需要boost::enable_shared_from_this？
1. class
2.
3. shared_ptr<cat> p(new
4. shared_ptr<cat> p2(p);
5.
6.
7.
8. class cat:public
9.
10. shared_ptr<cat> p(new
11. shared_ptr<cat> p2=p->shared_from_this();
这两段代码看似没什么区别。但是如果你在程序里，比如在cat中的成员方法中，有的只是cat的raw pointer，但你依然想利用shared_ptr的自动delete特性，又不想自己防止由于存在多个shared_ptr<cat>对同一个cat对象delete多次的危险。即多个shared_ptr<cat>共用同一个计数器。这时候，boost::enable_shared_frome_this就变得很方便了。
1. struct
2.
3. void f(shared_ptr<A> const&) {...}
4.
5. struct A: public
6. {
7. void
8. {
9. // you need to call f() here passing itself as a parameter
10. f(shared_from_this());
11. }
12. };
13.
14. shared_ptr<A> a_ptr(new
15. a_ptr->a_f(); // in inner call to f() will be used temporary shared_ptr<A>
16. // that uses (shares) the same reference counter as a_ptr
boost::enable_shared_from_this原理
其实继承了boost::enable_shared_from_this的类，真正的magic是发生在创建它的第一个shared_ptr实例时。shared_ptr会反调boost::enable_shared_from_this的_internal_accept_owner方法。
1. template<class T> class
2. {
3. protected:
4.
5. enable_shared_from_this()
6. {
7. }
8.
9. const
10. {
11. }
12.
13. const
14. {
15. return *this;
16. }
17.
18. ~enable_shared_from_this()
19. {
20. }
21.
22. public:
23.
24. shared_ptr<T> shared_from_this()
25. {
26. shared_ptr<T> p( weak_this_ );
27. this
28. return
29. }
30.
31. const> shared_from_this() const
32. {
33. const> p( weak_this_ );
34. this
35. return
36. }
37.
38. public: // actually private, but avoids compiler template friendship issues
39.
40. // Note: invoked automatically by shared_ptr; do not call
41. template<class X, class Y> void _internal_accept_owner( shared_ptr<X> const * ppx, Y * py ) const
42. {
43. if( weak_this_.expired() )
44. {
45. weak_this_ = shared_ptr<T>( *ppx, py );
46. }
47. }
48.
49. private:
50.
51. mutable
52. };
53.
54. //从源码中，可以看出，重点不在于初始化的时候。而是在于创建第一个该对象的shared_ptr的时候：
55.
56. template<class
57. explicit shared_ptr( Y * p ): px( p ), pn( p ) // Y must be complete
58. {
59. this, p, p );
60. }
61.
62. 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
63. {
64. if( pe != 0 )
65. {
66. const_cast< Y* >( py ) );
67. }
68. }
weak_ptr是为配合shared_ptr而引入的一种智能指针来协助shared_ptr工作，它可以从一个shared_ptr或另一个weak_ptr对象构造，它的构造和析构不会引起引用记数的增加或减少。没有重载*和->但可以使用lock获得一个可用的shared_ptr对象
weak_ptr的一个重要用途是通过lock获得this指针的shared_ptr,使对象自己能够生产shared_ptr来管理自己，但助手类enable_shared_from_this的shared_from_this会返回this的shared_ptr，只需要让想被shared_ptr管理的类从它继承即可
noncopyable允许程序轻松地实现一个禁止复制的类，位于名字空间boost，为了使用 noncopyable组件，需要包含头文件<boost/noncopyable.hpp>或者<boost/utility.hpp>，后者包含了数个小工具的实现：
从原理来上说就是将拷贝构造函数和拷贝赋值操作符声明为private，未免重复写这种乏味代码，可以直接继承自noncopyable
如下：
此处)折叠或打开
1. #include <boost/utility.hpp>
2.
3. class do_not_copy: boost::noncopyable
4. {
5. };
6.
7. int main()
8. {
9. ;
10. (d1);
11. = d1;
12. ;
13. }
g++ 编译报错：
boost::noncopyable_::noncopyable::noncopyable(const boost::noncopyable_::noncopyable&)’ is private
补充：
如果成员函数中用到shared_from_this()，则须通过shared_ptr<>创建该类实例，要么该类就别派生enable_shared_from_this，成员函数中直接使用this。
