auto_ptr智能指针

auto_ptr智能指针

template<class _Ty>
struct auto_ptr_ref // proxy reference for auto_ptr copying
{	
	explicit auto_ptr_ref(_Ty *_Right)
		: _Ref(_Right)
	{	
		// construct from generic pointer to auto_ptr ptr
	}

	_Ty *_Ref;	// generic pointer to auto_ptr ptr
};

template<class _Ty>
class auto_ptr  // wrap an object pointer to ensure destruction
{	
public:
	typedef _Ty element_type;

	explicit auto_ptr(_Ty *_Ptr = 0)
		: _Myptr(_Ptr)
	{	
		// construct from object pointer
	}

	auto_ptr(auto_ptr<_Ty>& _Right) : _Myptr(_Right.release())
	{	
		// construct by assuming pointer from _Right auto_ptr
	}

	auto_ptr(auto_ptr_ref<_Ty> _Right) 
	{	
		// construct by assuming pointer from _Right auto_ptr_ref
		_Ty *_Ptr = _Right._Ref;
		_Right._Ref = 0;	// release old
		_Myptr = _Ptr;	// reset this
	}

	template<class _Other>
    operator auto_ptr<_Other>() 
	{	
		// convert to compatible auto_ptr
		return (auto_ptr<_Other>(*this));
	}

	template<class _Other>
	operator auto_ptr_ref<_Other>()
	{	
		// convert to compatible auto_ptr_ref
		_Other *_Cvtptr = _Myptr;	// test implicit conversion
		auto_ptr_ref<_Other> _Ans(_Cvtptr);
		_Myptr = 0;	// pass ownership to auto_ptr_ref
		return (_Ans);
	}

	template<class _Other>
	auto_ptr<_Ty>& operator=(auto_ptr<_Other>& _Right) 
	{	
		// assign compatible _Right (assume pointer)
		reset(_Right.release());
		return (*this);
	}

	template<class _Other>
	auto_ptr(auto_ptr<_Other>& _Right) 
		: _Myptr(_Right.release())
	{	
		// construct by assuming pointer from _Right
	}

	auto_ptr<_Ty>& operator=(auto_ptr<_Ty>& _Right)
	{	
		// assign compatible _Right (assume pointer)
		reset(_Right.release());
		return (*this);
	}

	auto_ptr<_Ty>& operator=(auto_ptr_ref<_Ty> _Right) 
	{	
		// assign compatible _Right._Ref (assume pointer)
		_Ty *_Ptr = _Right._Ref;
		_Right._Ref = 0;	// release old
		reset(_Ptr);	// set new
		return (*this);
	}

	~auto_ptr()
	{	
		// destroy the object
		delete _Myptr;
	}

	_Ty& operator*() const 
	{	
		// return designated value
		return (*get());
	}

	_Ty *operator->() const 
	{	
		// return pointer to class object
		return (get());
	}

	_Ty *get() const _THROW0()
	{	
		// return wrapped pointer
		return (_Myptr);
	}

	_Ty *release() _THROW0()
	{	
		// return wrapped pointer and give up ownership
		_Ty *_Tmp = _Myptr;
		_Myptr = 0;
		return (_Tmp);
	}

	void reset(_Ty* _Ptr = 0)
	{	
		// destroy designated object and store new pointer
		if (_Ptr != _Myptr)
			delete _Myptr;
		_Myptr = _Ptr;
	}

private:
	_Ty *_Myptr;	// the wrapped object pointer
};

template <typename T>
class smart_ptr
{
public:
	smart_ptr(T *p = 0): pointee(p), count(new size_t(1)) { }  //初始的计数值为1
	smart_ptr(const smart_ptr &rhs): pointee(rhs.pointee), count(rhs.count) { ++*count; } //拷贝构造函数，计数加1
	~smart_ptr() { decr_count(); }              //析构，计数减1，减到0时进行垃圾回收，即释放空间
	smart_ptr& operator= (const smart_ptr& rhs) //重载赋值操作符
	{
		//给自身赋值也对，因为如果自身赋值，计数器先减1，再加1，并未发生改变
		++*count;
		decr_count();
		pointee = rhs.pointee;
		count = rhs.count;
		return *this;
	}  
	//重载箭头操作符和解引用操作符，未提供指针的检查
	T *operator->() { return pointee; }
	const T *operator->() const { return pointee; }
	T &operator*() { return *pointee; }
	const T &operator*() const { return *pointee; }
	size_t get_refcount() { return *count; } //获得引用计数器值
private: 
	T *pointee;       //实际指针，被代理  
	size_t *count;    //引用计数器
	void decr_count() //计数器减1
	{
		if(--*count == 0) 
		{
			delete pointee;
			delete count;
		}
	}
};