Re: Overloading operator delete problem

Jens Theisen wrote:


So the compiler knows to call it if the constructor of a
nothrow new exits by an exception.

The problem is simple. Suppose I write something like:

    MyClass* p = new MyClass ;

and the constructor of MyClass throws an exception. The memory
for MyClass has already been allocated (by the function `operator
new( size_t )'), but the user code has no pointer to it. So it
is up to the compiler to clean it up, by calling `operator
delete( void* )'.

Now consider what happens in the case of placement new. The
most common placement new (the only standard one in
pre-exception days) is new(void*), which is used to explicitly
call the constructor, without allocating memory. (Formally, it
"allocates" by calling the allocator function `operator new(
size_t, void* p )', which does nothing but return p.) Something
like:

    // With suitable precautions for alignment...
    char buffer[ size ] ;
    new ( buffer ) MyClass ;

Again, what happens if the constructor of MyClass throws?
Calling `operator delete( void* )' with the address (buffer) is
obviously not a very good idea.

The first proposal was to call operator delete() for
non-placement new, and nothing for placement new. But there are
many forms of placement new---the user can define just about
anything he wants. And some of them, like new(nothrow) DO
require delete to be called.

The result was the introduction of the placement delete
functions. They cannot be invoked from a delete expression;
they can be invoke by means of `operator delete(...)', but
that's obviously not the intent. They will be invoked if the
constructor in a placement new fails, however; their presence or
absence determines whether the compiler invokes an operator
delete function or not in placement new. And since in a
new(nothrow), we definitely have to invoke a delete if the
constructor fails, there is an operator delete(void*, nothrow)
function.

Similarly: if the operator new() function being used is declared
throw(), the compiler assumes that it reports a lack of memory
by returning a null pointer, and tests for null before calling
the constructor; if the operator new() function can raise an
exception, the compiler supposes that it will never return null.

You might want to try the following program; it should show the
behavior fairly well:

    #include <iostream>
    #include <ostream>
    #include <memory>
    #include <stdlib.h>

    #define PASTE(a,b) a ## b
    #define UNIQ(a) PASTE(a,__LINE__)
    #define TRACE( fn ) \
        do { \
            static bool UNIQ(nested) = false ; \
            if ( ! UNIQ(nested) ) { \
                UNIQ(nested) = true ; \
                std::cout << fn << std::endl ; \
                UNIQ(nested) = false ; \
            } \
        } while ( false )

    void*
    operator new( size_t n ) throw( std::bad_alloc )
    {
        TRACE( "new()" ) ;
        void* result = malloc( n ) ;
        if ( result == NULL ) {
            throw std::bad_alloc() ;
        }
        return result ;
    }

    void
    operator delete( void* p ) throw()
    {
        TRACE( "delete()" ) ;
        free( p ) ;
    }

    void*
    operator new( size_t n, std::nothrow_t const& ) throw()
    {
        TRACE( "new(nothrow)" ) ;
        return malloc( n ) ;
    }

    void
    operator delete( void* p, std::nothrow_t const& ) throw()
    {
        TRACE( "delete(nothrow)" ) ;
        free( p ) ;
    }

    void*
    operator new( size_t n, double ) throw()
    {
        TRACE( "new(double)" ) ;
        return malloc( n ) ;
    }

    struct MyClass
    {
        MyClass( bool b ) { if ( b ) throw 42 ; }
    } ;

    template< typename T >
    void
    test( T placement )
    {
        MyClass* p = new( placement ) MyClass( false ) ;
        delete p ;
        try {
            p = new( placement ) MyClass( true ) ;
            delete p ;
        } catch ( ... ) {
        }
    }

    void
    test()
    {
        MyClass* p = new MyClass( false ) ;
        delete p ;
        try {
            p = new MyClass( true ) ;
            delete p ;
        } catch ( ... ) {
        }
    }

    int
    main()
    {
        test() ;
        test( std::nothrow ) ;
        test( 3.14159 ) ;
    }

You'll notice that in the case of new(double), it leaks memory
when MyClass::MyClass() throws. If the pointer returned from
new(double) didn't actually allocate memory, this would be a
feature, and not a defect.

Also note that because the non-placement delete is called for
normal deletes, if you provide a special placement new of your
own, you also have to replace the non-placement operator delete,
AND the non-placement operator new, ensuring that in all of the
operator new's, you do something so that the non-placement
operator delete can tell how to dispose of the memory.

--
James Kanze GABI Software
Conseils en informatique orient?e objet/
                   Beratung in objektorientierter Datenverarbeitung
9 place S?mard, 78210 St.-Cyr-l'?cole, France, +33 (0)1 30 23 00 34

      [ See http://www.gotw.ca/resources/clcm.htm for info about ]
      [ comp.lang.c++.moderated. First time posters: Do this! ]