Partager via

<new> opérateurs et énumérations

  • Article

enum align_val_t

enum class align_val_t : size_t {};

operator delete

Fonction appelée par une delete expression pour libérer le stockage des objets individuels.

void operator delete(void* ptr) noexcept;
void operator delete(void *, void*) noexcept;
void operator delete(void* ptr, const std::nothrow_t&) noexcept;

Paramètres

ptr
Pointeur dont la valeur doit être rendue non valide par la suppression.

Notes

La première fonction est appelée par une delete expression pour afficher la valeur de ptr non valide. 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 standard C++. Le comportement requis consiste à accepter une valeur de ptr ce qui est nullptr ou qui a été retournée par un appel antérieur à operator new.

Le comportement par défaut d’une nullptr valeur dans ptr est de ne rien faire. Toute autre valeur de ptr doit être une valeur retournée précédemment par un new appel, comme décrit précédemment. Le comportement par défaut d’une valeur non Null consiste ptr à récupérer le stockage alloué par l’appel précédent. Il n’est pas spécifié dans quelles conditions le stockage récupéré ou dans toutes ces conditions est alloué par un appel ultérieur à , ou à operator newl’une des fonctions , mallocou realloc à l’une callocdes fonctions.

La deuxième fonction est appelée par une expression de placement delete correspondant à une new expression du formulaire new( std::size_t ). Elle ne fait rien.

La troisième fonction est appelée par une expression de placement delete correspondant à une new expression du formulaire new( std::size_t, const std::nothrow_t& ). 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 standard C++. Le comportement requis consiste à accepter une valeur de ptr celle-ci nullptr ou qui a été retournée par un appel antérieur à operator new. Le comportement par défaut est d’évaluer delete( ptr ).

Exemple

Consultez operator new un exemple qui utilise operator delete.

operator delete[]

Fonction appelée par une delete expression pour libérer le stockage pour un tableau d’objets.

void operator delete[](void* ptr) noexcept;
void operator delete[](void *, void*) noexcept;
void operator delete[](void* ptr, const std::nothrow_t&) noexcept;

Paramètres

ptr
Pointeur dont la valeur doit être rendue non valide par la suppression.

Notes

La première fonction est appelée par une expression delete[] pour rendre la valeur de ptr non valide. La fonction est remplaçable, car 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 standard C++. Le comportement requis consiste à accepter une valeur de ptr celle-ci nullptr ou qui a été retournée par un appel antérieur à operator new[]. Le comportement par défaut pour une valeur Null de ptr consiste à ne rien faire. Toute autre valeur de ptr doit être une valeur retournée plus tôt par un appel comme décrit précédemment. Le comportement par défaut de cette valeur ptr non null consiste à récupérer le stockage alloué par l’appel précédent. Il n’est pas spécifié dans quelles conditions le stockage récupéré ou dans toutes ces conditions est alloué par un appel ultérieur à , ou à operator newl’une des fonctions , mallocou realloc à l’une callocdes fonctions.

La deuxième fonction est appelée par une expression de placement delete[] correspondant à une new[] expression du formulaire new[]( std::size_t ). Elle ne fait rien.

La troisième fonction est appelée par une expression de placement delete[] correspondant à une new[] expression du formulaire new[]( std::size_t, const std::nothrow_t& ). 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 standard C++. Le comportement requis consiste à accepter une valeur de ptr celle-ci nullptr ou qui a été retournée par un appel antérieur à l’opérateur new[]. Le comportement par défaut est d’évaluer delete[]( ptr ).

Exemple

Pour operator new[] obtenir des exemples d’utilisation de operator delete[].

operator new

Fonction appelée par une expression new pour allouer le stockage pour des objets distincts.

void* operator new(std::size_t count);
void* operator new(std::size_t count, const std::nothrow_t&) noexcept;
void* operator new(std::size_t count, void* ptr) noexcept;

Paramètres

count
Nombre d’octets de stockage à allouer.

ptr
Pointeur à retourner.

Valeur retournée

Pointeur vers l’adresse d’octet la plus basse du stockage nouvellement alloué. Ou ptr, si vous utilisez la troisième forme de la fonction.

Notes

La première fonction est appelée par une new expression pour allouer des count octets de stockage correctement alignés pour représenter n’importe quel objet de cette taille. Cette fonction est remplaçable. Cela signifie que le programme peut définir une autre fonction avec cette signature de fonction qui remplace la version par défaut définie par la bibliothèque standard C++.

Le comportement requis consiste à retourner un pointeur non Null uniquement si le stockage peut être alloué comme demandé. Chaque allocation génère un pointeur vers du stockage disjoint de tout autre stockage alloué. L’ordre et la contiguïté du stockage alloué par les appels successifs ne sont pas spécifiés. La valeur stockée initiale n’est pas spécifiée. Le pointeur retourné pointe vers le début (l’adresse d’octet la plus basse) du stockage alloué. Si count elle est égale à zéro, la valeur retournée ne correspond à aucune autre valeur retournée par la fonction.

Le comportement par défaut consiste à exécuter une boucle. Dans la boucle, la fonction tente d’abord d’allouer le stockage demandé. Indique si la tentative implique un appel à n’est malloc pas spécifié. Si la tentative d’allocation réussit, la fonction retourne un pointeur vers le stockage alloué. Sinon, la fonction appelle la fonction désignée de type new_handler. Si la fonction appelée retourne, la boucle se répète. La boucle se termine lorsqu’une tentative d’allocation du stockage demandé réussit ou lorsqu’une fonction appelée ne retourne pas.

Le comportement requis d’une fonction de type new_handler consiste à effectuer l’une des opérations suivantes :

  • Rendre plus de stockage disponible pour l’allocation, puis retourner.

  • Appelez l’une ou l’autre abort ou exit.

  • Lève un objet de type bad_alloc.

Le comportement par défaut d’une new_handler fonction consiste à lever un objet de type bad_alloc. Une nullptr valeur désigne la fonction par défaut new_handler .

L’ordre et la contiguïté du stockage alloués par les appels successifs à ne operator new sont pas spécifiés, comme les valeurs initiales stockées ici.

Pour libérer le stockage alloué par la première forme de operator new, appelez operator delete.

La deuxième fonction est appelée par une expression de placement new pour allouer des count octets de stockage correctement alignés pour représenter n’importe quel objet de cette taille. Cette fonction est remplaçable. Cela signifie que le programme peut définir une autre fonction avec cette signature de fonction qui remplace la version par défaut définie par la bibliothèque standard C++.

Le comportement par défaut consiste à retourner operator new( count ) si cette fonction réussit. Sinon, nullptrest retourné.

Pour libérer le stockage alloué par la deuxième forme de operator new (autrement dit, s’il n’a pas retourné nullptr), appelez operator delete.

La troisième fonction est appelée par une expression de placement new non alloué, de la forme new ( ptr ) T. Ici, ptr se compose d’un pointeur d’objet unique. Il peut être utile de construire un objet à une adresse connue. La fonction retourne ptr. Vous devez appeler explicitement le destructeur sur cet objet.

Si vous appelez un placement newsans allocation, n’appelez deletepas . Au lieu de cela, appelez le deallocator pour la mémoire que vous avez fournie, si nécessaire, après avoir appelé le destructeur pour l’objet.

Pour plus d’informations sur le comportement de levée ou de non-levée, newconsultez Les opérateurs et delete les new opérateurs.

Exemple

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

using namespace std;

class MyClass {
    int member{ 0 };
public:
    MyClass() {
        cout << "MyClass at 0x" << this << " constructed.\n";
    };

    ~MyClass() {
        cout << "MyClass at 0x" << this << " destroyed.\n";
    };
};

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

    // The second form (fail returns nullptr) of new / delete
    MyClass* fPtr2 = new(nothrow) MyClass[2];
    if (fPtr2)
        delete fPtr2;

    // The third form (non-allocating placement) of new / delete
    char x[sizeof(MyClass)]; // x is automatic
    MyClass* fPtr3 = new(&x[0]) MyClass;
    fPtr3->~MyClass(); // Requires explicit destructor call
    // no delete because x is on the stack
}

operator new[]

Fonction d’allocation appelée par une expression new pour allouer le stockage pour un tableau d’objets.

void* operator new[](std::size_t count);
void* operator new[](std::size_t count, const std::nothrow_t&) noexcept;
void* operator new[](std::size_t count, void* ptr) noexcept;

Paramètres

count
Nombre d’octets de stockage à allouer pour l’objet tableau.

ptr
Pointeur à retourner.

Valeur retournée

Pointeur vers l’adresse d’octet la plus basse du stockage nouvellement alloué. Ou ptr, lorsque le troisième formulaire est utilisé.

Notes

La première fonction est appelée par une expression new[] pour allouer count octets de stockage alignés correctement pour représenter tout objet de tableau 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 standard C++. Le comportement requis est le même que pour operator new. Le comportement par défaut consiste à retourner operator new( count ) s’il réussit. Sinon, elle lève une std::bad_alloc exception (ou une exception dérivée de std::bad_alloc). Pour libérer le stockage alloué par cette forme de operator new[], appelez operator delete[].

La deuxième fonction est appelée par une expression new[] de positionnement pour allouer count octets de stockage alignés correctement pour représenter tout objet de tableau 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 standard C++. Le comportement par défaut consiste à retourner operator new( count ) si cette fonction réussit. Sinon, nullptrest retourné. Pour libérer le stockage alloué par cette forme de operator new[], appelez operator delete[]. Pour plus d’informations sur le comportement de levée ou de non-levée, newconsultez The new and delete operators.

La troisième fonction est appelée par une expression de placement new[] non alloué, de la forme new( ptr ) T[ N ]. Ce formulaire n’alloue pas de mémoire. Il construit les objets dans la mémoire passée par le ptr paramètre. La fonction retourne ptr. Vous devez appeler explicitement le destructeur pour chaque objet créé. Vous êtes responsable de la fourniture d’une mémoire suffisante pour ptr. N’appelez delete[] pas sur la valeur retournée par l’expression new . Au lieu de cela, libérez ptr, si nécessaire, après avoir appelé les destructeurs.

Exemple

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

using namespace std;

class MyClass {
    int member{ 0 };
public:
    MyClass() {
        cout << "MyClass at 0x" << this << " constructed.\n";
    };

    ~MyClass() {
        cout << "MyClass at 0x" << this << " destroyed.\n";
    };
};

int main() {
    // The first form of array new / delete
    MyClass* fPtr1 = new MyClass[2];
    delete[] fPtr1;

    // The second form (fail returns nullptr) of array new / delete
    MyClass* fPtr2 = new(nothrow) MyClass[2];
    if (fPtr2)
        delete[] fPtr2;

    // The third form (non-allocating placement) of array new / delete
    char x[2 * sizeof(MyClass) + sizeof(int)]; // x is automatic

    MyClass* fPtr3 = new(&x[0]) MyClass[2];
    fPtr3[1].~MyClass(); // Requires explicit destructor calls
    fPtr3[0].~MyClass(); // Recommended in reverse construction order
    // Don't delete[] fPtr3 here.
    // delete[] &x[0] not required because x is on the stack
}