autoptr的实现

#include<iostream>
using namespace std;

    //智能指针主要 在于即使忘了delete，他也能自己释放堆内存空间，只要能做到这一点，那就是智能指针。。。。。。。。别让new开辟上的空间被重复释
//放，以及别让new开辟的空间没有释放，这就是智能指针。

template<class T>
class Auto_ptr
{
public:
    Auto_ptr(T* ptr=new T)
        :_ptr(ptr)
    {
         cout<<"Auto_ptr: "<<_ptr<<endl;
    }
    ~Auto_ptr()
    {
        delete []_ptr;
        _ptr =NULL;
        cout <<"~Auto_ptr: "<<endl;
    }
    Auto_ptr(Auto_ptr<T>& ap)   //智能指针之管理权的转移
    {       
        _ptr=ap._ptr ;
        ap._ptr =NULL;
    }  
    Auto_ptr<T>& operator=(Auto_ptr<T>& ap)
    {
        if(_ptr != ap._ptr )
        {
        delete[] _ptr;
        _ptr = ap._ptr ;========>> {swap(_ptr, s._ptr);
                                 swap(_pcount, s._pcount);
                               return *this ;}这种写法方便
        ap._ptr = NULL;
        return *this;
        }
    }

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

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





private:

    T* _ptr;

};


struct A
{
    A(int a = 0)
        :_a(a)      

    {
        cout<<"A"<<endl;
    }
    int _a;
};

int main()
{
    Auto_ptr<int> ap1(new int(1)) ;
    Auto_ptr<int> ap2(ap1);
    Auto_ptr<int> ap3;
    ap3=ap2;
    *ap3=10;
    Auto_ptr<A> ap4(new A(2));//首先它是对象，其次数据类型是结构体：由大到小观察    
    ap4->_a=5;//ap4._ptr ->_a:调用结构体内部的对象
    return 0;
}



//智能指针实现的第二种方法
#include<iostream>
using namespace std;

template<class T>
class Auto_ptr
{
public:
    Auto_ptr(T* ptr)
        :_ptr(ptr),
        _owner(true)            //多了个owner
    {
        cout<<"_owner:"<<endl;
    }
    Auto_ptr(Auto_ptr& ap)
        :_owner(true)

    {
        _ptr = ap._ptr ;
        ap._owner = false;
    }
    ~Auto_ptr()
    {
        if(_owner)
        {
            delete[] _ptr;
            cout<<"~_owner:"<<endl;
            _ptr = NULL;//1.delete之后一定马上及时置NULL    2.千万不能重复delete东西
        }
        else
        {
            _ptr = NULL;
        }
    }



private:
    T* _ptr;
    bool _owner;
};

int main()
{
    Auto_ptr<int> ap1(new int(1));
    Auto_ptr<int> ap2(ap1);
    return 0;
}

//两者区别：（1）旧方案占的内存大于新方案；（2）旧方案的每个指针都指向同一块空间，会使的变量的值容易被修改，不安全


//定制删除器》》》shared_ptr的传递删除器(deleter)方式比较简单, 只需要在参数中添加具体的删除器函数名, 即可; 注意是单参数函数;
#include<iostream>
#include<memory>

using namespace std;

template<class T>   //定制删除器（new）
struct Del         //是个类，可以当作一个模板参数
{
    void operator()(T* ptr)
    {
        delete ptr;

        cout<<"operator():"<<endl;
    }
};

template<class T,class D=Del<T>>
class  Share_ptr
{
public:
    Share_ptr(T* ptr)
        :_ptr(ptr),
        _pcount(new int(1))
    {
    }
    Share_ptr(T* ptr,D del)
        :_ptr(ptr),
        _pcount(new int(1)).
        _del(del)
    {

    }
    ~Share_ptr()
    {
        _Release();
        _ptr=NULL;
        _pcount=NULL;
    }

    Share_ptr(const Share_ptr<T,D>& sp)
        :_ptr(sp._ptr ),
        _pcount(sp._pcount )//两个指针指向同一块内存
    {
        (*_pcount)++;
    }

    Share_ptr<T,D>& operator=(const Share_ptr<T,D>& sp)
    {
        if(_ptr!=sp._ptr )
        {       //（1）防止自赋值；（2）两个指针管理同一块空间//（3）两个指针分别指向两块空间时
             _Release();
            _ptr=sp._ptr ;      
            _pcount=sp._pcount ;        
            (*_pcount)++;
        }

        return *this;
    }
public:

    void _Release()
      {
           if(--(*_pcount) == 0)

          {
                 _del(_ptr);//delete_ptr;

                 delete _pcount;

          }
     }

private:
    T* _ptr;
    int* _pcount;
    D _del;



};


//仿函数(类,重载了operator[]，不是函数像函数）
int main()
{
    Share_ptr<int,Del<int>> sp1(new int[2]);

    Share_ptr<int,Del<int>> sp2(new int[3]);

    Share_ptr<int> sp3(new int[3]);
    return 0;
}