智能指针的实现

#pragma once
#include<iostream>
using namespace std;

//原理：资源的转移   解决的问题：释放指针
//缺陷：如果一个指针通过拷贝构造和赋值运算符重载将管理的空间交给其他指针，则原指针是没有办法访问这块空间了

#if 0
template<class T>
class AutoPtr
{
public:
	AutoPtr(T* ptr = NULL)
		:_ptr(ptr)
	{}

	AutoPtr(AutoPtr<T>& ap)
		:_ptr(ap._ptr)
	{
		ap._ptr = NULL;
	}

	AutoPtr<T>& operator=(AutoPtr<T>& ap)
	{
		if (this != &ap)
		{
			if (_ptr)
				delete _ptr;
			_ptr = ap._ptr;
			ap._ptr = NULL;
		}
		return *this;
	}

	T& operator*()
	{
		return *_ptr;
	}

	T* operator->()
	{
		return _ptr;
	}

	~AutoPtr()
	{
		if (_ptr)
		{
			delete _ptr;
		}
	} 
private:
	T* _ptr;
};

#endif


#if 0
//多添加一个bool类型的变量，用于对空间绝对拥有权的标记 
template<class T>
class AutoPtr
{
public:
	AutoPtr(T* ptr = NULL)
		:_ptr(ptr)
		, _owner(false)
	{
		if (_ptr)
		{
			_owner = true;
		}
	}

	AutoPtr(const AutoPtr<T>& ap)
		:_ptr(ap._ptr)
		, _owner(ap._owner)
	{
		ap._owner = false;
	}

	AutoPtr<T>& operator=(const AutoPtr<T>& ap)
	{
		if (this != &ap)
		{
			if (_ptr&&_owner)
				delete _ptr;

			_ptr = ap._ptr;
			_owner = ap._owner;
			ap._owner = false;
		}
		return *this;
	}

	~AutoPtr()
	{
		if (_ptr && _owner)
		{
			delete _ptr;
			_ptr = NULL;
			_owner = false; 
		}
	}

	T& operator*()
	{
		return *_ptr;
	}

	T* operator->()
	{
		return _ptr;
	}

private: 
	T* _ptr;
	mutable bool _owner;//对空间绝对拥有权的标记   
};

void FunTest()
{
	AutoPtr<int> ap1(new int);
	AutoPtr<int> ap2(ap1);
	AutoPtr<int> ap3;

	*ap1 = 10;
	*ap2 = 20;
	ap3 = ap2;
}

#endif


#if 0
//ScopedPtr(unique_ptr):同一块空间只能供一个对象运用，一个对象只能由一个对象管理
//原理：防止拷贝构造函数和赋值运算符重载拷贝对象，就不会引起多个对象共同管理同一块空间
//做法：将拷贝构造函数和赋值运算符重载放入到私有成员列表中
//问题：不能够调用拷贝构造函数和赋值运算符重载对对象进行拷贝
template<class T>
class ScopedPtr
{
public:
	ScopedPtr(T* ptr = NULL)
		:_ptr(ptr)
	{}
	
	~ScopedPtr()
	{
		if (_ptr)
		{
			delete _ptr;
		}
	}

	T& operator*()
	{
		return *_ptr;
	}

	T* operator->()
	{
		return _ptr;
	}

	/*
private:
	ScopedPtr(const ScopedPtr<T>& sp)
	{}

	ScopedPtr<T>& operator=(const ScopedPtr<T>& sp)
	{
		return *this;
	}

	*/
private:
	ScopedPtr(const ScopedPtr<T>& sp);
	ScopedPtr<T>& operator=(const ScopedPtr<T>& sp);
private:
	T* _ptr;
};

#endif


#if 0
//定制删除器   给使用不同方式开辟内存空间的指针，定制与其相匹配的释放方式的相关函数
//函数指针

void FClose(FILE* fp)
{
	if (fp)
		fclose(fp);
	fp = NULL;
}

template<class T>
void Free(T* p)
{
	if (p)
	{
		free(p);
		p = NULL;
	}
}

template<class T>
void Delete(T* p)
{
	if (p)
	{
		Delete p;
		p = NULL;
	}
}

typedef void(*PFD)(void*);

template<class T>
class ScopedPtr
{
public:
	ScopedPtr(T* ptr = NULL, PFD defDestory = Delete<T>)
		:_ptr(ptr)
		, _defDestory(defDestory)
	{}

	~ScopedPtr()
	{
		if (_ptr)
		{
			_defDestory(_ptr);
		}
		/*if (_ptr)
		{
			delete _ptr;
		}*/
	}

	T& operator*()
	{
		return *_ptr;
	}

	T* operator->()
	{
		return _ptr;
	}

	/*
	private:
	ScopedPtr(const ScopedPtr<T>& sp)
	{}

	ScopedPtr<T>& operator=(const ScopedPtr<T>& sp)
	{
	return *this;
	}

	*/
private:
	ScopedPtr(const ScopedPtr<T>& sp);
	ScopedPtr<T>& operator=(const ScopedPtr<T>& sp);
private:
	T* _ptr;
	PFD _defDestory;
};

#endif

//伪函数：设置不同类型释放方式的类  传参的时候以便识别类型

template<class T>
class DefDes
{
public:
	void operator()(T* ptr)
	{
		if (ptr)
		   delete ptr;
	}
};

template<class T>
class Free
{
public:
	void operator()(T* ptr)
	{
		if (ptr)
		{
			free(ptr);
			ptr = NULL;
		}
	}
};


class FClose
{
public:
	void operator()(FILE* pf)
	{
		if (pf)
		{
			fclose(pf);
			pf = NULL;
		}
	}
};

template<class T,class Dp = DefDes<T>>
class ScopedPtr
{
public:
	ScopedPtr(T* ptr = NULL)
		:_ptr(ptr)
	{}

	~ScopedPtr()
	{
		if (_ptr)
		{
			Dp destory;
			destory(_ptr);
			//Dp()(_ptr);
		}
	}

	T& operator*()
	{
		return *_ptr;
	}

	T* operator->()
	{
		return _ptr;
	}

	/*
	private:
	ScopedPtr(const ScopedPtr<T>& sp)
	{}

	ScopedPtr<T>& operator=(const ScopedPtr<T>& sp)
	{
	return *this;
	}

	*/
private:
	ScopedPtr(const ScopedPtr<T>& sp);
	ScopedPtr<T>& operator=(const ScopedPtr<T>& sp);
private:
	T* _ptr;
};

void FunTest()
{
	ScopedPtr<int> sp0(new int);
	ScopedPtr<int,Free<int>> sp1((int*)malloc(sizeof(int)));
	FILE* pf = fopen("1.txt", "rb");
	ScopedPtr<FILE,FClose> sp2(pf);
}