Znalostní bázeCentrum zkoušek
CSČeština
Vybrat jazyk13

CKTIS / C++

Placement new: konstrukce v existující paměti

Zkonstruujte objekt v připraveném slotu, spravujte jeho životnost nezávisle na paměti a zakažte kopírování i přesouvání vlastníka slotu.

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

Syntaxe

#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 výraz ::new (static_cast<void*>(storage)) T(args...) zkonstruuje T na zadané adrese a vrátí T*, pokud se vybere standardní nealokující přetížení operator new(std::size_t, void*) z <new>. Toto globální přetížení pouze vrátí adresu. Úvodní :: vynechá vyhledávání ve třídě, ale přetypování na void* nezaručí výběr standardního přetížení. Pokud platí alignof(T) > __STDCPP_DEFAULT_NEW_ALIGNMENT__, při výběru přetížení se nejprve zohlední další argument typu std::align_val_t, takže se místo standardního přetížení může vybrat vhodné globální přetížení placement new přijímající argument zarovnání. Pokud se nenajde odpovídající alokační funkce, výběr přetížení se opakuje bez argumentu zarovnání. Běžný alokující výraz new T(args...) získá paměť a inicializuje objekt. Jiná přetížení placement new mohou paměť alokovat.

Předejte platnou nenulovou adresu s nejméně sizeof(T) dostupnými bajty a zarovnáním vyhovujícím alignof(T). Příklad zajišťuje zarovnání pomocí alignas(Item). Životnost konstruovaného objektu začíná po úspěšné inicializaci. Pokud konstruktor vyvolá výjimku, odpovídající standardní placement operator delete(void*, void*) nic neuvolní. Slot označte jako obsazený až po úspěšné konstrukci.

Uchovejte T* vrácený výrazem new. Samotné přetypování objekt nekonstruuje a shodná adresa nedovoluje přístup přes nekompatibilní typ (pravidla strict aliasing). std::launder může získat ukazatel na již živý objekt podobného typu na této adrese, je-li splněna podmínka dosažitelnosti bajtů. Nezahajuje životnost ani neopravuje zarovnání. Zde není potřeba.

Explicitní volání destruktoru p->~T() zničí objekt, ale neuvolní paměť arény ani vyrovnávací paměti. V tomto vzoru zničte každý úspěšně zkonstruovaný objekt právě jednou, než slot znovu použijete nebo než skončí životnost vyrovnávací paměti. Na objekt v této vyrovnávací paměti nepoužívejte delete p: výraz delete spárovaný s odpovídajícím alokujícím výrazem new obvykle zničí objekt a uvolní paměť.

= delete definuje odstraněnou funkci; nejde o výraz delete. Funkce se stále účastní výběru přetížení, ale volání, které ji vybere, je neplatné. Slot odstraňuje kopírovací a přesouvací konstruktor i oba odpovídající operátory přiřazení. Výchozí kopírování po členech by zkopírovalo ukazatel do zdrojové vyrovnávací paměti, aniž by v cílové paměti zkonstruovalo Item.

Příklady

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

Výsledek

7
destroyed
9
destroyed

Druhé volání `emplace` zničí `Item` s hodnotou `7` a potom ve stejné vyrovnávací paměti zkonstruuje objekt s hodnotou `9`. Destruktor `Slot` zničí druhý objekt.

Související lekce

  • C++ · Lekce 16 · Pokročilá · Verze: 3
  • C++ · Lekce 19 · Pokročilá · Verze: 3

Zdroje