Baza znanjaCentar za ispite
HRHrvatski
Odaberi jezik13

CKTIS / C++

Placement new: konstrukcija u postojećoj memoriji

Konstruiraj objekt na pripremljenom mjestu, upravljaj njegovim životnim vijekom odvojeno od memorije te onemogući kopiranje i premještanje vlasnika.

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

Sintaksa

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

U C++23 izraz ::new (static_cast<void*>(storage)) T(args...) konstruira T na zadanoj adresi i vraća T* ako se odabere standardno nealocirajuće preopterećenje operator new(std::size_t, void*) iz <new>. To globalno preopterećenje samo vraća adresu. Početni :: preskače pretraživanje u dosegu klase, ali pretvorba u void* ne jamči odabir standardnog preopterećenja. Ako vrijedi alignof(T) > __STDCPP_DEFAULT_NEW_ALIGNMENT__, razrješavanje preopterećenja najprije uključuje dodatni argument tipa std::align_val_t, pa se umjesto standardnog može odabrati odgovarajuće globalno preopterećenje placement new koje prima argument poravnanja. Ako se ne pronađe odgovarajuća alokacijska funkcija, razrješavanje preopterećenja ponavlja se bez argumenta poravnanja. Uobičajeni alocirajući izraz new T(args...) pribavlja memoriju i inicijalizira objekt. Druga preopterećenja placement new mogu alocirati memoriju.

Predaj valjanu adresu koja nije null, s najmanje sizeof(T) dostupnih bajtova i poravnanjem koje zadovoljava alignof(T). Primjer koristi alignas(Item) za poravnanje. Životni vijek konstruiranog objekta počinje nakon uspješne inicijalizacije. Ako konstruktor baci iznimku, odgovarajući standardni placement operator delete(void*, void*) ništa ne oslobađa. Označi mjesto zauzetim tek nakon uspješne konstrukcije.

Sačuvaj T* koji vraća izraz new. Sama pretvorba tipa ne konstruira objekt, a podudaranje adresa ne dopušta pristup kroz nekompatibilan tip (pravila strict aliasing). std::launder može dati pokazivač na već živ objekt sličnog tipa na toj adresi ako je zadovoljen uvjet dosegljivosti bajtova. Ne započinje životni vijek niti ispravlja poravnanje. Ovdje nije potreban.

Izričit poziv destruktora p->~T() uništava objekt bez oslobađanja memorije arene ili međuspremnika. U ovom obrascu uništi svaki uspješno konstruiran objekt točno jednom, prije ponovne uporabe mjesta ili završetka životnog vijeka međuspremnika. Nemoj koristiti delete p na objektu u tom međuspremniku: izraz delete uparen s odgovarajućim alocirajućim izrazom new obično uništava objekt i oslobađa memoriju.

= delete definira izbrisanu funkciju; to nije izraz delete. Funkcija i dalje sudjeluje u razrješavanju preopterećenja, ali poziv koji je odabere nije valjan. Slot briše konstruktor kopiranja i konstruktor premještanja te oba odgovarajuća operatora pridruživanja. Zadano kopiranje član po član kopiralo bi pokazivač u izvorni međuspremnik, bez konstrukcije objekta Item u odredišnom međuspremniku.

Primjeri

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

Rezultat

7
destroyed
9
destroyed

Drugi poziv `emplace` uništava `Item` s vrijednošću `7` prije nego što u istom međuspremniku konstruira objekt s vrijednošću `9`. Destruktor klase `Slot` uništava drugi objekt.

Povezane lekcije

  • C++ · Lekcija 16 · Napredno · Verzija: 3
  • C++ · Lekcija 19 · Napredno · Verzija: 3

Izvori