【C++】智能指针

    在C++中，我们经常会用到动态开辟内存，需要我们自己维护，在出函数作用域之前，必须将管理的内存释放掉，否则就会造成内存泄漏，即使我们十分小心，但总有可能出错，因此便有了智能指针。

RAII：资源分配即初始化：定义一个类来封装资源的分配和释放，在构造函数完成资源的分配和初始化，在析构函数完成资源的清理，可以保证资源的正确初始化和释放。

1. auto_ptr，auto_ptr的实现机制是资源的转移，在拷贝构造函数和运算符重载函数中将当前对象的指针置为空，以实现资源的转移

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

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

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

它的缺陷是：当我们用一个对象去构造另一个对象时，原对象由于被置为NULL，则不能再使用了。

我们可以设置增加一个变量，当前对象如果为该资源的拥有者，则可以释放空间，否则，它将只有使用权。

template <class T>
class AutoPtr
{
public:
	AutoPtr(T* ptr = NULL)
		: _ptr(ptr)
		, _owner(true)
	{
		if (NULL == _ptr)
			_owner = false;
	}
	AutoPtr(const AutoPtr& ap)
		: _ptr(ap._ptr)
		, _owner(ap._owner)
	{
		ap._owner = false;
	}
	AutoPtr& operator=(const AutoPtr& ap)
	{
		if (this != &ap)
		{
			if (_ptr)
				delete _ptr;
			_ptr = ap._ptr;
			_owner = ap._owner;
			ap._owner = false;
		}
		return *this;
	}
	~AutoPtr()
	{
		if (_ptr && _owner == true)
		{
			delete _ptr;
			_owner = false;
			_ptr = NULL;
		}
	}
private:
	T* _ptr;
	mutable bool _owner;
};

它的缺陷是：如果我们在一个if的作用域中用对象ap1创建了ap2，那出了作用域，ap2被释放，ap1中的_ptr变成了野指针，无法再使用。因此，C++11建议不要使用auto_ptr。

2. scoped_ptr，这是boost库中的智能指针，它的实现机制是防拷贝，将拷贝构造函数和赋值运算符重载只声明而不定义，并设为私有成员。在C++标准库中unique_ptr与它的实现机制类似。

template<class T>
class ScopedPtr
{
public:
	ScopedPtr(T* ptr = NULL)
		: _ptr(ptr)
	{}
	~ScopedPtr()
	{
		if (_ptr)
		{
			delete _ptr;
			_ptr = NULL;
		}
	}
	T* operator->()
	{
		return _ptr;
	}
	T& operator*()
	{
		return *_ptr;
	}
private://防拷贝，将声明设为私有而不定义
	ScopedPtr(const ScopedPtr& sp);
	ScopedPtr& operator=(const ScopedPtr sp);
private:
	T* _ptr;
};

3. shared_ptr，它的实现原理类似于string类中的引用计数。拷贝一次，引用计数增加1，当引用计数为0时2，释放空间。

template<class T>
class SharedPtr
{
public:
	SharedPtr(T* ptr = NULL)
		: _ptr(ptr)
		, _pCount(new int(0))
	{
		if (_ptr)
			*_pCount = 1;
	}
	SharedPtr(const SharedPtr& sp)
		: _ptr(sp._ptr)
		, _pCount(sp._pCount)
	{
		(*_pCount)++;
	}
	SharedPtr& operator=(const SharedPtr& sp)
	{
		if (this != &sp)
		{
			if (_pCount && --(*_pCount) == 0)
			{
				delete _ptr;
				delete _pCount;
			}
			_ptr = sp._ptr;
			_pCount = sp._pCount;
			if (*_pCount)
				(*_pCount)++;
		}
		return *this;
	}
	~SharedPtr()
	{
		if (_ptr && --(*_pCount))
		{
			delete _ptr;
			_ptr = NULL;
            delete _pCount;
            _pConut=NULL;
		}
	}
	T* operator->()
	{
		return _ptr;
	}
	T& operator*()
	{
		return *_ptr;
	}
private:
	T* _ptr;
	int* _pCount;
};

weak_ptr与shared_ptr搭配使用，shared_ptr中存在着循环引用的问题。例如：

template<class T>
struct Node
{
	Node(const T& data)
	: _data(data)
	{
		cout << "Node()" << this << endl;
	}
	T _data;
	weak_ptr<Node<T>> _pNext;
	weak_ptr<Node<T>> _pPre;
	~Node()
	{
		cout << "~Node()" << this << endl;
	}
};

int main()
{
	shared_ptr<Node<int>> sp1(new Node<int>(10));
	shared_ptr<Node<int>> sp2(new Node<int>(20));
	cout << sp1.use_count() << endl;
	cout << sp2.use_count() << endl;
	sp1->_pNext = sp2;
	sp2->_pPre = sp1;
	cout << sp1.use_count() << endl;
	cout << sp2.use_count() << endl;
	return 0;
}

如果只是shared_ptr，由于sp1的next指向了sp2，sp2的pre指向了sp1，因此sp1和sp2的count为2，无法完成析构。当使用了weak_ptr时，引用计数count没有增加，增加的是weak计数。