Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / C++

Placement new: costruzione in memoria già disponibile

Costruisci un oggetto in uno spazio predisposto, gestiscine la durata di vita separatamente dalla memoria e impedisci la copia e lo spostamento del proprietario.

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

Sintassi

#include <new>

// Assumes overload resolution selects the standard non-allocating placement overload.
T* p = ::new (static_cast<void*>(storage)) T(args...);  // Construct one T in existing storage.
p->~T();                                              // Destroy that T without freeing the storage.

// Inside the owning class, disable copying and moving:
Owner(const Owner&) = delete;
Owner& operator=(const Owner&) = delete;
Owner(Owner&&) = delete;
Owner& operator=(Owner&&) = delete;

In C++23, ::new (static_cast<void*>(storage)) T(args...) costruisce un T all’indirizzo fornito e restituisce un T* se viene selezionato l’overload standard non allocante operator new(std::size_t, void*) di <new>. Questo overload globale restituisce soltanto l’indirizzo. Il prefisso :: evita la ricerca nell’ambito della classe, ma la conversione a void* non garantisce che venga selezionato l’overload standard. Se alignof(T) > __STDCPP_DEFAULT_NEW_ALIGNMENT__, la risoluzione degli overload include prima un argomento aggiuntivo di tipo std::align_val_t, quindi può essere selezionato al suo posto un overload globale di placement che accetta l’argomento di allineamento. Se non viene trovata una funzione di allocazione corrispondente, la risoluzione viene ripetuta senza l’argomento di allineamento. La normale espressione di allocazione new T(args...) ottiene memoria e inizializza l’oggetto. Altri overload di placement possono allocare memoria.

Fornisci un indirizzo valido e non nullo, almeno sizeof(T) byte disponibili e un allineamento conforme a alignof(T). L’esempio usa alignas(Item) per l’allineamento. La durata di vita dell’oggetto costruito inizia dopo che l’inizializzazione è riuscita. Se il costruttore lancia un’eccezione, il corrispondente operator delete(void*, void*) standard di placement non libera nulla. Segna lo spazio come occupato solo dopo che la costruzione è riuscita.

Conserva il T* restituito dall’espressione new. Una conversione di tipo da sola non costruisce l’oggetto, e un indirizzo coincidente non consente l’accesso tramite un tipo incompatibile (regole di strict aliasing). std::launder può ottenere un puntatore a un oggetto di tipo simile già in vita a quell’indirizzo se è soddisfatto il requisito di raggiungibilità dei byte. Non avvia la durata di vita né corregge l’allineamento. Qui non serve.

La chiamata esplicita al distruttore p->~T() distrugge l’oggetto senza liberare la memoria dell’arena o del buffer. In questo schema, distruggi ogni oggetto costruito con successo esattamente una volta, prima di riutilizzare lo spazio o che termini la vita del buffer. Non usare delete p per un oggetto in questo buffer: un’espressione delete abbinata a un’espressione new di allocazione appropriata normalmente distrugge l’oggetto e libera la memoria.

= delete definisce una funzione eliminata; non è un’espressione delete. La funzione partecipa comunque alla risoluzione degli overload, ma una chiamata che la seleziona è mal formata. Slot elimina i costruttori di copia e di spostamento e i due operatori di assegnazione corrispondenti. La copia predefinita membro per membro copierebbe il puntatore al buffer sorgente senza costruire un Item nel buffer di destinazione.

Esempi

#include <cstddef>
#include <cstdio>
#include <new>

struct Item {
    int value;
    explicit Item(int n) : value(n) {}
    ~Item() { std::puts("destroyed"); }
};

class Slot {
    alignas(Item) std::byte storage_[sizeof(Item)];
    Item* item_ = nullptr;

public:
    Slot() = default;
    ~Slot() { reset(); }

    Slot(const Slot&) = delete;
    Slot& operator=(const Slot&) = delete;
    Slot(Slot&&) = delete;
    Slot& operator=(Slot&&) = delete;

    Item& emplace(int n) {
        reset();
        item_ = ::new (static_cast<void*>(storage_)) Item(n);
        return *item_;
    }

    void reset() noexcept {
        if (item_) {
            item_->~Item();
            item_ = nullptr;
        }
    }
};

int main() {
    Slot slot;
    std::printf("%d\n", slot.emplace(7).value);
    std::printf("%d\n", slot.emplace(9).value);
}

Risultato

7
destroyed
9
destroyed

La seconda chiamata a `emplace` distrugge l’`Item` contenente `7` prima di costruire quello contenente `9` nello stesso buffer. Il distruttore di `Slot` distrugge il secondo oggetto.

Lezioni correlate

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

Fonti