CKTIS / C++
Geheugen: eigenaarschap, kopieën en levensduur van objecten
Houd opslagruimte, het object dat daarin leeft en de verantwoordelijkheid voor een resource uit elkaar. Leer over automatische en dynamische opslagduur, kopieergedrag, placement new, expliciete vernietiging en de regels voor strict aliasing.
Versie: C++23; repository compiler flag, production runtime not attested
Syntax
T copy = original; T* alias = &original; T* p = ::new (static_cast<void*>(storage)) T{args}; p->~T();Opslag biedt ruimte voor gegevens; levensduur gaat over het object daarin. Die begint doorgaans zodra er genoeg, goed uitgelijnde opslag is en de initialisatie klaar is. Bij een klasseobject eindigt ze zodra de destructor wordt aangeroepen; vrijgave of hergebruik van opslag kan ze ook beëindigen. Een geldig adres alleen geeft geen toegang tot het object.
Opslagduur bepaalt hoelang opslag beschikbaar blijft. Een gewone lokale variabele heeft automatische opslagduur, tot het blok eindigt. Objecten gemaakt met allocerende new hebben dynamische opslagduur en kunnen langer bestaan dan het blok. Een lokale std::unique_ptr kan automatische opslagduur hebben en zijn object dynamische. Stack en heap zijn gangbare implementatiemodellen, geen definities.
Eigenaarschap betekent dat je een resource moet vrijgeven. Gebruik RAII: de destructor van de eigenaar ruimt op. std::unique_ptr kun je verplaatsen, niet kopiëren. Een kale pointer kopiëren kopieert het adres, niet het object of de verantwoordelijkheid om het te verwijderen. Klassen worden standaard lid voor lid gekopieerd; een pointerlid blijft naar hetzelfde object wijzen. Een kopie is niet altijd diep; twee onafhankelijke eigenaren van één adres riskeren dubbele verwijdering.
Placement new. In ::new (storage) T{args} beperkt het vooraan geplaatste :: het zoeken naar de allocatiefunctie tot het globale bereik, maar dwingt het niet af dat de standaardoverload met void* wordt gekozen. Een globale overload die beter past bij het type van storage kan geheugen alloceren. Het voorbeeld gebruikt de vorm ::new (static_cast<void*>(storage)) T{args} met het type Item. Daarbij wordt de niet-allocerende standaardoverload gekozen en wordt het object in de aangeleverde opslag geconstrueerd. De cast naar void* alleen garandeert die keuze niet voor elke T. Als T een grotere uitlijning vereist dan de standaarduitlijning voor new (alignof(T) > __STDCPP_DEFAULT_NEW_ALIGNMENT__), telt bij de eerste poging om een overload te kiezen een argument van het type std::align_val_t mee vóór het placement-argument. Een geschikte globale overload operator new(std::size_t, std::align_val_t, void*) kan dan worden gekozen in plaats van de niet-allocerende standaardoverload. De opslag moet groot genoeg en correct uitgelijnd zijn. p->~T() vernietigt het expliciet zonder opslag vrij te geven. Gebruik geen delete voor een object in een lokale buffer. Vernietig een object niet tweemaal: reconstrueer na expliciete vernietiging van een gewone lokale variabele met niet-triviale destructor correct een object van het oorspronkelijke type vóór de automatische vernietiging.
Strict aliasing beperkt via welke typen je de objectwaarde mag lezen of wijzigen. reinterpret_cast maakt toegang via een incompatibel type niet geldig. char, unsigned char en std::byte geven toegang tot de representatie, maar vervangen de levensduurregels niet. Het voorbeeld gebruikt een C++23-compatibele subset; de standaard-URL wijst naar het actuele concept, niet naar de vastgelegde C++23-editie.
Referentie-identificatoren die in dit item worden behandeld: Object lifetime, placement new, explicit destruction and strict aliasing, Automatic and dynamic storage duration.
Voorbeelden
#include <cstddef>
#include <iostream>
#include <memory>
#include <new>
struct Item {
int value;
~Item() {}
};
int main() {
Item original{7};
Item copy = original;
Item* alias = &original;
alias->value = 9;
auto owner = std::make_unique<Item>();
owner->value = 11;
alignas(Item) std::byte storage[sizeof(Item)];
Item* placed = ::new (static_cast<void*>(storage)) Item{13};
std::cout << original.value << ' ' << copy.value << ' '
<< owner->value << ' ' << placed->value << '\n';
placed->~Item();
}
Resultaat
9 7 11 13
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.