Basic Shared Pointer Implementation

#pragma once

template <class T>
class BasicDeleter
{
public:
	void operator() (T* resource)
	{
		delete resource;
	}
};

template <class T>
class ArrayDeleter
{
public:
	void operator() (T* array)
	{
		delete[] array;
	}
};

template <class T, class Deleter = BasicDeleter<T>>
class SharedPtr
{
	T* _resource;
	int* _refs;

	void UpdateResource();

public:
	SharedPtr(T* resource);

	SharedPtr(const SharedPtr&);

	~SharedPtr();

	T& operator*()	{ return *_resource; }
	T* operator->()	{ return _resource; }
	SharedPtr& operator=(T* resource);
	SharedPtr& operator=(const SharedPtr& otherPtr);

	bool operator==(SharedPtr& rhs) { return rhs._resource == _resource; }
	bool operator!=(SharedPtr& rhs) { return rhs._resource != _resource; }

	T& operator[] (int index) { return _resource[index]; }
};

template <class T, class Deleter>
SharedPtr<T,Deleter>::SharedPtr(T* resource)
{
	_resource = resource;
	_refs = new int(1);
}

template <class T, class Deleter>
SharedPtr<T, Deleter>::~SharedPtr()
{
	--*_refs;
	UpdateResource();
}

template <class T, class Deleter>
void SharedPtr<T, Deleter>::UpdateResource()
{
	if (*_refs == 0)
	{
		delete _resource;
		delete _refs;
		_resource = nullptr;
		_refs = nullptr;
	}
}

template <class T, class Deleter>
SharedPtr<T, Deleter>::SharedPtr(const SharedPtr<T, Deleter>& rhs)
{
	_resource = rhs._resource;
	_refs = rhs._refs;
	++*_refs;
}

template <class T, class Deleter>
SharedPtr<T, Deleter>& SharedPtr<T, Deleter>::operator=(T* resource)
{
	if (resource == _resource)
		return *this;

	--*_refs;
	UpdateResource();

	_resource = resource;
	_refs = new int(1);

	return *this;
}

template <class T, class Deleter>
SharedPtr<T, Deleter>& SharedPtr<T, Deleter>::operator=(const SharedPtr<T, Deleter>& otherPtr)
{
	if (otherPtr._resource == _resource)
		return *this;

	--*_refs;
	UpdateResource();

	_resource = otherPtr._resource;
	_refs = otherPtr._refs;
	++*_refs;

	return *this;
}