boost::shared_ptr與定制刪除器

shared_ptr

     shared_ptr是一種智能指針，他的作用如同指針，但會記錄有多少shared_ptr指向同一個對象。使用時必須引用頭文件<boost/shared_ptr.hpp>

template<class T>
class ShartedPtr
{
public:
	//構造函數
	ShartedPtr(T* ptr)
	:_ptr(ptr)
	, _pCount(new int(1))
	{
	}
	//拷貝構造
	ShartedPtr(const ShartedPtr<T>&sp)
		:_ptr(sp._ptr)
		, _pCount(sp._pCount)
	{
		++(*_pCount);
	}
	//賦值
	ShartedPtr&operator = (ShartedPtr<T>sp)
	{
		swap(_ptr, sp._ptr);
		swap(_pCount, sp._pCount);

		return *this;
	}
	//重載*
	T &operator*()
	{
		return *_ptr;
	}
	//重載->
	T *operator->()
	{
		return _ptr;
	}
	//析構函數
	~ShartedPtr()
	{
		Relase();
	}
protected:
	void Relase()
	{
		if (--(*_pCount) == 0)
		{
			delete _ptr;
			delete _pCount;
		}
	}
private:
	T* _ptr;
	int *_pCount;
};
struct A
{
	int _A;
};
int main()
{
	ShartedPtr<int> sp1(new int(1));
	ShartedPtr<int> sp2(sp1);
	sp1 = sp2;
	ShartedPtr<int> sp3(sp2);
	*sp3 = 10;
	ShartedPtr<A>sp4(new A);
	sp4->_A = 30;
	return 0;
}

 但是shared_ptr也存在一系列問題

1. 引用計數存在線程安全問題

2. 會出現循環引用問題

3. 定制刪除器

      循環引用即在使用雙向鏈表時，若使用shared_ptr則會出現在析構時由于同一塊空間有兩個對象指向，且對象兩兩之間相互指向，故在析構時兩對象都在等對方的_pCount減為一，從而一直到最后對象都沒有析構

shared_ptr<Node>cur(new Node(1));
shared_ptr<Node>next(new Node(1));
cur->_next=next;
next->_prev=cur;

shared_ptr的定制刪除器

template<class T,class D>
class ShartedPtr
{
public:
	//構造函數
	ShartedPtr(T* ptr)
	:_ptr(ptr)
	, _pCount(new int(1))
	{
	}
	//構造函數的一個重載
	ShartedPtr(T* ptr,D del)
		:_ptr(ptr)
		, _pCount(new int(1))
		, _del(del)
	{
	}
	//拷貝構造
	ShartedPtr(const ShartedPtr<T,D>&sp)
		:_ptr(sp._ptr)
		, _pCount(sp._pCount)
	{
		++(*_pCount);
	}
	//賦值
	ShartedPtr&operator = (ShartedPtr<T,D>sp)
	{
		swap(_ptr, sp._ptr);
		swap(_pCount, sp._pCount);

		return *this;
	}
	//重載*
	T &operator*()
	{
		return *_ptr;
	}
	//重載->
	T *operator->()
	{
		return _ptr;
	}
	//析構函數
	~ShartedPtr()
	{
		Release();
	}
protected:
	void Release()
	{
		if (--(*_pCount) == 0)
		{
			_del( _ptr);
			delete _pCount;
		}
	}
private:
	T* _ptr;
	int *_pCount;
	D _del;
};
struct DefaultDel
{
	void operator()(void* ptr)
	{
		delete ptr;
	}
};
struct Free
{
	void operator()(void* ptr)
	{
		free(ptr);
	}
};
//struct Fclose
//{
//	void operator()(void* ptr)
//	{
//		fclose(FILE*(ptr));
//	}
//};
int main()
{
	ShartedPtr<int, DefaultDel>sp1(new int(1));
	ShartedPtr<int, Free>sp2((int*)malloc(sizeof(int)));

}

   ps：仿函數的介紹

    仿函數就是使一個類使用看上去像一個函數，其實現就是類中實現一個operator().這個類就有了類似函數的行為。

struct Free
{
                 void operator()(void *ptr)
                {
                                free( ptr);
                }
};
void Testsharedptr()
{
int *p1=(int*)malloc(sizeof(int)*10);
shared_ptr<int>sp1(p1,Free());//在使用完后自動釋放p1
}