auto_ptr 要点解析

今天看了auto_ptr类的用法，又仔细看了看C++标准库中的符合标准的auto_ptr类别的实作，觉得自己基本上理解了auto_ptr的原理，下面就我的心得写几句，有不正确的地方，希望多多指教。

1. 初始化auto_ptr(T* ptr = 0);参数必须是new申请的空间，而且不能是数组。

2. 看代码：

auto_ptr(auto_ptr& ths):ap(ths.release()){}
	
template<class Y>
auto_ptr(auto_ptr<Y>& rhs):ap(rhs.release()){} //继承用，父类指针指向基类
	
auto_ptr& operator =(auto_ptr& rhs)
{
	reset(rhs.release());
	return *this;
} 
	
template<class Y>
auto_ptr& operator=(auto_ptr<Y>& rhs) // 比如Y为double，T为int，可以实现这种隐式转换
{
	reset(rhs.release());
	return *this;
}

 

3. 特殊转换与禁用const 类型的大部分功能，比如：赋值和初始化

auto_ptr(auto_ptr& ths):ap(ths.release()){} 
//抑制产生Myauto_ptr(const Myauto_ptr& ths)，
//没有这个函数就不能对用const auot_ptr<int> p
// auto_ptr<int> pp(p);是错误的


auto_ptr& operator =(auto_ptr& rhs) 
// 同样参数不用const修饰，auto_ptr<int> pp = p;也是错误的
//你发现const auto_ptr<int> p 通过限制，使其拥有权不会发生转移

// 但是允许auto_ptr<int> p = auto_ptr<int>(new int(1));就需要通过 auto_ptr_ref机制来实现
//auto_ptr<int>(new int(1)) 产生一个临时变量，这个临时变量需要赋给 参数为 const auto_ptr<int>& 
//类型的参数，因为没有这个默认的复制构造函数，
//所以无法转换,但是通过下面的函数可以正确执行。
//1.auto_ptr<int>(new int(1)) 产生一个临时对象
//2.operator auto_ptr_ref<Y>() 隐式转换为 auto_ptr_ref对象
//3.auto_ptr(auto_ptr_ref<T> rhs) 构造出一个auto_ptr对象
//这就是引入这个auto_ptr_ref的原因，但是肯定不止这些用意，也许有其他的用意，以后再补上。


template<class Y>
struct auto_ptr_ref

auto_ptr(auto_ptr_ref<T> rhs)
	
auto_ptr& operator=(auto_ptr_ref<T> rhs)
	
template<class Y>
operator auto_ptr_ref<Y>()
	
template<class Y>
operator auto_ptr<Y>()

4.程序的示例（为了在编译器好运行，我把auto_ptr 改为 Myauto_ptr，防止和标准库的重复）

template<class Y>
struct Myauto_ptr_ref
{
	Y* yp;
	Myauto_ptr_ref(Y* ths):yp(ths){}
};

template<class T>
class Myauto_ptr
{
	private:
		T* ap;
	public:
		typedef T element_type;
	
	explicit Myauto_ptr(T *ptr = 0):ap(ptr){}
	
	Myauto_ptr(Myauto_ptr& ths):ap(ths.release()){}
	
	template<class Y>
	Myauto_ptr(Myauto_ptr<Y>& rhs):ap(rhs.release()){} //继承用，父类指针指向基类
	
	Myauto_ptr& operator =(Myauto_ptr& rhs)
	{
		reset(rhs.release());
		return *this;
	} 
	
	template<class Y>
	Myauto_ptr& operator=(Myauto_ptr<Y>& rhs)
	{
		reset(rhs.release());
		return *this;
	}
	
	~Myauto_ptr()
	{
		delete ap;
	}
	
	T* get()
	{
		return ap;
	}
	
	T& operator*() const
	{
		return *ap;
	}
	
	T* operator->()const
	{
		return ap;
	}
	
	T* release()
	{
		T* tmp(ap);
		ap = 0;
		return tmp;
	}
	
	void reset(T* ptr = 0)
	{
		if(ap != ptr)
		{
			delete ap;
			ap = ptr;
		}	
	}
	
	Myauto_ptr(Myauto_ptr_ref<T> rhs) : ap(rhs.yp){}
	
	Myauto_ptr& operator=(Myauto_ptr_ref<T> rhs)
	{
		reset(rhs.yp);
		return *this;
	}
	
	template<class Y>
	operator Myauto_ptr_ref<Y>()
	{
		return Myauto_ptr_ref<Y>(release());
	}
	
	template<class Y>
	operator Myauto_ptr<Y>()
	{
		return Myauto_ptr<Y>(release());
	}
};