CKTIS / C++
`new[]` et `delete[]` pour les tableaux et formes pour un objet unique
Utilisez `delete` pour un objet créé par `new T` et `delete[]` pour un tableau créé par `new T[n]`. Ces expressions gèrent la durée de vie des objets ; les fonctions correspondantes, avec ou sans `[]`, gèrent la mémoire.
Version : ISO C++23; implementation support may vary
Syntaxe
T* one = new T{};
delete one;
T* many = new T[n]{};
delete[] many;
// Representative global storage-function declarations from <new>:
void* operator new(std::size_t bytes);
void* operator new[](std::size_t bytes);
void operator delete(void* storage) noexcept;
void operator delete[](void* storage) noexcept;En C++23, new T{} crée et initialise un objet unique, tandis que new T[n]{} crée un tableau et initialise ses éléments. Les deux expressions renvoient un T* : le type du pointeur ne suffit donc pas à déterminer la forme de suppression à utiliser. Un tableau exige delete[] même si n vaut 0 ou 1.
delete p détruit un seul objet ; delete[] p détruit les éléments du tableau du dernier au premier. La mémoire est ensuite libérée. Ne permutez pas les formes : une discordance entraîne un comportement indéfini, même pour int. Passez à delete[] la valeur de pointeur initialement renvoyée par l’expression new de tableau, et non un pointeur décalé à l’intérieur du tableau. Un pointeur nul est valide dans les deux formes et ne provoque aucune destruction.
operator new et operator delete désignent les fonctions de gestion de la mémoire pour un objet unique ; operator new[] et operator delete[] sont leurs équivalents pour les tableaux. Un appel direct n’est pas la même chose qu’une expression : ::operator new[](bytes) prend un nombre d’octets et n’appelle aucun constructeur de T, tandis que ::operator delete[](raw) libère un bloc correctement alloué sans appeler les destructeurs des éléments. Une expression new de tableau peut demander des octets supplémentaires, et le pointeur qu’elle renvoie peut différer de l’adresse du bloc.
Les fonctions globales ont des surcharges qui prennent un paramètre d’alignement ; les fonctions globales de libération ont aussi des surcharges qui prennent une taille. Une classe peut définir ses propres fonctions ; ::new ou ::delete[] limite la recherche de la fonction correspondante à la portée globale. Avec l’allocation globale usuelle qui lève des exceptions, le manque de mémoire est signalé par std::bad_alloc. Une longueur de tableau invalide déterminée à l’exécution, par exemple un nombre négatif, peut entraîner std::bad_array_new_length.
Exemples
#include <cstdio>
struct Item {
int id;
~Item() { std::printf("destroy %d\n", id); }
};
int main() {
Item* one = new Item{0};
delete one;
Item* many = new Item[2]{{1}, {2}};
delete[] many;
}Résultat
destroy 0 destroy 2 destroy 1
`delete one` affiche `destroy 0`. Ensuite, `delete[] many` détruit l’élément d’indice 1 avant celui d’indice 0, ce qui affiche `destroy 2` puis `destroy 1`. Les valeurs de `id` ne sont pas des indices du tableau.
Leçons associées
- C++ · Leçon 57 · Intermédiaire · Version : 2