auto_ptr的两种方案

方案一：

    因为在类中对同一块空间的析构在一次以上，就会发生错误，所以在进行赋值和拷贝构造时（同一块空间有一个以上的指针指向），保证只有一个指针指向这块空间，对原指针赋空操作，这样在析构时一块空间只会被析构一次

class AutoPtr { public:	//构造函数	AutoPtr(T *ptr)	:_ptr(ptr)	{}	//拷贝构造函数	//管理权的转移	AutoPtr(AutoPtr<T>& ap)	:_ptr(ap._ptr)	{	ap._ptr = NULL;	}	//赋值语句	AutoPtr<T>& operator=(AutoPtr<T>&ap)	{	if (&ap != this)//自赋值检测	{	delete _ptr;	_ptr = ap._ptr;	ap._ptr = NULL;	}	return *this;	}	//重载*	 T&operator*()	{	 return *_ptr;	}	 //重载->	 T*operator->()	 {	 return _ptr;	 }	 //析构函数	~AutoPtr()	{	if (_ptr != NULL)	delete _ptr;	} private:	T* _ptr; }; struct A {	int _a; }; int main() {	AutoPtr<int>ap1(new int(1));//构造函数	AutoPtr<int>ap2(ap1);//拷贝构造函数	AutoPtr<int>ap3(new int(2));	ap3 = ap2;//重载=	*ap3 = 10;//重载*	AutoPtr<A>ap4(new A);	ap4->_a = 20;//重载->	return 0; }

方案二：

     在原有的私有成员上添加一个bool类型的_owner成员，当这块空间有一个autoptr指向时，这个autoptr的_owner=TRUE,当出现一块空间有多个指针指向操作时，仅最新的对象的_owner成员为TRUE,其他均为FALSE.在析构时，只要找到_owner=TRUE的才进行析构，其他则不析构，这样保证了一块空间不会被析构多次。

template<class T> class AutoPtr { public:	//构造函数	AutoPtr(T *ptr)	:_ptr(ptr)	, _owner(true)	{}	//拷贝构造函数	AutoPtr(AutoPtr<T>& ap)	:_ptr(ap._ptr)	{	ap._owner = false;	_owner = true;	}	//赋值语句	AutoPtr<T>& operator=(AutoPtr<T>&ap)	{	if (&ap != this)//自赋值检测	{	_owner = true;	ap._owner = false;	_ptr = ap._ptr;	}	return *this;	}	//重载*	 T&operator*()	{	 return *_ptr;	}	 //重载->	 T*operator->()	 {	 return _ptr;	 }	 //析构函数	~AutoPtr()	{	if (_owner == true)	delete _ptr;	} private:	T* _ptr;	bool _owner; }; struct A {	int _a; }; int main() {	AutoPtr<int>ap1(new int(1));//构造函数	AutoPtr<int>ap2(ap1);//拷贝构造函数	AutoPtr<int>ap3(new int(2));	ap3 = ap2;//重载=	*ap3 = 10;//重载*	AutoPtr<A>ap4(new A);	ap4->_a = 20;//重载->	return 0; }

比较：

    在谷歌的说明中auto_ptr被禁止使用，如果一定要说那种方案好那我会选第一种，方案一是在方案二上的改进，由于方案二中的当_owner=true释放空间时，_owner=false的对象中指针则成为了野指针（释放完内存后未把内存置空）