Re: Overriding new and delete

On Aug 9, 4:44 pm, MJ_India <mail.mohitj...@gmail.com> wrote:


It's standard. Theoretically, the steps you may have to take to
replace new and delete may vary; in practice, it's sufficient to
link you versions in before the library.

Replacing global new and delete, or just adding new placement
new and delete (as you're doing) can be tricky. The main
problem is that a delete expression always calls the
non-placement version, do you need to provide the non-placement
version of operator delete. And since this has to work with the
non-placement operator new as well, you have to replace that was
well. And you have to memorize which allocator or memory pool
was used, in order to know which one to use in the delete; the
classical solution for this is to use some sort of hidden
memory for this, e.g.:

    union BlockHeader
    {
        Allocator* allocator ;
        MaxAlignType dummyForAlignment ;
    } ;

    void*
    operator new( size_t n )
    {
        BlockHeader* p = static_cast< BlockHeader* >(
                            malloc( n + sizeo=

        if ( p == NULL ) {
            throw std::bad_alloc ;
        }
        p->allocator = NULL ;
        return p + 1 ;
    }

    void*
    operator new( size_t n, Allocator& alloc )
    {
        BlockHeader* p = static_cast< BlockHeader* >(
                            alloc.allocate( n=

( BlockHeader ) ) ) ;
        if ( p == NULL ) {
            throw std::bad_alloc ;
        }
        p->allocator = &alloc ;
        return p + 1 ;
    }

    void*
    operator delete( void* userPtr )
    {
        BlockHeader* p = static_cast< BlockHeader* >( userPtr )=

        if ( p->allocator == NULL ) {
            free( p ) ;
        } else {
            p->allocator->free( p ) ;
        }
    }

    void*
    operator delete( void* userPtr, Allocator& alloc )
    {
        operator delete( userPtr ) ;
    }

(The last is only used if a constructor in the new expression
throws an exception.)

In general, I would try to avoid this solution. If your modules
have distinct classes, you could try using class specific
operator new and delete. Otherwise, named functions can be
used, e.g.:

    template< typename T >
    T*
    create( Allocator& alloc )
    {
        void* p = alloc.allocate( sizeof( T ) ) ;
        try {
            return ::new ( p ) T ;
        } catch ( ... ) {
            alloc.free( p ) ;
            throw ;
        }
    }

    template< typename T >
    void
    destruct( Allocator& alloc, T* obj )
    {
        obj->~T() ;
        alloc.free( obj ) ;
    }