Code-Schnipsel: Placement New()

[Xin]

Hier mal etwas Beispielcode, den ich grade mal testweise zum Thema Placement New geschrieben habe.

Das Programm erzeugt eine Instanz der Klasse A in einem bereits bestehenden Speicherbereich, benutzt es und baut das Objekt anschließend wieder ab.
Als Hinweis: Grundsätzlich sollte auch Placement-Delete implementiert werden ( operator delete( void *, void * ) ), um Fehlern zu begegnen, die durch eine Exception im Konstruktor entstehen.

Code: Alles auswählen

#include <stdio.h>
#include <new>

char Buffer[ 5000 ];

class A
{
  int const a;

public:
  A( int value ) : a( value ) 
  { 
    printf( "Constructing at %x\n", (int) this ); 
  }
  ~A() 
  { 
    printf( "Destructing at %x\n", (int) this ); 
  }

  void Output()
  {
    printf( "Value is %d\n", a ); 
  }
};

int main( void )
{
  printf( "Buffer is at %x\n", (int) Buffer );

  A * temp = new (Buffer) A(1);

  temp->Output();

  temp->~A();

  return 0;
}

[Kerli]

Dazu passend hätte ich auch noch ein Codeschnipsel aus einem Projekt von mir, das einen Allocator (den aus der Standardbibliothek) verwendet:

Code: Alles auswählen

pointer
_getNode()
{ return _allocator.allocate(1); }

void
_putNode(pointer node)
{ return _allocator.deallocate(node, 1); }

_Node*
_createNode( const value_type& x )
{
  _Node* p = _getNode();
  try
  {
    _Tp_alloc_type(_allocator).construct(&p->_data, x);
  }
  catch(...)
  {
    _putNode(p);
    throw;
  }
  return p;
}

void _eraseNode( iterator pos )
{
  _Node *p = static_cast<_Node*>(pos._node);
  _allocator.destroy( &p->_data );
  _putNode(p);
}

Der Code wird natürlich nicht kompilieren, da einige Definitionen fehlen. Die muss man aber selbst je nach Gegebenheit definieren. Wichtig ist nur das _allocator ein Objekt vom Typ std::allocator<_Tp> ist. _Tp ist dann vom entsprechenden Typ. Placement new und delete werden dann indirekt über allocator.construct() bzw. allocator.destruct() aufgerufen.

[fat-lobyte]

Interessant, hab auch erst gestern ganz erstaunt vom Placement new gelesen, und zwar hier: http://www.open-std.org/jtc1/sc22/wg21/ ... n2648.html

Ich finde den Default-Konstruktor ziemlich interessant. Er fängt exceptions auf und löscht alle bisher initialisierten werte:

Code: Alles auswählen

    explicit dynarray(size_type c)
        : store( alloc( c ) ), count( c )
        { size_type i;
          try {
              for ( size_type i = 0; i < count; ++i )
                  new (store+i) T;
          } catch ( ... ) {
              for ( ; i > 0; --i )
                 (store+(i-1))->~T();
              throw;
          } }