stl智能指针auto_ptr

封装了指针类用起来跟指针本身一样才好.所以需要重载-> , * 等运算符

template< class T>

class my_auto_ptr

 {

private:

    T* m_ptr; //被封装的指针

public:

    my_auto_ptr( T* p) :m_ptr( p ) { }

    ~my_auto_ptr() { delete m_ptr; }

    T& operator*() { return *m_ptr;}

    T*  operator->() { return m_ptr;}

}

现在my_auto_ptr可以变得很像指针了

my_auto_ptr<int> mp(new int(88) );   //等价int* ip = new int(88);

int num = *mp;   //等价int num = *ip;

假如有这样的类struct Arwen { void Test() { cout<"i am arwen"<<; }

则my_auto_ptr<Arwen> mp( new Arwen);   //等价Arwen* ip = new Arwen;

  mp->Test();  //等价ip-Test();

3.完善版本(复制构造)

一个完善点的类往往还涉及到复制构造的一些操作.也可以做把另外一个智能指针类做为构造函数的参数,或者通过=给一个类赋值

template< class T>

class my_auto_ptr 

{

private:

    T* m_ptr;

    T* GetPtr(){ //供构造赋值时使用

    T* tmp = m_ptr;

    m_ptr = 0;

    return tmp;

}

public:

    explicit my_auto_ptr( T* p = 0) :m_ptr( p ) { }

    ~my_auto_ptr() { delete m_ptr; }

    T& operator*() { return *m_ptr;}

    T* operator->() { return m_ptr;}

    my_auto_ptr(my_auto_ptr& mp)

    {   //复制构造函数

        m_ptr = mp.GetPtr(); //mp复制过来后它自己原来的指针相当于失效了.

    }

    my_auto_ptr& operator=(my_auto_ptr& ap)

    {//赋值操作符

        if(ap != *this)

        {

            delete m_ptr;

            m_ptr = ap.GetPtr();

        }

        return *this;

    }

    void reset(T* p)

    {  //指针重置,相当于把指针指向另外一个地方去

        if(p != m_ptr)

        delete m_ptr;

        m_ptr = p;

    }

};