C++:弱智能指针（weak_ptr）

弱智能指针:

         一般结合强智能指针使用，它指向一个 shared_ptr 管理的对象. 进行该对象的内存管理的是强引用的 shared_ptr. weak_ptr只是提供了对管理对象的一个访问手段；weak_ptr 设计的目的是为配合 shared_ptr 而引入的一种智能指针来协助 shared_ptr 工作, 不会引起引用记数的增加或减少。

针对于强智能指针(shared_ptr )相互引用会出现内存无法释放的情况，加入弱智能指针(weak_ptr)。

#include

using namespace std;

class RefManage
{
public:
	static RefManage* getInstance()//静态函数不依赖于对象的调用,不能设计为普通的成员方法
	{
		return &rm;
	}
private:
	RefManage() :length(0)
	{}
	RefManage(const RefManage& rhs);
public:
	
	void addRef(void* ptr)
	{
		if (ptr != NULL)
		{
			int index = Find(ptr);
			if (index < 0)//新的节点
			{
				/*arr[length].addr = ptr;
				arr[length++].refcount++;*/
				Node tmp(ptr, 1);
				arr[length++] = tmp;
			}
			else
			{
				arr[index].refcount++;
			}
		}
	}
	void delRef(void* ptr)
	{
		if (ptr != NULL)
		{
			int index = Find(ptr);
			if (index < 0)
			{
				throw exception("addr is not exist");
			}
			else
			{
				if (arr[index].refcount != 0)
				{
					arr[index].refcount--;
				}
			}
		}
	}
	int getRef(void* ptr)
	{
		if (ptr == NULL)
		{
			return 0;
		}
		int index = Find(ptr);
		if (index < 0)
		{
			return -1;
		}
		else
		{
			return arr[index].refcount;
		}
		
	}
private:
	int Find(void* ptr)
	{
		for (int i = 0; i < length; i++)
		{
			if (arr[i].addr == ptr)
			{
				return i;
			}
		}
		return -1;
	}
	class Node
	{
	public:
		Node(void* ptr, int ref = 0)
		{
			addr = ptr;
			refcount = ref;
		}
		Node()
		{
			memset(this, 0, sizeof(Node));//清零
		}
	public:
		void* addr;
		int refcount;
	};
	Node arr[5];
	int length;//有效节点个数 当前要插入的节点下标
	static RefManage rm;
};

RefManage RefManage::rm;//在main函数调用之前就生成  .data


template
class ShardPtr
{
public:
	ShardPtr(T* ptr=NULL) :mptr(ptr)
	{
		AddRef();
	}
	ShardPtr(const ShardPtr& rhs):mptr(rhs.mptr)
	{
		AddRef();
	}
	ShardPtr& operator=(const ShardPtr& rhs)
	{
	    if (this != &rhs)
	    {
			DelRef();
			if (GetRef() == 0)
			{
				delete mptr;
			}
			mptr = rhs.mptr;
			AddRef();//相当于this指针调用
	    }
		return *this;
    }
	T* getPtr()const
	{
		return mptr;
	}
	~ShardPtr()
	{
		DelRef();
		if (GetRef() == 0)
		{
			delete mptr;
		}
		mptr = NULL;
	}
	T* operator->()
	{
		return mptr;
	}
	T* operator*()
	{
		return *mptr;
	}
private:
	void AddRef()
	{
		rm->addRef(mptr);
	}
	void DelRef()
	{
		rm->delRef(mptr);
	}
	int GetRef()
	{
		return rm->getRef(mptr);
	}
	T* mptr;
	static RefManage* rm;
};

template
RefManage* ShardPtr::rm = RefManage::getInstance();


template
class WeakPtr
{
public:
	WeakPtr(T* ptr = NULL) :mptr(ptr) {}
	WeakPtr(const WeakPtr& rhs) :mptr(rhs.mptr) {}
	WeakPtr& operator=(const ShardPtr& rhs)// 弱智能指针=强智能能指针
	{
		//mptr = rhs.mptr;
		mptr = rhs.getPtr();
		return *this;
	}
	~WeakPtr() {}
	T* operator->()
	{
		return mptr;
	}
	T& operator*()
	{
		return *mptr;
	}
private:
	T * mptr;
};


class B;

class A
{
public:
	A()
	{
		cout << "A()" << endl;
	}
	~A()
	{
		cout << "~A()" << endl;
	}
	WeakPtr pb;
};


class B
{
public:
	B()
	{
		cout << "B()" << endl;
	}
	~B()
	{
		cout << "~B()" << endl;
	}
	WeakPtr pa;
};

int main()
{
	ShardPtr spa(new A());
	ShardPtr spb(new B());
	spa->pb = spb;
	spb->pa = spa;
	return 0;
}

打印结果：

         

解释：