Thread: Base container class question

I made this container, and it seems to work, but I may be missing something.

I was wondering if you all could critique it, and let me know what you think.

All input is greatly appreciated.

Code:

#pragma once
#include "VariaMacros.h"
#include "cSingletonBase.h"

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

template <typename T>
class cMapBase : public cSingletonBase<cMapBase<T> >
{
	EnableSingleton(cMapBase);
	DisableClassCopying(cMapBase);
private:
	cMapBase():m_CurIndex(0){};
	virtual ~cMapBase(){Clear();};

	mutable std::map<unsigned long, T*> m_Map;
	mutable std::list<unsigned long> m_Indices;
	mutable unsigned long m_CurIndex;

	virtual bool _Free(T*& p_Element) const
	{
		if ( !p_Element )
			return false;
		else
		{
			delete p_Element;
			p_Element = 0;
			return true;
		}
	}

	unsigned long _GetIndex() const
	{
		if ( m_Indices.empty() )
		{
			++m_CurIndex;
			return m_CurIndex;
		}
		unsigned long Index = m_Indices.back();
		m_Indices.pop_back();
		return Index;
	}
public:
	/*
		This should add a element, and return its index
			- All things that are to be placed in this container have to have a copy constructor(unless unsafe_add is used)
	*/
	virtual unsigned long Add(const T& p_NewElement) const
	{
		T* temp = new T(p_NewElement);
		unsigned long Index = _GetIndex();
		if ( m_Map.find(Index) != m_Map.end() )
		{
			_Free(temp);
			return 0;
		}
		else
			m_Map[Index] = temp;
		return Index;
	}

	/*
		This should add an element, and return its index
			- This is a unsafe function, and has such warning attached. This function can produce memory leaks if used
			incorrectly.
	*/
#ifndef CCONTAINER_NO_WARNINGS
	virtual unsigned long UNSAFE(cMapBase<T>::Add(const T&)) 
		Add(T* p_NewElement) const
#else
	virtual unsigned long
		Add(T* p_NewElement) const
#endif
	{
		unsigned long Index = _GetIndex();
		if ( m_Map.find(Index) != m_Map.end() )
		{
			return 0;
		}
		else
			m_Map[Index] = p_NewElement;
		return Index;
	}

	/*
		This should remove an element at the given index.
	*/
	virtual bool Remove(int p_Index) const
	{
		std::map<unsigned long, T*>::iterator find_iter = m_Map.find(p_Index);
		if ( find_iter == m_Map.end() )
			return false;
		else
		{
			m_Indices.push_back(p_Index);
			return _Free(m_Map[p_Index]);
		}
	}

	/*
		This should delete(free memory) of all elements.
	*/
	virtual void Clear() const
	{
		std::map<unsigned long, T*>::iterator free_iter = m_Map.begin();
		for ( /**/; free_iter != m_Map.end(); ++free_iter )
		{
			_Free((*free_iter).second);
		}
		m_Indices.clear();
		m_Map.clear();
		m_CurIndex = 0;
	}

	/*
		These should access the element at given index.
	*/
	virtual T* operator[](unsigned long p_Index) const
	{
		std::map<unsigned long, T*>::iterator find_iter = m_Map.find(p_Index);

		try
		{
			if ( find_iter == m_Map.end() )
			{
				throw (std::string("Bad index provided. cContainerBase<")+std::string(typeid(T).name())+std::string(">::operator[](unsigned long)"));
			}
		}
		catch(const std::string& str)
		{
			std::cout << "\n" << str << "\n";
			return NULL;
		}
		return (*find_iter).second;
	}
};

This is the cSingletonBase class as well

Code:

#pragma once
#include "VariaMacros.h"

template< class T >
class cSingletonBase
{
public:
    static T* Create()
    {
        if ( m_Singleton )
        {
            ++m_RefCount;
            return m_Singleton;
        }
        m_RefCount = 1;
        m_Singleton = new T;
        return m_Singleton;
    }

    static bool Free()
    {
        if ( m_Singleton )
        {
            //Bad ref count check
            if ( m_RefCount <= 0 )
                _asm int 3

            --m_RefCount;
            if ( !m_RefCount )
            {
                delete m_Singleton; m_Singleton = 0;
                return true;
            }
            return false;
        }
        return true;
    }
protected:
    cSingletonBase()
    { }
    virtual ~cSingletonBase()
    { }

private:
    DisableClassCopying(cSingletonBase);

    static T* m_Singleton;
    static unsigned int m_RefCount;
};

template< class T > T* cSingletonBase< T >::m_Singleton = 0;
template< class T > unsigned int cSingletonBase< T >::m_RefCount = 0;