Re: Exception in Constructor

On 16.09.2012 09:45, Henry wrote:


Yes, but at the same time, it *is* a little bit incorrect -- as is
necessarily any condensation of the standard's rules.


The quote from the FAQ refers to the action of a `new` expression.

When the specified constructor throws, then if there is a deallocation
function (operator delete) D corresponding to the allocation function
(operator new) A that was used, then D is used to deallocate the
memory allocated by A. This does not do anything about memory
allocated by the constructor code, but if that was cleaned up
properly, then this final cleanup ensures that the `new` expression
works like a database "transaction". I.e. it's ALL OR NOTHING: either
you get a fresh new successfully initialized object, or (disregarding
time) no side-effect.

<example>
#include <iostream> // std::wcout, std::endl
#include <stddef.h> // size_t

void say( char const s[] ) { std::wcout << s << std::endl; }

enum Action { fail, succeed };

class Blah
{
private:
      Blah( Blah const& ); // No such.

public:
      void operator delete( void* p )
      {
          say( "Deallocated!" );
          ::operator delete( p );
      }

      void* operator new( size_t const nBytes )
      {
          say( "Allocated!" );
          return ::operator new( nBytes );
      }

      ~Blah()
      {
          say( "Blah::<destroy>()" );
      }

      Blah( Action const action = succeed )
      {
          say( "Blah::<init>()" );
          if( action == fail ) { throw 666; }
      }
};

void test( Action const action, char const* const legend )
{
      try
      {
          say( legend );
          Blah const* const p = new Blah( action );
          say( "Explicitly invoking delete..." );
          delete p;
      }
      catch( ... )
      {
          say( "!Oops, an exception!" );
      }
      say( "" );
}

int main()
{
      test( succeed, "With successful construction:" );
      test( fail, "With failed construction:" );
}
</example>

<output>
With successful construction:
Allocated!
Blah::<init>()
Explicitly invoking delete...
Blah::<destroy>()
Deallocated!

With failed construction:
Allocated!
Blah::<init>()
Deallocated!
!Oops, an exception!
</output>

Salient points:

* For the exception case, everything is cleaned up, *if* the custom
    code does its own cleanup correctly (there's no magic).

* The exception, if any, is passed on upwards from the new expression
    (after cleanup).

* Destructors are only invoked for completely constructed objects
    (including completely constructed sub-objects).

The reason that the FAQ quote is a little bit incorrect is that this
automatic cleanup depends on the existence of a corresponding
deallocation function D. If you override (replace) the allocation
function for a class with one that has custom arguments, and you do
not provide a corresponding override of the deallocation function,
then the automatic cleanup does not deallocate. In this case you may
have memory leaks when constructors fail (it was once an infamous bug
in Microsoft's MFC, ironically only manifesting itself in debug
builds...).

Cheers & hth.,

- Alf

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