Baza znanjaIzpitno središče
SLSlovenščina
Izberi jezik13

CKTIS / C++

Življenjska doba objekta in pravila strict aliasing

Pomnilnik lahko ostane na voljo po uničenju objekta. Življenjska doba določa, kdaj objekt obstaja, pravila strict aliasing pa, prek katerih tipov je dovoljen dostop do njegove vrednosti.

Različica: ISO C++23; implementation support may vary

Sintaksa

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);

V ISO C++23 ločimo pomnilnik, življenjsko dobo objekta in tip izraza za dostop. Življenjska doba se običajno začne, ko je na voljo dovolj velik in ustrezno poravnan pomnilnik ter je inicializacija končana. Pri objektu razrednega tipa se konča z začetkom klica destruktorja; konča se lahko tudi ob sprostitvi pomnilnika ali če ga znova uporabi objekt, ki ni ugnezden v prvem. Med konstrukcijo in uničevanjem veljajo posebna pravila.

::new (static_cast<void*>(storage)) T{args...} izbere standardno globalno obliko placement new, ki ne dodeli pomnilnika. Funkcija operator new vrne podani naslov, izraz new pa tam zgradi T in vrne T*. p->~T() pokliče destruktor, ne sprosti pa pomnilnika arene ali medpomnilnika. Za tako zgrajen objekt v medpomnilniku ne uporabi delete p in ga ne uniči dvakrat.

Po uničenju je pomnilnik lahko še vedno na voljo, vendar zunaj življenjske dobe vrednosti objekta ne smeš brati ali zapisovati. Za nadomestni objekt uporabi kazalec, ki ga vrne izraz new. Pri transparentni zamenjavi stari kazalci, reference in ime samodejno označujejo novi objekt, ko se začne njegova življenjska doba. Primer je popoln objekt brez const, ki ga na povsem istem mestu nadomesti popoln objekt istega tipa.

std::launder(p) lahko vrne kazalec na nadomestni objekt, če ga stari kazalci ali reference ne začnejo označevati samodejno. Na danem naslovu mora že obstajati živ objekt podobnega tipa v smislu standarda, vse bajte, dosegljive prek rezultata, pa mora biti mogoče doseči prek p. std::launder ne začne življenjske dobe, ne popravi poravnave in ne obide pravil aliasinga.

Strict aliasing se nanaša na tip glvalue, torej izraza, ki označuje objekt. Dostop do shranjene vrednosti prek nedovoljenega tipa povzroči nedefinirano obnašanje. Dovoljeni so tip, podoben dinamičnemu tipu objekta, ustrezni predznačeni ali nepredznačeni tip ter char, unsigned char ali std::byte za dostop do predstavitve objekta. signed char ni splošna izjema za dostop do bajtov. Sam reinterpret_cast ne omogoči veljavnega dostopa in ne ustvari objekta.

Primeri

#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();
}

Rezultat

7
destroy
9
destroy

Program prebere živi član tipa `int` prek reference na ustrezni tip `unsigned int`. Ko uniči prvi `Item`, v istem medpomnilniku zgradi drugega in uporabi novi kazalec. Vsak destruktor izpiše `destroy`; nobeden ne sprosti medpomnilnika.

Povezane lekcije

  • C++ · Lekcija 16 · Napredna · Različica: 3

Viri