CKTIS / C++
`new[]` en `delete[]` voor arrays tegenover de vormen voor één object
Gebruik `delete` voor een object dat met `new T` is gemaakt en `delete[]` voor een array die met `new T[n]` is gemaakt. Deze expressies regelen de levensduur van objecten; de bijbehorende functies met en zonder `[]` beheren het geheugen.
Versie: ISO C++23; implementation support may vary
Syntax
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;In C++23 maakt en initialiseert new T{} één object. new T[n]{} maakt een array en initialiseert de elementen ervan. Beide expressies leveren T* op; aan het type van de pointer alleen zie je dus niet welke vorm van verwijderen nodig is. Een array vereist ook delete[] als n gelijk is aan 0 of 1.
delete p vernietigt één object; delete[] p vernietigt de array-elementen van het laatste tot het eerste. Daarna wordt het geheugen vrijgegeven. Verwissel de vormen niet: een verkeerde combinatie leidt tot ongedefinieerd gedrag, zelfs voor int. Geef aan delete[] de oorspronkelijke pointerwaarde die de array-new-expressie opleverde, niet een pointer die verder in de array wijst. Een nullpointer is bij beide vormen geldig en vernietigt niets.
operator new en operator delete zijn de geheugenfuncties voor één object; operator new[] en operator delete[] zijn de tegenhangers voor arrays. Een directe aanroep is niet hetzelfde als een expressie: ::operator new[](bytes) neemt een aantal bytes aan en roept geen constructors van T aan, terwijl ::operator delete[](raw) een op passende wijze toegewezen geheugenblok vrijgeeft zonder de destructors van de elementen aan te roepen. Een array-new-expressie kan extra bytes aanvragen en een pointer opleveren die afwijkt van het adres van het geheugenblok.
Globale functies hebben overloads met een parameter voor uitlijning; globale vrijgavefuncties hebben ook overloads met een grootteparameter. Klassen kunnen eigen functies definiëren. Met ::new of ::delete[] wordt de bijbehorende functie alleen in het globale bereik gezocht. Bij gewone globale allocatie die uitzonderingen werpt, wordt geheugentekort gemeld met std::bad_alloc. Een ongeldige arraylengte die tijdens de uitvoering wordt bepaald, zoals een negatief aantal, kan leiden tot std::bad_array_new_length.
Voorbeelden
#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;
}Resultaat
destroy 0 destroy 2 destroy 1
`delete one` toont `destroy 0`. Daarna vernietigt `delete[] many` eerst het element op index 1 en dan dat op index 0. De uitvoer is `destroy 2` en `destroy 1`. De waarden van `id` zijn geen array-indexen.
Gerelateerde lessen
- C++ · Les 57 · Gemiddeld · Versie: 2