(C++ : IOCP-14) Reference Counting

class Missile
{
public:
	void SetTarget(Wraight* target)
	{
		_target = target;
	}

	bool Update()
	{
		if (_target == nullptr)
			return true;

		int posX = _target->_posX;
		int posY = _target->_posY;

		return true;
	}

	Wraight* _target = nullptr;
};

int main()
{	
	Wraight* wraight = new Wraight();
	Missile* missile = new Missile();

	missile->SetTarget(wraight);

	// 레이스가 피격 당함
	delete wraight;
    // 여기서 이렇게 마음대로 메모리를 날려도 될까???
    // missile에서 wraight를 어떻게 쓰고 있는지도 모르는데??
	
    // ...
}

#pragma once

/*---------------
   RefCountable
----------------*/

class RefCountable
{
public:
	RefCountable() : _refCount(1) { }
	// _refCount를 1로 초기화 한거는 정책에 따라 달라질 수 있음, 여기서는 1로 초기화 한다고 가정한다
	virtual ~RefCountable() { }

	int32 GetRefCount() { return _refCount; }

	int32 AddRef() { return ++_refCount; }
	int32 ReleaseRef()
	{
		int32 refCount = --_refCount;
		if (refCount == 0)
		{
			delete this;
		}
		return refCount;
	}

protected:
	atomic<int32> _refCount;    // 나를 참조하고 있는애들이 몇명이냐?
};

// 이제 카운팅이 필요한 객체는 RefCountable를 상속하자
class Wraight : public RefCountable
{
public:
	// ...

class Missile : public RefCountable
{
public:
	void SetTarget(Wraight* target)
	{
		_target = target;
		// RefCount를 추가해준다
		_target->AddRef();
	}

	bool Update()
	{
		if (_target == nullptr)
			return true;

		int posX = _target->_posX;
		int posY = _target->_posY;

		// TODO : 쫓아간다

		if (_target->_hp == 0)
		{
			// Release처리도 RefCount를 감소시킨다
			_target->ReleaseRef();
			_target->nullptr;
			return true;
		}

		return false;
	}

	Wraight* _target = nullptr;
};

int main()
{	
	Wraight* wraight = new Wraight();
	Missile* missile = new Missile();
	missile->SetTarget(wraight);

	// 레이스가 피격 당함
	wraight->ReleaseRef();
	wraight->nullptr;

    // ...
}

class Missile : public RefCountable
{
public:
	void SetTarget(Wraight* target)
	{
		_target = target;
		_target->AddRef();

		/* (문제)
			target을 복사하는 행위와
			AddRef를 하는 행위가 별개로 동작하다보니
			멀티쓰레드에 세이프하지 못하다
		*/
	}

	// ...

template<typename T>
class TSharedPtr
{
public:
	TSharedPtr() { }
	TSharedPtr(T* ptr) { Set(ptr); }

	// 복사
	TSharedPtr(const TSharedPtr& rhs) { Set(rhs._ptr); }
	// 이동
	TSharedPtr(TSharedPtr&& rhs) { _ptr = rhs._ptr; rhs._ptr = nullptr; }
	// 상속 관계 복사
	template<typename U>
	TSharedPtr(const TSharedPtr<U>& rhs) { Set(static_cast<T*>(rhs._ptr)); }

	~TSharedPtr() { Release(); }

public:
	// 복사 연산자
	TSharedPtr& operator=(const TSharedPtr& rhs)
	{
		if (_ptr != rhs._ptr)
		{
			Release();
			Set(rhs._ptr);
		}
		return *this;
	}

	// 이동 연산자
	TSharedPtr& operator=(TSharedPtr&& rhs)
	{
		Release();
		_ptr = rhs._ptr;
		rhs._ptr = nullptr;
		return *this;
	}

	bool		operator==(const TSharedPtr& rhs) const { return _ptr == rhs._ptr; }
	bool		operator==(T* ptr) const { return _ptr == ptr; }
	bool		operator!=(const TSharedPtr& rhs) const { return _ptr != rhs._ptr; }
	bool		operator!=(T* ptr) const { return _ptr != ptr; }
	bool		operator<(const TSharedPtr& rhs) const { return _ptr < rhs._ptr; }
	T*			operator*() { return _ptr; }
	const T*	operator*() const { return _ptr; }
				operator T* () const { return _ptr; }
	T*			operator->() { return _ptr; }
	const T*	operator->() const { return _ptr; }

	bool IsNull() { return _ptr == nullptr; }

private:
	inline void Set(T* ptr)
	{
		_ptr = ptr;
		if (ptr)
			ptr->AddRef();
	}

	inline void Release()
	{
		if (_ptr != nullptr)
		{
			_ptr->ReleaseRef();
			_ptr = nullptr;
		}
	}

private:
	T* _ptr = nullptr;
};

class Missile : public RefCountable
{
public:
	void SetTarget(WraightRef target)
	{
		// WraightRef target이 매개변수로 들어며 복사가 한 번 일어난다
		// 복사가 되면 RefCount가 1늘어나기에 SetTarget에 들어온 이상 절대 삭제가 되지않음
		_target = target;
		// target->AddRef();
		// 이제 직접 AddRef를 해주지 않아도 됨.
	}

class TSharedPtr
{
    // ...

public:
	// 복사 연산자
	TSharedPtr& operator=(const TSharedPtr& rhs)
	{
		if (_ptr != rhs._ptr)
		{
			Release();		// 내가 들고있던 포인터를 날리고

				// 여기서 메모리가 해지(delete)되고 
				// Set을 진행한다면??

			Set(rhs._ptr);	// 새롭게 들어온 포인터를 셋
		}
		return *this;
	}

    // ...

    private:
	inline void Set(T* ptr)
	{
		_ptr = ptr;
		if (ptr)// 여기서 메모리 체크한다 걱정말자 ㅎ
			ptr->AddRef();
	}

// using이렇게 쓸수 있음을 기억(자주까먹음)
using WraightRef = TSharedPtr<Wraight>;
using MissileRef = TSharedPtr<Missile>;

class Missile : public RefCountable
{
public:
	void SetTarget(WraightRef target)
	{
    // ...

int main()
{	
	WraightRef wraight(new Wraight());	// 생성하면서 Set이 한번 호출됨
	wraight->ReleaseRef();	// RefCount를 하나 제거해야함
	MissileRef missile(new Missile());
	missile->ReleaseRef();

    // ...

	// 피격
	wraight->nullptr;
	// 이게 되나?
	// wraight->WraightRef(nullptr);	// 컴파일러가 이렇게 고쳐줌
	// 내부에서 Set호출된다