What is the correct way to instantiate an object with an allocator?

Question

I have implemented a custom allocator (to be used by STL containers within my memory debugging utility, without them using my overridden new operator). Within the memory debugger I use an instance of the same allocator class to allocate the objects I need to keep track of 'normal' memory allocations. It's all working fine, but I'm not sure if the way I'm using the allocator interface is correct. Here are the utility methods as they currently stand (correct initialization parameters for the entry will be added soon):

iidebug::CMemoryDebugger::CEntry* iidebug::CMemoryDebugger::NewEntry()
{
    CEntry* pEntry = m_entryAllocator.allocate(1);
    if (0 != pEntry)
    {
     new(pEntry) CEntry(0, 0, __FILE__, 0, 0, 0);
    }
    return pEntry;
}

void iidebug::CMemoryDebugger::DeleteEntry( iidebug::CMemoryDebugger::CEntry* pEntry )
{
    if (0 != pEntry)
    {
     destruct(pEntry);
     m_entryAllocator.deallocate(pEntry, 1);
    }
}

This just seems very messy, but I can't see how I can improve it.

Answer 1

What is destruct? I suppose it should be:

void iidebug::CMemoryDebugger::DeleteEntry( iidebug::CMemoryDebugger::CEntry* pEntry )
{
    if (0 != pEntry)
    {
        pEntry->~CEntry();
        m_entryAllocator.deallocate(pEntry, 1);
    }
}

Answer 2

You can actually overload new and delete to take an allocator parameter, like so:

inline void *operator new(size_t sizeT, Allocator *&a) {
  return a->allocate(sizeT);
}

inline void operator delete(void * mem, Allocator *&a) {
  a->release(mem);
}

int main()
{
  Allocator * a = new Allocator;
  C *c = new(a) C;
  c->~C();
  operator delete(c, a);
  return 0;
}

See the wikipedia article for more detail. It's still a bit messy because you have to be sure not to call the regular delete operator if your allocator does something special.

Answer 3

Just for reference in case anyone struggles to use Drew's code, it needed a few tweaks. The following is what I ended up using:

template <typename T>
void* operator new(SizeT iSize, SimpleAllocator<T>& rAllocator)
{
    return rAllocator.allocate(1);
}

template <typename T>
void operator delete(void* pvMemory, SimpleAllocator<T>& rAllocator)
{
    ((T*)pvMemory)->~T();   
    rAllocator.deallocate(pvMemory, 1);
}

And actually using it is as simple as:

// SimpleAllocator<CFoo> fooAllocator = ...
CFoo* pFoo = new(fooAllocator) CFoo(param1, param2, ...); 
// Do stuff with pFoo...
operator delete(pFoo, fooAllocator);