智能指针(STL)

智能指针（类模板（初））
智能指针并不是一个指针， 它是一个类模板，只是通过封装，使之产生一些与普通指针相似的行为
它的作用： 自动释放所指向的对象
它的拷贝构造，是把旧指针的指针指空， 新指针指向原来的内存空间
它的拷贝赋值的实现，并不是指针的复制，也不是对象的复制，它需要先析构左边的对象， 再把右边的对象转移到左边

template<typename T>
class AutoPtr{
public:
    AutoPtr(T* p=NULL):m_p(p){}
    //拷贝构造
    //要把旧的对象指针指空，新的对象指针指向实例
    AutoPtr(AutoPtr& that):m_p(that.release()){}
    //拷贝赋值
    //被赋值的对象要先析构，再把他的指针指向右操作数
    //不能自赋值
    AutoPtr& operator=(AutoPtr& that){
        if(&that != this)
            reset(that.release());
        return *this;
    }
    T* operator->(void){
        return m_p;
    }
    T& operator*(void){
        return *m_p;
    }
    ~AutoPtr(void){
        delete m_p;
        m_p = NULL;
    }

private:
    T* release(void){
        T* cmp = m_p;
        m_p = NULL;
        return cmp;
    }
    void reset(T* p){
        if(m_p != p){
            delete m_p;
            m_p = p;
        }
    }
    T* m_p;
}；

数组类型的特例化板本

template<typename T>
class AutoPtr<T[]>{
public:
    AutoPtr(T* p=NULL):m_p(p){}
    AutoPtr(AutoPtr& that):m_p(that.release()){}
    AutoPtr& operator=(AutoPtr& that){
        if(&that != this)
            reset(that.release());
        return *this;
    }
    T* operator->(void){
        return m_p;
    }
    T& operator*(void){
        return *m_p;
    }
    ~AutoPtr(void){
        delete [] ]m_p;
        m_p = NULL;
    }

private:
    T* release(void){
        T* cmp = m_p;
        m_p = NULL;
        return cmp;
    }
    void reset(T* p){
        if(m_p != p){
            delete [] m_p;
            m_p = p;
        }
    }
    T* m_p;
}；