智能指针--scoped_ptr shared_ptr weak_ptr

所谓智能指针就是智能/自动化的管理指针所指向的动态资源的释放；

scopde_ptr--防拷贝

什么叫做防拷贝？就是不允许一个地址空间的指针赋值给另一个指针，导致有两个指针指向同一个地址；也就是说防拷贝能保证地址与指针是一一对应的关系；

实现方法：要拷贝，就需要通过对象来调用赋值运算符重载函数/拷贝构造函数，只要将这两个成员函数私有化/保护化，就ok啦；

具体代码：

 

template<class T>
class ScopedePtr
{
public:
	ScopedePtr(T *ptr)
		:_ptr(ptr)
	{}
	~ScopedePtr()
	{
		delete _ptr;
	}

	T* GetPtr()
	{
		return _ptr;
	}
	T& operator*()
	{
		return *_ptr;
	}
	T* operator->()
	{
		return _ptr;
	}
protected:
	ScopedePtr<T>& operator=(const ScopedePtr<T> &sp);
	ScopedePtr(const ScopedePtr<T> &sp);

protected:
	T *_ptr;
};

shared_ptr--引用计数

允许多个指向同一块地址；每增加一个指向该地址的指针计数器就加一；减少一个指向该地址的指针计数器减一，直到计数器的值为0的时候进行delete释放这块空间；

代码：

template<class T>
class SharedPtr
{
	SharedPtr(T * ptr)
	:_ptr(ptr)
	, _ptrCount(new int(1))
	{
	}
	~SharedPtr()
	{
		if (*_ptrCount == 0)
		{
			delete _ptr;
		}
	}

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

	SharedPtr<T>& operator=(const SharedPtr<T>& sp)
	{
		Release();
		_ptr = sp._ptr;
		_ptrCount = sp._ptrCount;
		(*_ptrCount)++;
	}

	SharedPtr(const SharedPtr<T>& sp)
		:_ptr(sp._ptr)
	{
		_ptrCount = sp._ptrCount;
		(*_ptrCount)++;
	}

	void Release()
	{
		if (*_ptrCount != 0)
			(*_ptrCount)--;
	}

protected:
	T *_ptr;
	int *_ptrCount;
};

但是share_ptr有一个循环引用的问题：

当在双向链表时，想要释放p1但是p2->_prev指向p1,引用计数为1，想要释放p1必须先释放p2;对于p2而言想要释放也必须先释放p1；这就构成了循环引用问题，两者都不能释放；

weak_ptr就应运而生，专们用来辅助shared_ptr;

weak_ptr对象引用资源时不会增加引用计数，但是它能够通过lock()方法来判断它所管理的资源是否被释放。另外很自然地一个问题是：既然weak_ptr不增加资源的引用计数，那么在使用weak_ptr对象的时候，资源被突然释放了怎么办呢？呵呵，答案是你根本不能直接通过weak_ptr来访问资源。那么如何通过weak_ptr来间接访问资源呢？答案是：在需要访问资源的时候weak_ptr为你生成一个shared_ptr，shared_ptr能够保证在shared_ptr没有被释放之前，其所管理的资源是不会被释放的。创建shared_ptr的方法就是lock()方法。

弱指针当引用的对象活着的时候不一定存在。仅仅是当它存在的时候的一个引用。弱指针并不修改该对象的引用计数，这意味这弱指针它并不对对象的内存进行管理，在功能上类似于普通指针，然而一个比较大的区别是，弱指针能检测到所管理的对象是否已经被释放，从而避免访问非法内存

template<typename T> class weak_ptr {
    public:
        template <typename Y>
        weak_ptr(const shared_ptr<Y>& r);

        weak_ptr(const weak_ptr& r);

        ~weak_ptr();

        T* get() const; 
        bool expired() const; 
        shared_ptr<T> lock() const;
    };

expired()用于检测所管理的对象是否已经释放；lock()用于获取所管理的对象的强引用指针。