KennisbankExamencentrum
NL · NLNederlands (Nederland)
Taal kiezen13

CKTIS / C++

new — objecten maken en opslag verkrijgen

Een new-expressie maakt een object en geeft er een pointer naar terug; meestal verkrijgt die ook opslag. Maak onderscheid met de allocatiefunctie operator new en leer over array-new[] en de Placement-new-expressie, die een object in aangeleverde opslag construeert.

Versie: C++23; repository compiler flag, production runtime not attested

Syntax

new T(args...)
new T{args...}
new T[n]{}
::new (address) T{args...}
new (std::nothrow) T{args...}

Als T geen arraytype is, maakt en initialiseert new T{args...} een object en geeft de expressie een pointer van het type T* terug. Een new-expressie is niet hetzelfde als de functie operator new: die laatste levert ruwe opslag, maar roept zelf geen constructor aan. De initializer is belangrijk: new int laat een onbepaalde waarde achter die in C++23 niet gelezen mag worden; new int{} levert nul op.

De arrayvorm new[], zoals new T[n]{}, maakt een array. Als de bewerking slaagt en n > 0, geeft de expressie een pointer naar het eerste element terug. In C++23 is n == 0 toegestaan: de array heeft geen elementen, dus je mag de teruggegeven pointer niet dereferencen. Gebruik delete bij gewone new voor één object en delete[] bij new dat een array maakt, ook voor een array met lengte nul. Na using T = int[3]; geeft new T{} bijvoorbeeld een int* naar het eerste element terug. Gebruik delete[] om de array te verwijderen, ook al bevat de new-expressie geen vierkante haken. Deze vormen door elkaar gebruiken veroorzaakt ongedefinieerd gedrag. Het verwijderen van objecten reset pointers die hun adressen bevatten niet.

De standaard-allocatiefunctie die uitzonderingen werpt, werpt std::bad_alloc als ze geen opslag kan verkrijgen. Als new (std::nothrow) T{} de standaardoverload van de allocatiefunctie selecteert die geen uitzonderingen werpt, geeft de expressie bij een allocatiefout nullptr terug. Als T een klassetype is, kan de expressie in plaats daarvan een klassespecifieke allocatieoverload selecteren die std::nothrow_t accepteert, maar toch een uitzondering kan werpen. Ook met de standaardoverload die geen uitzonderingen werpt, kan de expressie een uitzondering van de constructor doorgeven. Controleer het resultaat voordat je het dereferencet. Als een constructor een uitzondering werpt, roept de new-expressie een geschikte deallocatiefunctie aan als die wordt gevonden.

Een Placement-new-expressie in de vorm ::new (address) T{args...}, met de standaardoverload uit <new> die een void* accepteert, construeert een object in bestaande opslag zonder die te alloceren. Het opgegeven adres mag niet nullptr zijn. De opslag moet groot genoeg zijn, correct uitgelijnd zijn en gedurende de volledige levensduur van het object beschikbaar blijven. Roep voor de buffer in het voorbeeld placed->~Item() aan, niet delete placed; de buffer heeft een eigen levensduur.

Reikwijdte van dit item: C++23. De bijbehorende compileroptie in de repository bevestigt de productie-runtime niet. De opgegeven standaard-URL verwijst naar een voortdurend veranderend werkdocument, niet naar een vastgelegde C++23-editie.

Voorbeelden

#include <cstddef>
#include <iostream>
#include <new>

struct Item {
    int value;
};

int main() {
    int* single = new int{7};
    std::cout << *single << '\n';
    delete single;

    int* array = new int[3]{1, 2, 3};
    std::cout << array[0] + array[1] + array[2] << '\n';
    delete[] array;

    alignas(Item) std::byte storage[sizeof(Item)];
    Item* placed = ::new (static_cast<void*>(storage)) Item{9};
    std::cout << placed->value << '\n';
    placed->~Item();
}

Resultaat

7
6
9

De getoonde code en het opgegeven resultaat zijn in een geïsoleerde omgeving geverifieerd met de methode die in het verificatiebewijs voor exact deze versie is vastgelegd.

Bronnen