autoptr的实现

来源：互联网发布：thinkphp5防止sql注入编辑：程序博客网时间：2024/06/05 03:26
#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;}
0 0