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

CKTIS / C++

Fond objektů, aréna a zastaralé ukazatele při opětovném použití adresy

Fond znovu používá jednotlivé sloty, monotónní aréna uvolňuje paměť hromadně. Identifikátor s číslem generace rozliší dva po sobě jdoucí objekty na stejné adrese.

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

Syntaxe

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>`).

V C++23 může fond objektů s pevnou kapacitou uchovávat objekty jednoho typu ve slotech pevné velikosti. Životnost se řídí pro každý slot zvlášť: umísťovací ::new zkonstruuje objekt v paměti s odpovídající velikostí a zarovnáním a std::destroy_at jej zničí, aniž uvolní paměť slotu. Destruktor fondu zničí všechny dosud živé objekty.

Monotónní aréna, například std::pmr::monotonic_buffer_resource, sdružuje alokace z jedné fáze. Jednotlivá dealokace nemá účinek; release() vrátí bloky nadřazenému paměťovému zdroji a obnoví počáteční stav zdroje. Nevolá destruktory uživatelských objektů. Objekty a kontejnery, které tuto paměť ještě používají, znič před obnovením nebo zničením zdroje.

Mezi zničením a novou konstrukcí nepřistupuj k objektu přes starý ukazatel. Při transparentním nahrazení, jako u dvou úplných objektů Item bez const na přesně stejném místě, začne starý ukazatel automaticky označovat nový objekt. Porovnání ukazatelů pomocí == generace nerozliší. Není-li nahrazení transparentní, nespoléhej na automatické přesměrování; použij ukazatel vrácený konstrukcí. std::launder má vlastní vstupní podmínky a neověřuje logickou totožnost.

Příklad používá omezené lineární hledání: create prohlédne nejvýše N slotů (v nejhorším případě O(N)) a vrátí std::nullopt, pokud žádný nelze použít. Nejde o alokátor s konstantním časem ani o implementaci standardního rozhraní alokátoru. get a erase kontrolují index, generaci a přítomnost živého objektu. Po použití nejvyšší generace se slot při odstranění objektu vyřadí, aby se čítač nevrátil na nulu.

Identifikátor používej jen se stejnou, dosud existující instancí fondu. Vrácený surový ukazatel je vypůjčený: neprodlužuje životnost objektu a neprovádí pozdější kontroly. Sdílí-li fond více vláken, zajisti vnější synchronizaci operací fondu i přístupu přes vypůjčené ukazatele.

Příklady

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

Výsledek

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

Po zaplnění obou slotů program zničí první objekt a zkonstruuje `Item{40}` ve stejném slotu. Ukazatele porovná až po nové konstrukci; starý identifikátor je odmítnut i při stejné adrese.

Související lekce

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

Zdroje