Partager via


new[], opérateur (<new>)

La fonction d'allocation appelée par une nouvelle expression pour allouer la mémoire pour un tableau d'objets.

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( );

Paramètres

  • _Count
    Nombre d'octets de mémoire à allouer pour l'objet table.

  • _Ptr
    Le pointeur à retourner.

Valeur de retour

Un pointeur vers l'adresse ayant le moins d'octets de la mémoire nouvellement allouée. Ou _Ptr.

Notes

La première fonction est appelée par une expression d'new[] pour allouer des octets d'_Count de stockage correctement alignés pour représenter un objet table de cette taille ou plus petit. Le programme peut définir une fonction avec cette signature de fonction qui remplace la version par défaut définie par la bibliothèque C++ standard. Le comportement nécessaire est identique à opérateur nouveau(size_t). Le comportement par défaut consiste à retourner operator new(_Count).

La deuxième fonction est appelée par une expression d'new[] de placement pour allouer des octets d'_Count de stockage correctement alignés pour représenter un objet table de cette taille. Le programme peut définir une fonction avec cette signature de fonction qui remplace la version par défaut définie par la bibliothèque C++ standard. Le comportement par défaut consiste à retourner opérateur new(_Count) si la fonction réussit. Sinon, elle retourne un pointeur null.

La troisième fonction est appelée par une expression d'new[] de placement, au format new (arguments) T[N]. Ici, les arguments est constitué d'un seul pointeur de l'objet. La fonction retourne _Ptr.

À l'espace de stockage alloué gratuitement par operator new[], appelez suppression d'opérateur [].

Pour plus d'informations sur le comportement en levant ou nonthrowing de nouveau, consultez l'Le nouveau et des opérateurs.

Exemple

// 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;
}

Résultat de l'exemple

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

Configuration requise

En-tête : <nouveau>

Espace de noms : std

Voir aussi

Référence

nothrow_t, structure

delete[], opérateur (<new>)