Baza wiedzyCentrum egzaminacyjne
PLPolski
Wybierz język13

CKTIS / C++

Placement new: konstruowanie w istniejącej pamięci

Utwórz obiekt w przygotowanym miejscu w pamięci. Oddziel czas życia obiektu od zarządzania pamięcią i świadomie zablokuj kopiowanie oraz przenoszenie właściciela.

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

Składnia

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

W C++23 wyrażenie ::new (static_cast<void*>(storage)) T(args...) konstruuje obiekt T pod podanym adresem i zwraca T*, jeśli wybrane zostanie standardowe niealokujące przeciążenie operator new(std::size_t, void*) z <new>. To globalne przeciążenie tylko zwraca przekazany adres. Początkowe :: pomija wyszukiwanie w obrębie klasy, ale rzutowanie na void* nie gwarantuje wyboru standardowego przeciążenia. Gdy alignof(T) > __STDCPP_DEFAULT_NEW_ALIGNMENT__, rozstrzyganie przeciążeń najpierw uwzględnia dodatkowy argument typu std::align_val_t, więc może zostać wybrane pasujące globalne przeciążenie placement new przyjmujące argument wyrównania. Jeśli nie znaleziono pasującej funkcji, rozstrzyganie przeciążeń jest ponawiane bez argumentu wyrównania. Zwykłe alokujące new T(args...) pozyskuje pamięć i inicjalizuje obiekt. Inne przeciążenia placement new mogą alokować pamięć.

Przekaż prawidłowy, niezerowy adres, co najmniej sizeof(T) dostępnych bajtów i zapewnij wyrównanie wymagane przez alignof(T). W przykładzie zapewnia je alignas(Item). Czas życia konstruowanego obiektu zaczyna się po pomyślnej inicjalizacji. Jeśli konstruktor zgłosi wyjątek, odpowiadające standardowe placement operator delete(void*, void*) niczego nie zwalnia. Oznacz miejsce jako zajęte dopiero po udanej konstrukcji.

Zachowaj T* zwrócone przez wyrażenie new. Rzutowanie samo nie konstruuje obiektu, a zgodność adresów nie zezwala na dostęp przez nieodpowiedni typ (reguły ścisłego aliasowania). std::launder może zwrócić wskaźnik do istniejącego żywego obiektu o podobnym typie pod tym adresem, jeśli spełniony jest warunek osiągalności bajtów. Nie rozpoczyna czasu życia ani nie naprawia wyrównania. Tutaj nie jest potrzebne.

Jawne wywołanie destruktora p->~T() niszczy obiekt, ale nie zwalnia pamięci areny ani bufora. W pokazanym cyklu zniszcz każdy pomyślnie skonstruowany obiekt dokładnie raz przed ponownym użyciem miejsca lub końcem istnienia bufora. Nie stosuj delete p do obiektu w tym buforze: wyrażenie delete dla poprawnie dobranego alokującego new zwykle niszczy obiekt i zwalnia pamięć.

= delete oznacza usuniętą definicję funkcji, a nie wyrażenie delete. Funkcja nadal uczestniczy w rozstrzyganiu przeciążeń, ale jej wybór w wywołaniu jest błędem kompilacji. Slot usuwa oba konstruktory i oba operatory przypisania służące do kopiowania i przenoszenia. Domyślne kopiowanie składowych skopiowałoby wskaźnik do bufora źródłowego, nie konstruując Item w buforze docelowym.

Przykłady

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

Wynik

7
destroyed
9
destroyed

Drugie wywołanie `emplace` niszczy `Item` o wartości `7` przed skonstruowaniem `9` w tym samym buforze. Destruktor `Slot` niszczy drugi obiekt.

Powiązane lekcje

  • C++ · Lekcja 16 · Zaawansowany · Wersja: 3
  • C++ · Lekcja 19 · Zaawansowany · Wersja: 3

Źródła