delete vs delete [] opérateurs en C ++
Quelle est la difference entre delete et delete[] opérateurs en C++?
L'opérateur delete libère de la mémoire et appelle le destructeur pour un seul objet créé avec new.
L'opérateur delete [] Libère de la mémoire et appelle des destructeurs pour un tableau d'objets créé avec new [].
L'utilisation de delete sur un pointeur renvoyé par new [] Ou delete [] Sur un pointeur renvoyé par new entraîne un comportement non défini.
L'opérateur delete[] est utilisé pour supprimer des tableaux. L'opérateur delete est utilisé pour supprimer des objets non-array. Il appelle la fonction operator delete[] et operator delete respectivement pour supprimer la mémoire occupée par le tableau ou l'objet non-tableau après (éventuellement) l'appel des 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 un new qui crée un tableau (le code new type[] ou new est donc appliqué à une construction de type tableau), la norme 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, afin de pouvoir ultérieurement, lors de la suppression, connaître le nombre d'appels de destructeurs à done). Si la classe déclare un operator new[] qui, en plus de la quantité de mémoire, accepte un autre size_t, ce deuxième paramètre recevra le nombre d'éléments alloués - il pourra l'utiliser à toutes fins utiles (débogage, etc.).
Pour un new qui crée un objet non-tableau, il cherchera un operator new dans la classe de l'élément ou dans la portée globale. Il transmet la quantité de mémoire demandée (exactement sizeof(T) toujours).
Pour un delete[], il examine le type de classe d'élément des tableaux et appelle leurs destructeurs. La fonction operator delete[] utilisée est celle de la classe du type d'élément ou, s'il n'y en a pas, dans la portée globale.
Pour un delete, si le pointeur transmis est une classe de base du type de l'objet réel, la classe de base doit avoir un destructeur virtuel (sinon, le comportement est indéfini). S'il ne s'agit pas d'une classe de base, le destructeur de cette classe est appelé et un operator delete dans cette classe ou le global operator delete est utilisé. Si une classe de base a été transmise, le destructeur du type d'objet réel est appelé et le operator delete trouvé dans cette classe est utilisé, ou s'il n'y en a pas, un global operator delete est appelé. Si le operator delete de 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 pour la différence entre supprimer et supprimer []
1) delete est utilisé pour désallouer de la mémoire allouée pour objet unique
2) delete [] est utilisé pour désallouer de la mémoire allouée pour tableau d'objets
classe ABC {}
ABC * ptr = nouvel ABC [100]
quand on dit new [100] .. le compilateur peut obtenir des informations sur le nombre d'objets à allouer (ici, il s'agit de 100) et appelle le constructeur pour chacun des objets créés
mais en conséquence, si nous utilisons simplement delete ptr dans ce cas, le compilateur ne saura pas combien d'objets pointe ptr et finira par appeler un destructeur et supprimer de la mémoire uniquement 1 objet (laissant invocation des destructeurs et désallocation des 99 objets restants). Il y aura donc une fuite de mémoire
il faut donc utiliser delete [] ptr dans ce cas.
Les opérateurs delete et delete [] sont utilisés respectivement pour détruire les objets créés avec new et new[], revenant à la mémoire allouée laissée au gestionnaire de mémoire du compilateur.
Les objets créés avec new doivent obligatoirement être détruits avec delete, et que les tableaux créés avec new[] devrait être supprimé avec delete[].
Lorsque j'ai posé cette question, ma vraie question était la suivante: "existe-t-il une différence entre les deux? Le moteur d'exécution ne doit-il pas conserver les informations relatives à la taille du tableau, et ne pourra-t-il donc pas dire de quel groupe on parle?" Cette question n'apparaissant pas dans les "questions connexes", alors pour aider ceux qui sont comme moi, voici la réponse à cette question: "pourquoi avons-nous même besoin de l'opérateur delete []?"