编写auto_ptr感

首先，上自己编写的auto_ptr

#include<iostream>
using namespace std;

template<typename T>
class my_auto_ptr
{
public:
//构造函数
my_auto_ptr() :ptr(NULL)
{}
my_auto_ptr(const T *x) :ptr((T *)x)
{}

//拷贝构造函数
my_auto_ptr(my_auto_ptr &other)
{
if (&other != this)
{
if (other.ptr == NULL)
ptr = NULL;
else
{
ptr = other.ptr;
other.ptr = NULL;
}
}
}

//赋值函数重载
my_auto_ptr& operator=(my_auto_ptr &other)
{
if (&other != this)
{
if (other.ptr == NULL)
ptr = NULL;
else
ptr = other.ptr;
}
other.ptr = NULL;
return *this;
}

//运算符的重载
T* operator->()
{
return ptr;
}

T& operator*()
{
return *ptr;
}
T* get()
{
return ptr;
}

~my_auto_ptr()
{
if (ptr)
delete ptr;
}
private:
T *ptr;
bool state;
};

int main()
{
char *str2 = "lianyiming";
char *a = new char[11];
strcpy(a, str2);

//无参数构造str
my_auto_ptr<char> str;
//传参数构造str1
my_auto_ptr<char> str1(a);
cout << *str1.get() << endl;

//拷贝构造创建,将str1拷贝str3，此时str1变为NULL
my_auto_ptr<char> str3(str1);
cout << *str3.get() << endl;

//赋值实现,将str3赋值传给str，此时str3变为NULL
str = str3;
cout << *str.get() << endl;
return 0;
}

在这里，我们首先要明白，auto_ptr的作用是用来保存一个指针，且这个指针不能指向对象为数组、类等复杂结构的数据。它的作用是，利用类的析构函数对指针指向的空间实现自动释放。然后，就是对auto_ptr的理解，auto_ptr实现保存一个指针，但不能有多个指针同时指向同一空间。即类似单例模式，一个空间，只允许一个智能指针来使用。

下面，上源代码：

#include<iostream>
//#include<memory>
using namespace std;
//RAII 机制
template<class _Ty>
class auto_ptr
{
public:
explicit auto_ptr(_Ty *_P = 0) :_Owns(_P != 0), _Ptr(_P) //_Owns初始化为假
{}
auto_ptr(const auto_ptr<_Ty> &_Y) :
_Owns(_Y._Owns), _Ptr(_Y.release())
{}
auto_ptr<_Ty>& operator=(const auto_ptr<_Ty> &_Y)
{
if (this != &_Y)
{
if (_Ptr != _Y.get())
{
if (_Owns)
{
delete _Ptr;
_Owns = _Y._Owns;
}
else if (_Y._Owns)
{

_Owns = true;
_Ptr = _Y.release();
}
}
}
return *this;
}
~auto_ptr()
{
if (_Owns)
delete _Ptr;
}
public:
//_Ty*release(const auto_ptr<_Ty> *const this)
_Ty* release()const
{
((auto_ptr<_Ty> *)this)->_Owns = false;
return _Ptr;
}
_Ty& operator*()const
{
return (*get());
}
_Ty* operator->()const
{
return(get());
}

_Ty* get()const
{
return _Ptr;
}
private:
bool _Owns;  //是否对内存进行释放  真-->释放； 假-->不调用析构
_Ty *_Ptr;
};

void main()
{
auto_ptr<int> ptr;
}

其为通过_Owns来设置所有权。在这里注意关键字explicit，其目的是为了防止发生隐式的转换构造函数的调用。