智能指针

原理

智能指针是存储指向动态分配（堆）对象指针的类，用于生存期控制，能够确保自动正确的销毁动态分配的对象，防止内存泄漏（利用自动调用类的析构函数来释放内存）。
通常是使用引用计数。智能指针类讲一个计数器与类指向的对象相关联，引用计数跟踪该类有多少个对象共享同一指针。

• RAII：利用对象生命周期来控制程序资源的技术。
• 具备指针的行为：既然是智能指针肯定要具备指针的功能

分类

1. std::auto_ptr
2. std::unique_ptr
3. std::shared_ptr

auto_ptr

template<class T>
class Auto_Ptr
{
public:
	Auto_Ptr(T* ptr = NULL)
		:_ptr(ptr)
	{}

	~Auto_Ptr()
	{
		if (_ptr)
			delete _ptr;
	}

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

	Auto_Ptr<T>& operator=(Auto_Ptr<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; }
private:
	T* _ptr;
};

unique_ptr

template<class T>
class Unique_Ptr
{
public:
	Unique_Ptr(T* ptr = NULL)
		:_ptr(ptr)
	{}

	Unique_Ptr()
	{
		if (_ptr)
			delete _ptr;
	}

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

	T& operator->() { return _ptr; }
private:
	Unique_Ptr(Unique_Ptr<T> const &);
	Unique_Ptr<T>& operator=(Unique_Ptr<T> const &);
private:
	T* _ptr;
};

shared_ptr

template<class T>
class Shared_Ptr
{
public:
	Shared_Ptr(T* ptr = NULL)
		:_ptr(ptr)
		,_count(new int(1))
	{
		if (_ptr == nullptr)
			*_count = 0;
	}

	~Shared_Ptr()
	{
		if (_ptr && --(*_count) == 0)
		{
			delete _ptr;
			delete _count;
		}
	}

	Shared_Ptr(Shared_Ptr<T>& sp)
		:_ptr(sp._ptr)
		,_count(sp._count)
	{
		if (_ptr)
			++(*_count);
	}

	Shared_Ptr<T>& operator=(const Shared_Ptr<T>& sp)
	{
		if (_ptr != sp._ptr)
		{
			if (_ptr && --(*_count) == 0)
			{
				delete _ptr;
				delete _count;
			}
			_ptr = sp._ptr;
			_count = sp._count;
			if (_ptr)
			{
				++(*_count);
			}
		}
		return *this;
	}

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

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

	int UseCount()
	{
		return *_count;
	}
private:
	T* _ptr;
	int *_count;
};