delete, opérateur (C++)

Libère un bloc de mémoire.

Syntaxe

[::] delete cast-expression
[::] delete [] cast-expression

Notes

L’argument cast-expression doit être un pointeur vers un bloc de mémoire précédemment alloué pour un objet créé avec l’opérateur new. L’opérateur delete a un résultat de type void et ne retourne par conséquent aucune valeur. Par exemple :

CDialog* MyDialog = new CDialog;
// use MyDialog
delete MyDialog;

L’utilisation de delete sur un pointeur vers un objet non alloué avec new donne des résultats imprévisibles. Toutefois, vous pouvez utiliser delete sur un pointeur avec la valeur 0. Cette clause signifie que, lorsque new retourne 0 en cas d’échec, la suppression du résultat d’une opération new ayant échoué ne présente aucun danger. Pour plus d’informations, consultez Les opérateurs new et delete.

Les opérateurs new et delete peuvent également être utilisés pour les types intégrés, y compris les tableaux. Si pointer fait référence à un tableau, placez des crochets vides ([]) avant pointer :

int* set = new int[100];
//use set[]
delete [] set;

L’utilisation de l’opérateur delete sur un objet libère sa mémoire. Un programme qui déréférence un pointeur après la suppression de l'objet peut avoir des résultats imprévisibles ou se bloquer.

Quand delete est utilisé pour libérer la mémoire pour un objet de classe C++, le destructeur de l’objet est appelé avant la libération de la mémoire de l’objet (si l’objet a un destructeur).

Si l’opérande vers l’opérateur delete est une l-value modifiable, sa valeur n’est pas définie une fois l’objet supprimé.

Si l’option du compilateur /sdl (Activer des vérifications de sécurité supplémentaires) est spécifiée, l’opérande vers l’opérateur delete est défini sur une valeur non valide après la suppression de l’objet.

Utilisation de delete

Il existe deux variantes syntaxiques pour l’opérateur delete : une pour les objets uniques, l’autre pour les tableaux d’objets. Le fragment de code suivant illustre leurs différences :

// expre_Using_delete.cpp
struct UDType
{
};

int main()
{
   // Allocate a user-defined object, UDObject, and an object
   //  of type double on the free store using the
   //  new operator.
   UDType *UDObject = new UDType;
   double *dObject = new double;
   // Delete the two objects.
   delete UDObject;
   delete dObject;
   // Allocate an array of user-defined objects on the
   // free store using the new operator.
   UDType (*UDArr)[7] = new UDType[5][7];
   // Use the array syntax to delete the array of objects.
   delete [] UDArr;
}

Les deux cas suivants génèrent des résultats indéfinis : en utilisant le formulaire du tableau delete (delete []) sur un objet et en utilisant le formulaire nonarray de delete sur un tableau.

Exemple

Pour obtenir des exemples d’utilisation de delete, consultez opérateur new.

Fonctionnement de delete

L’opérateur delete appelle la fonction opérateur delete.

Pour les objets n’étant pas du type de classe (class, struct ou union), l’opérateur delete global est appelé. Pour les objets du type classe, le nom de la fonction de désallocation est résolu dans la portée globale si l’expression de supprimer commence par l’opérateur de résolution de portée unaire (::). Sinon, l'opérateur delete appelle le destructeur pour un objet avant de désallouer la mémoire (si le pointeur n'est pas null). L'opérateur delete peut être défini pour chaque classe ; si cette définition n'existe pas pour une classe donnée, l'opérateur de suppression global est appelé. Si l'expression de suppression est utilisée pour désallouer un objet de classe dont le type statique a un destructeur virtuel, la fonction de désallocation est résolue par l'intermédiaire du destructeur virtuel du type dynamique de l'objet.

Voir aussi

Expressions avec opérateurs unaires
Mots clés
new et delete, opérateurs