Baza wiedzyCentrum egzaminacyjne
PLPolski
Wybierz język13

CKTIS / C++

Pula obiektów, arena i ponowne użycie adresu

Pula ponownie wykorzystuje pojedyncze gniazda, a arena monotoniczna odzyskuje pamięć zbiorczo. Uchwyt z numerem generacji odróżnia nowy obiekt od starego pod tym samym adresem.

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

Składnia

ISO C++23; implementation support may vary. For a single object in suitably sized and aligned storage: `T* p = ::new (static_cast<void*>(storage)) T(args...);` (`<new>`), then `std::destroy_at(p);` (`<memory>`) while the object is live. Keep the storage for reuse. Pool pattern: `create(...) -> std::optional<Handle>`, `get(Handle) -> T*`, `erase(Handle) -> bool`, with `Handle = {slot index, generation}`. These are example API signatures, not standard library interfaces. Arena example: `std::pmr::monotonic_buffer_resource` (`<memory_resource>`).

W C++23 pula obiektów może przechowywać obiekty jednego typu w gniazdach o stałym rozmiarze. Każde gniazdo ma własny cykl życia obiektu: forma umieszczająca ::new konstruuje go w przygotowanej pamięci o odpowiednim rozmiarze i wyrównaniu, a std::destroy_at niszczy go bez zwalniania pamięci gniazda. Destruktor puli niszczy pozostałe żywe obiekty.

Arena monotoniczna, np. std::pmr::monotonic_buffer_resource, grupuje alokacje jednej fazy. Dealokacja pojedynczego bloku nic nie robi; release() zwalnia bloki pozyskane z zasobu nadrzędnego i przywraca stan początkowy zasobu. Nie wywołuje destruktorów obiektów użytkownika. Przed resetem lub zniszczeniem zasobu zniszcz obiekty i kontenery, które jeszcze korzystają z jego pamięci.

Między zniszczeniem a ponowną konstrukcją nie uzyskuj dostępu do obiektu przez stary wskaźnik. Przy przezroczystym zastąpieniu, jak dla dwóch kompletnych, niebędących const obiektów Item w tym samym miejscu, stary wskaźnik automatycznie wskazuje nowy obiekt. Wynik == nie rozróżnia generacji. Gdy zastąpienie nie jest przezroczyste, nie zakładaj automatycznego przekierowania; użyj wskaźnika zwróconego przez konstrukcję. std::launder ma własne warunki wstępne i nie sprawdza tożsamości logicznej.

Przykład ma ograniczone liniowe przeszukiwanie: create sprawdza najwyżej N gniazd (w najgorszym przypadku O(N)) i zwraca std::nullopt, gdy nie ma gniazda do użycia. To nie jest alokator o stałym czasie ani implementacja standardowego interfejsu alokatora. get i erase sprawdzają indeks, generację i obecność żywego obiektu. Po wykorzystaniu maksymalnej generacji opróżnione gniazdo nie wraca do puli, więc licznik się nie zawija.

Uchwytu używaj tylko z tą samą, nadal istniejącą instancją puli. Zwrócony surowy wskaźnik jest pożyczony: nie przedłuża życia obiektu ani nie wykonuje późniejszych sprawdzeń. Przy współdzieleniu między wątkami synchronizuj na zewnątrz zarówno operacje puli, jak i dostęp przez pożyczony wskaźnik.

Przykłady

#include <array>
#include <cstddef>
#include <iostream>
#include <limits>
#include <memory>
#include <new>
#include <optional>

struct Item {
    int value;
};

class Pool {
public:
    struct Handle {
        std::size_t index;
        unsigned generation;
    };

    Pool() = default;
    Pool(const Pool&) = delete;
    Pool& operator=(const Pool&) = delete;
    Pool(Pool&&) = delete;
    Pool& operator=(Pool&&) = delete;

    ~Pool() {
        for (auto& slot : slots_) {
            if (slot.live) std::destroy_at(slot.live);
        }
    }

    std::optional<Handle> create(int value) {
        for (std::size_t i = 0; i < slots_.size(); ++i) {
            auto& slot = slots_[i];
            if (slot.live || slot.generation == std::numeric_limits<unsigned>::max()) {
                continue; // A slot at the maximum generation cannot be reused.
            }
            slot.live = ::new (static_cast<void*>(slot.storage)) Item{value};
            ++slot.generation;
            return Handle{i, slot.generation};
        }
        return std::nullopt;
    }

    Item* get(Handle h) noexcept {
        if (h.index >= slots_.size()) return nullptr;
        auto& slot = slots_[h.index];
        return slot.generation == h.generation ? slot.live : nullptr;
    }

    bool erase(Handle h) noexcept {
        if (Item* p = get(h)) {
            std::destroy_at(p);
            slots_[h.index].live = nullptr;
            return true;
        }
        return false;
    }

private:
    struct Slot {
        alignas(Item) std::byte storage[sizeof(Item)];
        Item* live = nullptr;
        unsigned generation = 0;
    };
    std::array<Slot, 2> slots_{};
};

int main() {
    Pool pool;
    const auto old = pool.create(10).value();
    Item* const first = pool.get(old);
    pool.create(20).value();

    std::cout << std::boolalpha;
    std::cout << "full: " << !pool.create(30).has_value() << '\n';
    pool.erase(old);
    const auto fresh = pool.create(40).value();
    Item* const current = pool.get(fresh);

    std::cout << "same address: " << (first == current) << '\n';
    std::cout << "stale handle rejected: " << (pool.get(old) == nullptr) << '\n';
    std::cout << "fresh value: " << current->value << '\n';
}

Wynik

full: true
same address: true
stale handle rejected: true
fresh value: 40

Po zapełnieniu obu gniazd program niszczy pierwszy obiekt i tworzy `Item{40}` w tym samym gnieździe. Porównuje wskaźniki dopiero po konstrukcji; stary uchwyt zostaje odrzucony mimo identycznego adresu.

Powiązane lekcje

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

Źródła