架构共享指针和弱指针

SharedPtr.h

template<class T>
class FWeakPtr;

class FTestPtr
{
public:

	FTestPtr()
	{
		a = 1000;
	}
	~FTestPtr()
	{

	}

	void Init()
	{
		cout << "Init" << endl;
	}

private:
	int a;

};

template<class T>
class FSharedPtr
{
	friend class FWeakPtr<T>;
public:

	//FSharedPtr<FTest> Instance(new FTest);
	FSharedPtr(T* InInstance = NULL)
		:Ptr(InInstance)
	{
		Count = new FRefCounter();
		if (InInstance)
		{
			Count->SharedCount = 1;
		}
	}

	//FSharedPtr<FTest> Instance1(new FTest);
	//FSharedPtr<FTest> Instance(Instance1);
	FSharedPtr(FSharedPtr<T> &InInstance)
	{
		this->Ptr = InInstance.Ptr;
		InInstance.Count->SharedCount++;
		this->Count = InInstance.Count.;
	}

	FSharedPtr(FWeakPtr<T>& InInstance)
	{
		this->Count = InInstance.Count;
		this->Count->SharedCount++;
		this->Ptr = InInstance.Ptr;
	}

	//FSharedPtr<FTest> Instance1(new FTest);
	//FSharedPtr<FTest> Instance = Instance1;
	FSharedPtr<T>& operator=(FSharedPtr<T>& InInstance)
	{
		if (this != &InInstance)
		{
			Release();
			InInstance.Count->SharedCount++;
			this->Count = InInstance.Count;
			this->Ptr = InInstance.Ptr;
		}
		return *this;
	}

	FSharedPtr<T>& operator=(FWeakPtr<T>& InInstance)
	{
		if (this->Ptr == InInstance.Ptr)
		{
			Release();
			this->Count = InInstance.Count;
			this->Count->SharedCount++;
			this->Ptr = InInstance.Ptr;
		}
	}

	T *operator*()
	{
		return *Ptr;
	}

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

	void Release()
	{
		Count->SharedCount--;

		if (Count->SharedCount >= 0)
		{
			if (Count->SharedCount < 1)
			{
				if (Count->WeakCount < 1)
				{
					delete Count; //弱指针也要判断 告诉弱指针，智能指针的情况
					Count = nullptr;
				}

				delete Ptr;
				Ptr = nullptr;
			}
		}

	}

	~FSharedPtr()
	{
		Release();
	}

private:
	T* Ptr;
	FRefCounter* Count;

};

template<class T>
class FWeakPtr
{
	friend class FSharedPtr<T>;

public:
	FWeakPtr()
		:Ptr(nullptr)
		, Count(nullptr)
	{

	}

	FWeakPtr(FSharedPtr<T>& InInstance)
		:Ptr(InInstance.Ptr)
		, Count(InInstance.Count)
	{
		Count->WeakCount++;
	}

	FWeakPtr<T>& operator=(FWeakPtr<T>& Wt)
	{
		if (Wt != this)
		{
			Release();
			Count = Wt.Count;
			Ptr = Wt.Ptr;

			Count->WeakCount++;
		}

		return *this;
	}

	FWeakPtr<T>& operator=(FSharedPtr<T>& St)
	{
		Release();
		Count = St.Count;
		Ptr = St.Ptr;

		Count->WeakCount++;

		return *this;
	}

	FSharedPtr<T> Pin()
	{
		FSharedPtr<T> SP(*this);
		return SP; //弱指针
	}

	bool IsVaild()
	{
		if (Count)
		{
			if (Count > 0)
			{
				return true;
			}
		}

		return false;
	}

	~FWeakPtr()
	{
		Release();
	}

	void Release()
	{
		if (Count)
		{
			Count->WeakCount--;
			if (Count->WeakCount < 1 && Count->SharedCount < 1)
			{
				delete Count;
				Count = nullptr;
			}
		}
	}

private:
	T* Ptr;
	FRefCounter* Count;
};

int main()
{
	FSharedPtr<FTestPtr> TestPtr(new FTestPtr());
	FSharedPtr<FTestPtr> TestPtr2(TestPtr);
	FSharedPtr<FTestPtr> TestPtr3(TestPtr2);

	TestPtr3.Release();
	TestPtr2->Init();
	TestPtr2.Release();

	FWeakPtr<FTestPtr> HelloPtr = TestPtr;
	FWeakPtr<FTestPtr> HelloPtr2(TestPtr);
	HelloPtr2.Pin()->Init();
	HelloPtr2.Release();

	return 0;
}

PtrType.h

//引用计数
class FRefCounter
{
public:
	FRefCounter()
		:SharedCount(0)
		, WeakCount(0)
	{

	}

	int SharedCount;
	int WeakCount;

};