#pragma once
#ifndef SMARTPOINTERS_H
#define SMARTPOINTERS_H

#include <cassert>

template<typename T>
class InstanceCounted
{
	InstanceCounted();
	InstanceCounted(const InstanceCounted&);
};

template<typename T>
class InstanceCounted<T*>
{
public:
	explicit InstanceCounted(T* pT) : m_pT(pT)
	{
		assert(m_pT != null);
		m_instCount = 1;
	}

	~InstanceCounted()
	{ delete m_pT; }

	void Increment()
	{ ++m_instCount; }

	void Decrement()
	{ --m_instCount; }

	unsigned GetCount()
	{ return m_instCount; }

	T* const GetPtr()
	{ return m_pT; }
	
private:
	InstanceCounted(const InstanceCounted<T*>&);
	InstanceCounted& operator=(const InstanceCounted&);

	T* const m_pT;
	unsigned m_instCount;
};

template<typename T>
class SmartPtr
{
	SmartPtr();
	SmartPtr(const SmartPtr<T>&);
};

template<typename T>
class SmartPtr<T*>
{
public:
	explicit SmartPtr(T* pT)
	{
		m_pInstCounted = new InstanceCounted<T*>(pT);
	}

	explicit SmartPtr(const SmartPtr<T*>& rhs)
	{
		m_pInstCounted = rhs.m_pInstCounted;
		m_pInstCounted->Increment();
	}

	~SmartPtr()
	{
		m_pInstCounted->Decrement();
		if(m_pInstCounted->GetCount() == 0)
		{
			delete m_pInstCounted;
		}
	}

	SmartPtr<T*>& operator=(const SmartPtr<T*>& rhs)
	{
		if(&rhs != this)
		{
			m_pInstCounted->Decrement();
			if(m_pInstCounted->GetCount() == 0)
			{
				delete m_pInstCounted;
			}

			m_pInstCounted = rhs.m_pInstCounted;
			m_pInstCounted->Increment();
		}

		return *this;
	}

	bool operator==(const SmartPtr<T*>& rhs)
	{
		return m_pInstCounted->GetPtr() == rhs.m_pInstCounted->GetPtr();
	}

	bool operator!=(const SmartPtr<T*>& rhs)
	{
		return m_pInstCounted->GetPtr() != rhs.m_pInstCounted->GetPtr();
	}

	T* operator->()
	{
		assert(m_pInstCounted != null);
		return m_pInstCounted->GetPtr();
	}

	const T* operator->() const
	{
		assert(m_pInstCounted != null);
		return m_pInstCounted->GetPtr();
	}

	unsigned GetCount()
	{ return m_pInstCounted->GetCount(); }

private:
	InstanceCounted<T*>* m_pInstCounted;
};

#endif //SMARTPOINTERS_H

Quote:Original post by Rydinare
Sorry for stating the obvious, but why not use boost::shared_ptr<>?

Quote:Original post by impulsionaudio

Quote:Original post by Rydinare
Sorry for stating the obvious, but why not use boost::shared_ptr<>?

Practice, mostly. I figured it would be a relatively small amount of code that could be written relatively quickly. boost::shared_ptr is probably better, but then I don't get the practice.

Quote:Original post by impulsionaudio

I would like to hide the InstanceCounted class from the outside world but the only way I can think of is to make all of its methods private and make SmartPtr a friend but then if I write another SmartPtr class the new one will have to be added also.

class SmartPtr {  struct InstanceCounted {};};