智能指针

为啥想学boost呢，因为它名气大？其实主要还是因为工作中有不要地方用到了不少智能指针，bind等一些东西，想直接完全理解起来还有点难。
boost.smart_ptr库提供了六种智能指针，包括scoped_ptr,scoped_array,shared_ptr,shared_array,weak_ptr和instrusive_ptr,来增强std::auto_ptr,而且是异常安全的。它们都很轻量，速度和原始指针差不多，但是类型T有一个要求：类型T的析构函数不能抛出异常，析构函数最好不要抛出异常不是被很多大牛重申了N次了吗？
原因是:1.能够在异常转递的堆栈辗转开解（stack-unwinding）的过程中，防止terminate被调用。2.它能帮助确保析构函数总能完成我们希望它做的所有事情。

独占与共享：
holder类型独占一个对象

template<typename T>
class Holder{
private:
    T* ptr;
public:
    Holder():ptr(0){
    }
    explicit Holder(T* p):ptr(p){
    }
    ~Holder(){
        delete ptr;
    }
    //针对新指针的赋值运算符
    Holder<T>& operator=(T* p){
        delete ptr;
        ptr = p;
        return *this;
    }
    T& operator*()const{
        return *ptr;
    }
    T* operator->()const{
        return ptr;
    }
    T* get()const{
        return ptr;
    }
    void release(){
        ptr = 0;
    }
    void exchange_with(Holder<T>& h){
        swap(ptr,h.ptr);
    }
    void exchange_with(T*& p){
        swap(ptr,p);
    }
private:
    //不向外提供拷贝构造函数和拷贝赋值运算符
    Holder (Holder<T> const&);
    Holder<T>& operator=(Holder<T> const&);
};

trule可以使对象的拥有者从一个holder传递给另一个holder

#ifndef TRULE_H
#define TRULE_H

template<typename T>
class Holder;

template<typename T>
class Trule{
private:
    T* ptr;
public:
    Trule(Holder<T>& h){
        ptr = h.get();
        h.release();
    }

    Trule(Trule<T> const& t){
        ptr = t.ptr;
        const_cast<Trule<T>&>(t).ptr = 0;
    }
    ~Trule(){
        delete ptr;
    }
private:
    Trule(Trule<T>&);
    Trule<T>& operator=(Trule<T>&);
    friend class Holder<T>;
};

#endif // TRULE_H