operator new (<new>)

Artikel
07/13/2016

Veröffentlicht: Juli 2016

Die Funktion, die durch einen neuen Ausdruck aufgerufen wurde, um Speicher für einzelne Objekte zuzuweisen.

Syntax

      void* operator new(
   std::size_t _Count
) throw(bad_alloc);
void* operator new(
   std::size_t _Count,        
   const std::nothrow_t&
) throw( );
void* operator new(
   std::size_t _Count, 
   void* _Ptr
) throw( );

Parameter

_Count
Die zuzuordnende Speichermenge in Byte.
_Ptr
Der zurückgegeben werden Zeiger.

Rückgabewert

Ein Zeiger auf die niedrigste Byteadresse des neu zugeordneten Speichers. Oder _Ptr.

Hinweise

Die erste Funktion wird mit einem neuen Ausdruck aufgerufen, um _Count Bytes Speicherplatz zuzuordnen entsprechend ausgerichtet, um jedes Objekt dieser Größe darzustellen. Das Programm kann eine alternative Funktion mit dieser Funktionssignatur, definieren, die die Standardversion ersetzt, die von der C++-Standardbibliothek definiert ist und deshalb ist austauschbar.

Das erforderliche Verhalten ist, einen Nicht-NULL-Zeiger zurückzugeben, wenn Speicher zugewiesen werden kann, z angefordert worden. Jede dieser Zuordnung wird ein Zeiger auf Speicher, der von jedem anderen zugeordneten Speicher disjunkt ist. Die Reihenfolge und die Kontiguität des Speichers zugeordnet durch aufeinander folgende Aufrufe ist nicht angegeben. Die ursprüngliche gespeicherte Wert ist nicht angegeben. Der zurückgegebene Zeiger zeigt auf den Start (niedrigste Byteadresse) des zugeordneten Speicher. Wenn Anzahl ist, vergleicht der Wert, der zurückgegeben wird, nicht gleich einen anderen Wert, der von der Funktion zurückgegeben.

Das Standardverhalten ist, eine Schleife ausgeführt. Innerhalb der Schleife versucht die Funktion zuerst, dem angeforderten Speicher zuzuordnen. Ob der Test einschließt, ist ein Aufruf von malloc(size_t) nicht angegeben. Wenn der Test erfolgreich ist, gibt die Funktion ein Zeiger auf den zugeordneten Speicher zurück. Andernfalls die Funktionsaufrufe festgelegte neuen Handler. Wenn die aufgerufene Funktion zurückkehrt, die Schleifenwiederholungen. Die Schleife beendet wird, wenn versucht, dem angeforderten Speicher zuzuordnen erfolgreich ist, oder wenn eine aufgerufene Funktion nicht beendet wird.

Das erforderliche neuen Verhalten eines Handlers ist, einen der folgenden Vorgänge auszuführen:

Stellen Sie Speicher mehr für Zuordnungs- bereit und kehren Sie dann zurück.
Rufen Sie entweder abort oder exit auf (int).
Lösen Sie ein Objekt des Typs bad_alloc. aus

Das Standardverhalten von neuen Handler handelt, ein Objekt des Typs bad_alloc auslösen. Ein NULL-Zeiger wird der Standard neuen Handler fest.

Die Reihenfolge und die Kontiguität des Speichers zugeordnet durch aufeinander folgende Aufrufe operator new(size_t) ist nicht angegeben, wie die Anfangswerte, die dort gespeichert werden.

Die zweite Funktion wird mit einem neuen Ausdruck der Platzierung aufgerufen, um _Count Bytes Speicherplatz zuzuordnen entsprechend ausgerichtet, um jedes Objekt dieser Größe darzustellen. Das Programm kann eine alternative Funktion mit dieser Funktionssignatur, definieren, die die Standardversion ersetzt, die von der C++-Standardbibliothek definiert ist und deshalb ist austauschbar.

Das Standardverhalten besteht darin, operator new(_Count) zurückgibt wenn diese Funktion. Andernfalls gibt es einem NULL-Zeiger zurück.

Die dritte Funktion wird über einen Ausdruck, Platzierungs neu des Formulars neu (args T) bezeichnet. Hier args besteht aus einem einzelnen Objektzeiger. Dies kann zum Erstellen eines Objekts mit einer bekannten Adresse hilfreich sein. Die Funktion gibt _Ptr zurück.

Wenn Speicher freien zugeordnet durch operator new, rufen Sie Operator.

Informationen zum auslösendes oder nonthrowing Verhalten von neuem, finden Sie unter Das neue und die Operatoren.

Beispiel

// new_op_new.cpp
// compile with: /EHsc
#include<new>
#include<iostream>

using namespace std;

class MyClass 
{
public: 
   MyClass( )
   {
      cout << "Construction MyClass." << this << endl;
   };

   ~MyClass( )
   {
      imember = 0; cout << "Destructing MyClass." << this << endl;
   };
   int imember;
};

int main( ) 
{
   // The first form of new delete
   MyClass* fPtr = new MyClass;
   delete fPtr;

   // The second form of new delete
   MyClass* fPtr2 = new( nothrow ) MyClass;
   delete fPtr2;

   // The third form of new delete
   char x[sizeof( MyClass )];
   MyClass* fPtr3 = new( &x[0] ) MyClass;
   fPtr3 -> ~MyClass();
   cout << "The address of x[0] is : " << ( void* )&x[0] << endl;
}

Beispiels-Ausgabe

Construction MyClass.000B3F30
Destructing MyClass.000B3F30
Construction MyClass.000B3F30
Destructing MyClass.000B3F30
Construction MyClass.0023FC60
Destructing MyClass.0023FC60
The address of x[0] is : 0023FC60

Anforderungen

Header: <neu>

Namespace: std

Siehe auch

new Operator (STL-Beispiele)
nothrow_t-Struktur
operator delete (<new>)

Freigeben über