#include <vector>  
#include <iostream>  
#include <boost/scoped_ptr.hpp>  
#include <boost/shared_ptr.hpp>  
#include <boost/weak_ptr.hpp>  
#include <boost/enable_shared_from_this.hpp>  
  
class Base  
{  
public:  
    explicit Base(int a)  
    : m_a(a)  
    {  
    }  
    virtual ~Base()  
    {  
    }  
  
    int GetA() const  
    {  
        return m_a;   
    }  
  
private:  
    int m_a;  
};  
  
class Derive : public Base  
{  
public:  
    explicit Derive(int b)  
        : Base(2 * b)  
        , m_b(b)  
    {  
  
    }  
  
    virtual ~Derive()  
    {  
    }  
  
    int GetB() const  
    {  
        return m_b;   
    }  
  
private:  
    int m_b;  
};  
  
class EnableShared  
{  
public:  
    EnableShared()  
    : m_e(3)  
    {  
  
    }  
    ~EnableShared()   
    {  
        std::cout<< "EnableShared Destruction execute" << std::endl;  
    }  
  
    void ShowE()  
    {  
        boost::shared_ptr<EnableShared> p1(this);  
        std::cout<< p1->m_e << std::endl;  
    }  
  
private:  
    int m_e;  
};  
  
class EnableSharedEx : public boost::enable_shared_from_this<EnableSharedEx>  
{  
public:  
    EnableSharedEx()  
        : m_e(3)  
    {  
  
    }  
    ~EnableSharedEx()   
    {  
        std::cout<< "EnableSharedEx Destruction execute" << std::endl;  
    }  
  
    void ShowE()  
    {  
        //boost::shared_ptr<EnableSharedEx> p1(this);  
        boost::shared_ptr<EnableSharedEx> p1 = shared_from_this();  
        std::cout<< p1->m_e << std::endl;  
    }  
  
private:  
    int m_e;  
};  
  
static void testSharedPtr();  
static void testEnableSharedFromthis();  
static void testScopedPtr();  
static void testAutoPtr();  
  
void testSmartPointer()  
{  
    // ------------- shared_ptr -------------  
    testSharedPtr();  
  
    // ------------- enable_shared_from_this -------------  
    testEnableSharedFromthis();  
  
    // ------------- scoped_ptr -------------  
    testScopedPtr();  
  
    // ------------- auto_ptr -------------  
    testAutoPtr();  
  
    // ------------- summary -------------  
    // 1 auto_ptr会转移所有权，使原拥有者失效  
    // 2 shared_ptr比起auto_ptr，不会转移所有权，而是增加引用计数  
    // 3 scoped_ptr不允许复制  
    // 4 weak_ptr起了类似于观察者的作用，不会对拥有者造成影响  
}  
  
void testSharedPtr()  
{  
    // 1 使用  
    boost::shared_ptr<Base> pa(new Base(2));  
    std::cout<< "testSharedPtr" << pa->GetA() << std::endl;  
  
    // 2 发生引用，此时pa2和pa指向同一个指针，观察计数器share_ptr::use_count_ 值从1变为2。  
    boost::shared_ptr<Base> pa2 = pa;  
  
    // 3 弱引用，计数器并仍然是2，不过weak_count_ 从1变成了2。  
    boost::weak_ptr<Base> p3 = pa;  
}  
  
void testEnableSharedFromthis()  
{  
    // 1 应用举例  
    boost::shared_ptr<EnableShared> pe(new EnableShared);  
    //pe->ShowE();  
  
    // 2 注释说明  
    // 编译可以通过，但是析构函数会执行两次，造成程序崩溃  
    // shared_ptr的一个缺点，无法从this指针构造，无法像testSharedPtr中的引用例子一样。  
  
    // 3 解决办法 enable_shared_from_this，改写EnableShared为EnableSharedEx  
    boost::shared_ptr<EnableSharedEx> pex(new EnableSharedEx);  
    pex->ShowE();  
}  
  
void testScopedPtr()  
{  
    // 1 应用举例、  
    boost::scoped_ptr<Base> pb(new Base(2));  
    std::cout << "testScopedPtr" << pb->GetA() << std::endl;  
  
    // 2 引用，无法通过编译，原因：scope_ptr不允许复制  
    // boost::scoped_ptr<Base> pb2 = pb;  
}  
  
void testAutoPtr()  
{  
    // 1 应用举例，与shared_ptr相似  
    std::auto_ptr<Base> pa(new Base(2));  
    std::cout<< "testAutoPtr: " << pa->GetA() << std::endl;  
  
    // 2 发生引用，与shared_ptr不同的地方在于pa编程空指针了。  
    std::auto_ptr<Base> pax = pa;  
}