CKTIS / C++
Objectlevensduur en strict aliasing
Geheugen kan beschikbaar blijven nadat een object is vernietigd. De levensduur bepaalt wanneer het object bestaat; strict aliasing bepaalt via welke typen je zijn waarde mag benaderen.
Versie: ISO C++23; implementation support may vary
Syntax
alignas(T) std::byte storage[sizeof(T)];
T* p = ::new (static_cast<void*>(storage)) T{args...};
p->~T();
// Schematic: T is a class type; args... denotes its initializer arguments.
// Headers: <cstddef> for std::byte; <new> for placement new and std::launder.
// When its preconditions are met: T* q = std::launder(candidate);In ISO C++23 zijn opslag, objectlevensduur en het type van de toegangsexpressie verschillende zaken. De levensduur begint normaal zodra er voldoende, correct uitgelijnde opslag is en de initialisatie voltooid is. Bij een klasseobject eindigt de levensduur zodra de destructor wordt aangeroepen; ze kan ook eindigen als de opslag wordt vrijgegeven of hergebruikt door een object dat er niet in genest is. Tijdens constructie en destructie gelden speciale regels.
::new (static_cast<void*>(storage)) T{args...} kiest de globale standaardvorm van placement new die geen opslag toewijst. De allocatiefunctie operator new retourneert het opgegeven adres; de new-expressie construeert daar een T en retourneert een T*. p->~T() roept de destructor aan, maar geeft de opslag van de arena of buffer niet vrij. Gebruik geen delete p voor een zo in de buffer geconstrueerd object en vernietig het niet tweemaal.
Na destructie kan de opslag nog beschikbaar zijn, maar lees of schrijf de objectwaarde niet buiten de levensduur. Gebruik bij vervanging de pointer die de nieuwe new-expressie retourneert. Bij transparante vervanging verwijzen bestaande pointers, referenties en de naam van het object automatisch naar het nieuwe object zodra het leeft. Een voorbeeld is een volledig, niet-const object dat in exact dezelfde opslag wordt vervangen door een volledig object van hetzelfde type.
std::launder(p) kan een pointer naar het vervangende object opleveren als bestaande verwijzingen niet automatisch naar dat object wijzen. Op dat adres moet al een levend object staan met een type dat volgens de standaard gelijksoortig is. Alle bytes die via het resultaat bereikbaar zijn, moeten ook via p bereikbaar zijn. std::launder start geen levensduur, herstelt geen uitlijning en omzeilt de aliasingregels niet.
Strict aliasing gaat over het type van de glvalue, de expressie die het object aanduidt. Toegang tot de opgeslagen waarde via een niet-toegestaan type leidt tot ongedefinieerd gedrag. Toegestaan zijn een type dat gelijksoortig is aan het dynamische type van het object, het bijbehorende signed of unsigned type en char, unsigned char of std::byte voor toegang tot de objectrepresentatie. signed char is geen algemene uitzondering voor toegang tot bytes. Een reinterpret_cast maakt toegang op zichzelf niet geldig en creëert geen object.
Voorbeelden
#include <cstddef>
#include <cstdio>
#include <new>
struct Item {
int value;
~Item() { std::puts("destroy"); }
};
int main() {
alignas(Item) std::byte storage[sizeof(Item)];
void* slot = storage;
Item* p = ::new (slot) Item{7};
const unsigned int& alias = reinterpret_cast<const unsigned int&>(p->value);
std::printf("%u\n", alias);
p->~Item();
Item* q = ::new (slot) Item{9};
std::printf("%d\n", q->value);
q->~Item();
}Resultaat
7 destroy 9 destroy
Het programma leest het levende `int`-lid via een referentie naar het bijbehorende type `unsigned int`. Na destructie van het eerste `Item` construeert het een tweede in dezelfde buffer en gebruikt het de nieuwe pointer. Elke destructor schrijft `destroy`; geen van beide geeft de buffer vrij.
Gerelateerde lessen
- C++ · Les 16 · Gevorderd · Versie: 3
Bronnen
- N4950: Working Draft, Standard for Programming Language C++ (C++23 draft)
- Lifetime [basic.life] (living draft)
- Value category [basic.lval] (living draft)
- Non-allocating forms [new.delete.placement] (living draft)
- Destructors [class.dtor] (living draft)
- Pointer optimization barrier [ptr.launder] (living draft)