Freigeben über


operator new (<new>)

Die Zuornungsanzahl-Funktion aufgerufen durch einen neuen Ausdruck, um Speicher für ein Array von Objekten zuzuordnen.

void *operator new[](
   std::size_t _Count
)
   throw(std::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 Anzahl der Bytes für das Arrayobjekt zugeordnet werden, Speicher.

  • _Ptr
    Der Zeiger zurückgegeben werden.

Rückgabewert

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

Hinweise

Die erste Funktion wird durch einen Ausdruck new[] aufgerufen, um _Count Bytes Speicher zuzuordnen entsprechend ausgerichtet, um jedes Arrayobjekt dieser Größe darzustellen oder kleiner.Das Programm kann eine Funktion mit dieser Funktionssignatur definieren, die die Standardversion ersetzt, die durch die C++-Standardbibliothek definiert ist.Das erforderliche Verhalten entspricht für Operator neu(size_t).Das Standardverhalten ist, operator new(_Count) zurückzugeben.

Die zweite Funktion wird durch einen new[]-Platzierungsausdruck aufgerufen, um _Count Bytes Speicher zuzuordnen entsprechend ausgerichtet, um jedes Arrayobjekt dieser Größe darzustellen.Das Programm kann eine Funktion mit dieser Funktionssignatur definieren, die die Standardversion ersetzt, die durch die C++-Standardbibliothek definiert ist.Das Standardverhalten ist, Operatornew(_Count) zurückzugeben, wenn diese Funktion folgt.Andernfalls gibt es einen NULL-Zeiger zurück.

Die dritte Funktion wird durch einen new[]-Platzierungsausdruck im Format new (args) T[N] aufgerufen.Hier besteht args aus einem einzelnen Objektzeiger.Die Funktion gibt _Ptr zurück.

So freien Speicher belegt wurde operator new[], Aufruf Operator delete [].

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

Beispiel

// new_op_alloc.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[2];
   delete[ ] fPtr;

   // The second form of new delete
   char x[2 * sizeof( MyClass ) + sizeof(int)];
   
   MyClass* fPtr2 = new( &x[0] ) MyClass[2];
   fPtr2[1].~MyClass();
   fPtr2[0].~MyClass();
   cout << "The address of x[0] is : " << ( void* )&x[0] << endl;

   // The third form of new delete
   MyClass* fPtr3 = new( nothrow ) MyClass[2];
   delete[ ] fPtr3;
}

Beispielausgabe

Construction MyClass.00311AEC
Construction MyClass.00311AF0
Destructing MyClass.00311AF0
Destructing MyClass.00311AEC
Construction MyClass.0012FED4
Construction MyClass.0012FED8
Destructing MyClass.0012FED8
Destructing MyClass.0012FED4
The address of x[0] is : 0012FED0
Construction MyClass.00311AEC
Construction MyClass.00311AF0
Destructing MyClass.00311AF0
Destructing MyClass.00311AEC

Anforderungen

Header: <new>

Namespace: std

Siehe auch

Referenz

nothrow_t Structure

operator delete[] (<new>)