智能指针的简单实现

share_ptr
运用对每一个对象进行计数，从而防止资源泄露
auto_ptr:
template<class T>
class AutoPtr
{
public:
    AutoPtr(T* ptr)
        :_ptr(ptr)
    {}
    ~AutoPtr()
    {

        if (_ptr)
        {
            cout << "delete" << _ptr << endl;
            delete _ptr;
            _ptr = NULL;
        }
    }
    AutoPtr(AutoPtr<T>& ap)
        :_ptr(ap._ptr)
    {
        ap._ptr = NULL;
    }
    AutoPtr& operator=(AutoPtr<T>& ap)
    {
        if (this != &ap)
        {
            delete _ptr;
            _ptr = ap._ptr;
            ap._ptr = NULL;
        }
        return *this;
    }
public:
    T& operator*()
    {
        return *_ptr;
    }
    T* operator->()
    {
        return _ptr;
    }
    T* GetPtr()
    {
        return _ptr;
    }
protected:
    T* _ptr;
};

share_prt:
template<class T>
class SharedPtr
{
public:
    SharedPtr(T* ptr)
            :_ptr(ptr)
            , _pCount(new long(1))
    {}
    ~SharedPtr()
    {
        _Release();
    }
    SharedPtr(const SharedPtr<T> sp)
        :_ptr(sp._ptr)
        , _pCount(sp._pCount)
    {
        ++*_pCount;
    }
    //传统写法
    //SharedPtr& operator=(const SharedPtr<T>& sp)
    //{
    //  if (_ptr != sp._ptr)
    //  {
    //      _Release();
    //      _ptr = sp._ptr;
    //      _pCount = sp._pCount;
    //      ++*_pCount;
    //  }
    //  return *this;
    //}
    //现代写法
    SharedPtr& operator=(SharedPtr<T> sp)
    {
        swap(_ptr, sp._ptr);
        swap(_pCount, sp._pCount);
        return *this;
    }
public:
    T& operator*()
    {
        return *_ptr;
    }
    T* operator->()
    {
        return _ptr;
    }
    T* GetPtr()
    {
        return _ptr;
    }
    long GetCount()
    {
        return *_pCount;
    }
protected:
    void _Release()
    {
        if (--*_pCount == 0)
        {
            delete _ptr;
            delete _pCount;
        }
    }

protected:
    T* _ptr;
    long* _pCount;
};
share_array:
template<class T>
class SharedArray
{
public:
    SharedArray(T* ptr)
        :_ptr(ptr)
        , _pCount(new long(1))
    {}
    ~SharedArray()
    {
        _Release();
    }
public:
    T& operator[](size_t index)
    {
        return _ptr[index];
    }
protected:
    void _Release()
    {
        if (--*_pCount == 0)
        {
            delete[] _ptr;
            delete _pCount;
        }
    }

protected:
    T* _ptr;
    long* _pCount;
};
//#pragma once
//#include<iostream>
//#include<string>
//template<class T>
//class ScopedPtr
//{
//public:
//  ScopedPtr(T* ptr)
//      :_ptr(ptr)
//  {
//
//  }
//  ~ScopedPtr()
//  {
//      delete _ptr;
//  }
//  void Display()
//  {
//      cout << (*_ptr) << endl;
//  }
//  T& operator*()
//  {
//      //assert(_ptr);
//      return *_ptr;
//  }
//
//  T* operator->()
//  {
//      return _ptr;
//  }
//
//  T* GetPtr()
//  {
//      return _ptr;
//  }
//protected:
//  T* _ptr;
//private:
// 
//  ScopedPtr(const ScopedPtr<T>& s);
//  ScopedPtr& operator=(const ScopedPtr<T> s);
//}；
scorp_ptr:
template < typename T >
class ScopedPtr   
{
public:
    ScopedPtr(T * ptr)
        :_ptr(ptr)
    {}

    ~ScopedPtr()
    {
        if (NULL != this)
        {
            delete _ptr;
            _ptr = NULL;
        }
    }
protected:
    ScopedPtr< T >(ScopedPtr < T>& ap);
    ScopedPtr <T > opreator = (ScopedPtr & ap);  
private:
    T * _ptr;
};

#include<iostream>  
using namespace std;
int main()
{
    int* p = new int(1);
    ScopedPtr<int> sp(p);
    //ScopedPtr<int> sp1(sp);  
    return 0;
}


template<typename T>
class ScopedPtrArray
{
public:
    ScopedPtrArray(T* ptrArr = NULL)
        :_ptrArr(ptrArr)
    {}
    ~ScopedPtrArray()
    {
        if (NULL != this)
        {
            delete[] _ptrArr;  
            _ptrArr = NULL;
        }
    }
protected:
    ScopedPtrArray<T>(ScopedPtrArray<T> & parr);
    ScopedPtrArray& operator=(ScopedPtrArray<T> & parr);
private:
    T* _ptrArr;
};
#include<iostream>  
using namespace std;

int main()
{
    ScopedPtrArray<int> pa(new int[10]);
    //ScopedPtrArray<int> pa1(pa);  
    return 0;
}