Thread: Rewrote my cMap class. Looking for more criticism

Okay so I rewrote my map class, and changed pretty much everything.

What I fixed (I think)-

• I added memory recording. Probably not accurate, but I don't know how else to do it.
• Removed a lot of unnecessary searching, thus saving a lot of time I think.
• Added functionality for copying.
• Added better exception. using std::runtime_error

Well, here it is. I am hoping you all can point out mistakes, or better ways of doing something.
Although not really looking for people to tell me it doesn't work like an associative array, as I already know that ( just do not have a better name for the class )

Code:

#pragma once

#include <map>
#include <list>
#include <string>
#include <stdexcept>

template <class T>
class cMap
{
private:
	/* Index management */
	size_t m_iCurIndex;
	std::list<size_t> m_cList;

	/* Memory Recording */
	size_t m_iMemUsage;
	bool   m_fRecordMemory;


	std::map<size_t, T*> m_cMap;

	size_t _GetIndex()
	{
		if ( !m_cList.empty() )
		{
			size_t iIndex = m_cList.back();
			m_cList.pop_back();
			return iIndex;
		}
		++m_iCurIndex;
		return m_iCurIndex;
	}

	void _Copy(const cMap& p_cCopy)
	{
		//Make sure the map is empty first
		Clear();
		//Now copy all indices, and pointers
		typename std::map<size_t, T*>::const_iterator iter = p_cCopy.m_cMap.begin();
		for (/**/; iter != p_cCopy.m_cMap.end(); ++iter )
		{
			m_cMap[(*iter).first] = new T(*(*iter).second);
		}
		//Copy index list
		m_cList = p_cCopy.m_cList;

		//Copy variable values
		m_iCurIndex = p_cCopy.m_iCurIndex ;
		m_iMemUsage = p_cCopy.m_iMemUsage;
		m_fRecordMemory = p_cCopy.m_fRecordMemory;
	}

public:
	explicit cMap()
		:m_iCurIndex(0), m_iMemUsage(0),m_fRecordMemory(true)
	{ }
	~cMap()
	{
		Clear();
	}

	/* Copying */
	explicit cMap(const cMap& p_cCopy)
	{
		_Copy(p_cCopy);
	}
	const cMap& operator=(const cMap& p_cCopy)
	{
		_Copy(p_cCopy);
		return *this;
	}

	/* Memory Recording */
	void SetMemRec(bool p_fValue) { m_fRecordMemory = p_fValue; }
	bool GetMemRec() const		  { return m_fRecordMemory; }
	int  GetMemUsage() const      { return m_iMemUsage;}


	size_t Push(const T& p_cCopy)
	{
		size_t iIndex = _GetIndex();
		m_cMap[iIndex] = new T(p_cCopy);

		/* Manage memory */
		if ( m_fRecordMemory )
		{
			m_iMemUsage += sizeof(T);
		}
		return iIndex;
	}

	void Remove(size_t p_iIndex) throw(...)
	{
		typename std::map<size_t,T*>::iterator iter = m_cMap.find(p_iIndex);
		if ( iter == m_cMap.end() )
		{
			throw std::runtime_error("Invalid index was provided to cMap<T*>::Remove(size_t)");
		}
		delete (*iter).second; (*iter).second = 0;
		m_cList.push_back(p_iIndex);
		m_cMap.erase(iter);

		/* Manage memory */
		if ( m_fRecordMemory )
		{
			m_iMemUsage -= sizeof(T);
		}
	}

	void Clear()
	{
		typename std::map<size_t,T*>::iterator iter = m_cMap.begin();
		for(/**/; iter != m_cMap.end(); ++iter )
		{
			delete (*iter).second; (*iter).second = 0;
		}
		m_iMemUsage = 0;
		m_iCurIndex = 0;
		m_cMap.clear();
	}

	T& operator[](size_t p_iIndex) 
	{
		if ( m_cMap.find(p_iIndex) == m_cMap.end() )
		{
			throw std::runtime_error("Invalid index was provided to cMap<T*>::operator[](size_t)");
		}
		return *m_cMap[p_iIndex];
	}

	const T& operator[](size_t p_iIndex) const
	{
		if ( m_cMap.find(p_iIndex) == m_cMap.end() )
		{
			throw std::runtime_error("Invalid index was provided to cMap<T*>::operator[](size_t)");
		}
		return *m_cMap[p_iIndex];
	}
};

Thank you for any input you have.