Re: inconsistent behavior with user-defined new and delete

From:

Sylvester Hesp <s.hespNO@SPAMoisyn.nl>

Newsgroups:

comp.lang.c++

Date:

Wed, 30 May 2007 16:40:16 +0200

Message-ID:

<mn.f3e87d751e2441d1.75415@SPAMoisyn.nl>

jeffjohnson_alpha@yahoo.com wrote :

We all know that a new-expression,

    foo* a = new foo() ;

allocates memory for a single foo then calls foo::foo(). And we know
that

    void* p = ::operator new(sizeof(foo)) ;

allocates a sizeof(foo)-sized buffer but does NOT call foo::foo().
So only new-expressions both allocate and initialize. Fair enough.

Now suppose we wish to use a custom memory pool,

    my_pool pool ;
    foo* a = new(pool) foo() ;

This calls

    void* operator new( std::size_t size, my_pool & )
                        throw(std::bad_alloc) ;

and then calls foo::foo(). Naturally we also define

    void operator delete( void* data, my_pool & ) throw() ;

But how are we going to call our custom delete?

Not possible using the delete operator. However, do note that a
placement delete counterpart for operator new is needed in the case
that an exception is thrown during object construction, in which case
it is automatically called to clean up the memory.

One workaround is to define operator new() and operator delete()
inside foo, but suppose I can't do that. Another workaround is to use

    template< typename pool_type, typename T >
    void custom_delete( pool_type & pool, T* p )
    {
        p->~T() ;
        pool.deallocate(p, sizeof(T)) ;
    }

Another one is to override the global operator delete, where your
placement new somehow associates the allocator with the allocated chunk
of memory, and the delete fetches the appropriate allocator and uses it
to free the memory.

- Sylvester