Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / C++

Durata di vita degli oggetti e aliasing rigoroso

La memoria può restare disponibile dopo la distruzione dell’oggetto. La durata di vita stabilisce quando l’oggetto esiste; l’aliasing rigoroso stabilisce tramite quali tipi si può accedere al suo valore.

Versione: ISO C++23; implementation support may vary

Sintassi

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 occorre distinguere la memoria, la durata di vita dell’oggetto e il tipo dell’espressione usata per accedervi. Di norma, la durata di vita inizia quando è disponibile memoria con dimensioni e allineamento adeguati e l’inizializzazione è completata. Per un oggetto di classe termina quando inizia la chiamata al distruttore; può terminare anche se la memoria viene liberata o riutilizzata da un oggetto non annidato al suo interno. Durante costruzione e distruzione valgono regole specifiche.

::new (static_cast<void*>(storage)) T{args...} seleziona la forma globale standard del placement new, che non alloca memoria. La funzione operator new restituisce l’indirizzo fornito; l’espressione new costruisce lì un T e restituisce un T*. p->~T() chiama il distruttore senza liberare la memoria dell’arena o del buffer. Non usare delete p su un oggetto costruito in questo modo in un buffer e non distruggerlo due volte.

Dopo la distruzione, la memoria può essere ancora disponibile, ma non si deve leggere o scrivere il valore dell’oggetto al di fuori della sua durata di vita. Per il nuovo oggetto usa il puntatore restituito dall’espressione new. In caso di sostituzione trasparente, i puntatori, i riferimenti e il nome precedenti designano automaticamente il nuovo oggetto non appena è in vita. È il caso, per esempio, di un oggetto completo non const sostituito da un oggetto completo dello stesso tipo esattamente nella stessa memoria.

std::launder(p) può fornire un puntatore al nuovo oggetto quando i riferimenti precedenti non passano a designarlo automaticamente. A quell’indirizzo deve già esistere un oggetto in vita di tipo simile nel senso dello standard, e tutti i byte raggiungibili tramite il risultato devono essere raggiungibili tramite p. std::launder non avvia la durata di vita, non corregge l’allineamento e non aggira le regole di aliasing.

L’aliasing rigoroso riguarda il tipo della glvalue, ossia dell’espressione che designa l’oggetto. Accedere al valore memorizzato tramite un tipo non consentito produce comportamento indefinito. Sono consentiti un tipo simile al tipo dinamico dell’oggetto, il corrispondente tipo con o senza segno e char, unsigned char o std::byte per accedere alla rappresentazione dell’oggetto. signed char non è un’eccezione generale per l’accesso ai byte. Un reinterpret_cast da solo non rende lecito l’accesso e non crea un oggetto.

Esempi

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

Risultato

7
destroy
9
destroy

Il programma legge il membro `int` in vita tramite un riferimento al tipo corrispondente `unsigned int`. Distrutto il primo `Item`, ne costruisce un secondo nello stesso buffer e usa il nuovo puntatore. Ogni distruttore stampa `destroy`; nessuno libera il buffer.

Lezioni correlate

  • C++ · Lezione 16 · Avanzato · Versione: 3

Fonti