opérateurs delete vs delete [] en C ++

Quelle est la différence entre les opérateurs deleteet delete[]en C ++?

L' deleteopérateur libère la mémoire et appelle le destructeur pour un seul objet créé avec new.

L' delete []opérateur libère la mémoire et appelle des destructeurs pour un tableau d'objets créés avec new [].

L'utilisation deletesur un pointeur renvoyé par new []ou delete []sur un pointeur renvoyé par newentraîne un comportement non défini.

L' delete[]opérateur est utilisé pour supprimer des tableaux. L' deleteopérateur est utilisé pour supprimer des objets non-tableau. Il appelle operator delete[]et operator deletefonctionne respectivement pour supprimer la mémoire occupée par le tableau ou l'objet non-tableau après avoir (éventuellement) appelé les destructeurs pour les éléments du tableau ou l'objet non-tableau.

Ce qui suit montre les relations:

typedef int array_type[1];

// create and destroy a int[1]
array_type *a = new array_type;
delete [] a;

// create and destroy an int
int *b = new int;
delete b;

// create and destroy an int[1]
int *c = new int[1];
delete[] c;

// create and destroy an int[1][2]
int (*d)[2] = new int[1][2];
delete [] d;

Pour le newqui crée un tableau (donc, soit le new type[]soit newappliqué à une construction de type tableau), le Standard recherche un operator new[]dans la classe de type d'élément du tableau ou dans la portée globale et transmet la quantité de mémoire demandée. Il peut demander plus que N * sizeof(ElementType)s'il le souhaite (par exemple pour stocker le nombre d'éléments, de sorte que plus tard, lors de la suppression, il sait combien d'appels de destructeur à done). Si la classe déclare un operator new[]qui supplémentaire à la quantité de mémoire en accepte un autresize_t , ce deuxième paramètre recevra le nombre d'éléments alloués - elle peut l'utiliser pour n'importe quel but (débogage, etc ...).

Pour le newqui crée un objet non-tableau, il recherchera un operator newdans la classe de l'élément ou dans la portée globale. Il passe la quantité de mémoire demandée (exactement sizeof(T)toujours).

Pour le delete[], il examine le type de classe d'élément des tableaux et appelle leurs destructeurs. La operator delete[]fonction utilisée est celle de la classe du type d'élément, ou s'il n'y en a pas alors dans la portée globale.

Pour le delete, si le pointeur passé est une classe de base du type de l'objet réel, la classe de base doit avoir un destructeur virtuel (sinon, le comportement n'est pas défini). S'il ne s'agit pas d'une classe de base, alors le destructeur de cette classe est appelé et un operator deletedans cette classe ou le global operator deleteest utilisé. Si une classe de base a été transmise, le destructeur du type d'objet réel est appelé et l' operator deleteélément trouvé dans cette classe est utilisé, ou s'il n'y en a pas, un global operator deleteest appelé. Si le operator deletedans la classe a un deuxième paramètre de type size_t, il recevra le nombre d'éléments à désallouer.

C'est l'utilisation de base du modèle allocate / DE-allocate en c ++ malloc/ free, new/ delete, new[]/delete[]

Nous devons les utiliser en conséquence. Mais je voudrais ajouter cette compréhension particulière de la différence entre deleteetdelete[]

1) deleteest utilisé pour désallouer la mémoire allouée à un seul objet

2) delete[]est utilisé pour désallouer la mémoire allouée au tableau d'objets

class ABC{}

ABC *ptr = new ABC[100]

quand nous disons new ABC[100], le compilateur peut obtenir les informations sur le nombre d'objets à allouer (ici c'est 100) et appellera le constructeur pour chacun des objets créés

mais en conséquence si nous utilisons simplement delete ptrpour ce cas, le compilateur ne saura pas combien d'objets ptrpointent et finira par appeler le destructeur et supprimer la mémoire pour un seul objet (laissant l'invocation des destructeurs et la désallocation des 99 objets restants). Il y aura donc une fuite de mémoire.

nous devons donc utiliser delete [] ptrdans ce cas.

Les opérateurs deleteet delete []servent respectivement à détruire les objets créés avec newet new[], en retournant à la mémoire allouée laissée disponible au gestionnaire de mémoire du compilateur.

Les objets créés avec newdoivent nécessairement être détruits avec deleteet que les tableaux créés avec new[]doivent être supprimés avec delete[].

Lorsque j'ai posé cette question, ma vraie question était: "Y a-t-il une différence entre les deux? Le moteur d'exécution ne doit-il pas conserver des informations sur la taille du tableau, et ne pourra-t-il donc pas dire de quoi nous parlons?" Cette question n'apparaît pas dans les "questions connexes", donc juste pour aider ceux comme moi, voici la réponse à cela: "pourquoi avons-nous même besoin de l'opérateur delete []?"

deleteest utilisé pour un seul pointeur et delete[]est utilisé pour supprimer un tableau via un pointeur. Cela pourrait vous aider à mieux comprendre.

Eh bien .. peut-être que je pense que c'est juste pour explicite. L'opérateur deleteet l'opérateur delete[]sont distingués mais l' deleteopérateur peut également libérer le tableau.

test* a = new test[100];
delete a;

Et déjà vérifié ce code n'a pas de fuite de mémoire.