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

CKTIS / C++

Placement new: konstrukcija v obstoječem pomnilniku

Ustvari objekt na pripravljenem mestu, upravljaj njegovo življenjsko dobo ločeno od pomnilnika ter lastniku mesta onemogoči kopiranje in premikanje.

Različica: 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;

V C++23 izraz ::new (static_cast<void*>(storage)) T(args...) konstruira T na podanem naslovu in vrne T*, če je izbrana standardna preobremenitev operator new(std::size_t, void*) iz <new>, ki ne dodeljuje pomnilnika. Ta globalna preobremenitev samo vrne naslov. Predpona :: preskoči iskanje v dosegu razreda, vendar pretvorba v void* ne zagotavlja izbire standardne preobremenitve. Če velja alignof(T) > __STDCPP_DEFAULT_NEW_ALIGNMENT__, se pri izbiri preobremenitve najprej upošteva dodatni argument tipa std::align_val_t, zato je lahko namesto standardne izbrana ustrezna globalna preobremenitev placement new, ki sprejme argument za poravnavo. Če se ne najde ustrezna funkcija za dodelitev pomnilnika, se izbira preobremenitve ponovi brez argumenta za poravnavo. Običajni izraz new T(args...), ki dodeljuje pomnilnik, pridobi pomnilnik in inicializira objekt. Druge preobremenitve placement new lahko dodelijo pomnilnik.

Podaj veljaven neničelni naslov z najmanj sizeof(T) razpoložljivimi bajti in poravnavo, ki ustreza alignof(T). Primer za poravnavo uporabi alignas(Item). Življenjska doba konstruiranega objekta se začne po uspešni inicializaciji. Če konstruktor sproži izjemo, ustrezni standardni placement operator delete(void*, void*) ne sprosti ničesar. Mesto označi kot zasedeno šele po uspešni konstrukciji.

Obdrži T*, ki ga vrne izraz new. Sama pretvorba tipa ne konstruira objekta, ujemanje naslovov pa ne dovoljuje dostopa prek nezdružljivega tipa (pravila strict aliasing). std::launder lahko pridobi kazalec na že živ objekt podobnega tipa na tem naslovu, če je izpolnjen pogoj dosegljivosti bajtov. Ne začne življenjske dobe in ne popravi poravnave. Tukaj ni potreben.

Izrecni klic destruktorja p->~T() uniči objekt, ne da bi sprostil pomnilnik arene ali medpomnilnika. Pri tem vzorcu uniči vsak uspešno konstruiran objekt natanko enkrat, preden znova uporabiš mesto ali preden se konča življenjska doba medpomnilnika. Za objekt v tem medpomnilniku ne uporabi delete p: izraz delete, povezan z ustreznim izrazom new, ki dodeli pomnilnik, običajno uniči objekt in sprosti pomnilnik.

= delete definira izbrisano funkcijo; to ni izraz delete. Funkcija še vedno sodeluje pri izbiri preobremenitve, vendar je klic, ki jo izbere, neveljaven. Slot izbriše kopirni in premikalni konstruktor ter oba pripadajoča operatorja prirejanja. Privzeto kopiranje po članih bi kopiralo kazalec v izvorni medpomnilnik, ne da bi konstruiralo Item v ciljnem medpomnilniku.

Primeri

#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 klic `emplace` uniči `Item` z vrednostjo `7`, preden v istem medpomnilniku konstruira objekt z vrednostjo `9`. Destruktor `Slot` uniči drugi objekt.

Povezane lekcije

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

Viri