🚀 go-pugleaf

Some current compilers allocate memory for heap objects from inside
the constructor code.  This isn't great when exceptions can be thrown
and indeed generated code from compilers that support exception handling
seems to abandon the idea.

Does the standard say anything about how memory should be allocated?
My question is motivated by the following simple program which exhibits
different behavior when exception handling is enabled compared to when
it isn't.  Would such behavior be accptable inder the provisions of the
standard?

// -----------------------------------------------------------------

#include <stddef.h>

struct Y
{
  Y() {}
  void* allocate() { return 0; }
};

struct X
{
   X() {}
   void* operator new( size_t ) { return (void*)42; }
   void* operator new( size_t , Y& alloc ) { return alloc.allocate(); }
   void  operator delete( void* ) {}
   //void operator delete( size_t , Y& ); // not yet supported by my compiler
};


#include <iostream.h>

main()
{
  Y y;
  X* ptr = new(y) X;
  cout << "ptr == " << (int)ptr << "\n";
}

The output is 0 when exception handling is enabled and 42 when it isn't.


-- 
John Hickin      Bell-Northern Research, Montreal, Quebec
(514) 765-7924   hickin@bnr.ca
---
[ comp.std.c++ is moderated.  Submission address: std-c++@ncar.ucar.edu.
  Contact address: std-c++-request@ncar.ucar.edu.  The moderation policy
  is summarized in http://dogbert.lbl.gov/~matt/std-c++/policy.html. ]