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的對象中指針則成為了野指針（釋放完內存后未把內存置空）