Session of low-level optimization of memory usage in C++ programs with total exposure

#ifndef CMN_ARENA_ALLOCATORS_H
#define CMN_ARENA_ALLOCATORS_H
#include "cmnArena.h"
#include "assert.h"
namespace utils
{
template<class ObjectType, class ParamType>
struct arena_allocator
{
    DEFINE_TEMPLATE_CONSTRUCTORS(arena_allocator)

    ObjectType * NewChars(size_t count)
    {
       ObjectType * p = (ObjectType *)Arena_Alloc(count);
       if (!p)
          throw std::bad_alloc();
       return p;
    }
    ObjectType * New(size_t count)
    {
       ObjectType * p = (ObjectType *)Arena_Alloc(count * sizeof(ObjectType));
       if (!p)
          throw std::bad_alloc();
       return p;

    }

    void Delete(void * ptr, size_t)
    {
       Arena_Free(ptr);
    }
};


// base class 
template<class ParentType>
class CArenaCore:public ParentType
{
    typedef CArenaCore<ParentType> This_type;
    int m_iCount;

    CArenaCore()
        : m_iCount(1)
    {
    }
    CArenaCore(const CArenaCore&)
    {
    }
    CArenaCore& operator =(const CArenaCore&)
    {
    }
public:
    static This_type * Create()
    {
        This_type * pRes = (This_type * )malloc(sizeof(This_type)); 
        new (pRes) This_type;
        return pRes;
    }
    void AddRef()
    {
        ++m_iCount;
    }
    void Release()
    {
        if (!--m_iCount)
        {
            this->~This_type();
            free(this);
        }
    }
};

template<class ObjectType, class ParamType>
class arena_custom_allocator
{
    typedef arena_custom_allocator<ObjectType, ParamType> This_type;
    typedef CArenaCore<ParamType> ArenaCore_type;
    ArenaCore_type * m_pArenaCore;
public:
    arena_custom_allocator()
    {
        m_pArenaCore = ArenaCore_type::Create();
    }
    arena_custom_allocator(const This_type & another)
    {
        m_pArenaCore = another.m_pArenaCore;
        m_pArenaCore->AddRef();
    }
    arena_custom_allocator & operator = (const This_type & another)
    {
        This_type me(another);
        me.swap(*this);
        return *this;
    }
    ~arena_custom_allocator()
    {
        m_pArenaCore->Release();
    }
    template<class OtherType>
    arena_custom_allocator(const OtherType & another)
    {
        m_pArenaCore = const_cast<ArenaCore_type*>(another.GetArena());
        m_pArenaCore->AddRef();
    }
    template<class OtherType>
    arena_custom_allocator & operator = (const OtherType & another)
    {
        OtherType me(another);
        me.swap(*this);
        return *this;
    }

    template<class OtherType>
    void swap(OtherType & another)
    {
        std::swap(m_pArenaCore, *another.GetArenaPtr()); 
    }
    ObjectType * NewChars(size_t count)
    {
       ObjectType * p = (ObjectType *)m_pArenaCore->Allocate(count);
       return p;
    }
    ObjectType * New(size_t count)
    {
       ObjectType * p = (ObjectType *)m_pArenaCore->Allocate(count * sizeof(ObjectType));
       return p;
    }
    void Delete(void * ptr, size_t)
    {
       m_pArenaCore->Deallocate(ptr);
    }
    ArenaCore_type ** GetArenaPtr()
    {
        return m_pArenaCore;
    }
    ArenaCore_type * GetArena()
    {
        return m_pArenaCore;
    }
    const ArenaCore_type * GetArena() const 
    {
        return m_pArenaCore;
    }
};

}
#endif