KennisbankExamencentrum
NL · NLNederlands (Nederland)
Taal kiezen13

CKTIS / C++

Objectpool, arena en verouderde pointers bij adreshergebruik

Een pool hergebruikt afzonderlijke slots; een monotone arena geeft geheugen in één keer vrij. Een handle met generatienummer onderscheidt opeenvolgende objecten op hetzelfde adres.

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

Syntax

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

In C++23 kan een objectpool met vaste capaciteit objecten van één type in slots van vaste grootte bewaren. De levensduur wordt per slot beheerd: placement-::new construeert in geheugen met voldoende ruimte en de juiste uitlijning, en std::destroy_at vernietigt het object zonder het slot vrij te geven. De destructor van de pool vernietigt alle nog levende objecten.

Een monotone arena, zoals std::pmr::monotonic_buffer_resource, groepeert allocaties uit één fase. Afzonderlijke deallocatie doet niets; release() geeft blokken terug aan de bovenliggende geheugenresource en herstelt de begintoestand. Het roept geen destructors van gebruikersobjecten aan. Vernietig objecten en containers die dit geheugen nog gebruiken voordat je de resource reset of vernietigt.

Benader het object tussen vernietiging en herconstructie niet via de oude pointer. Bij transparante vervanging, zoals bij twee volledige, niet-const Item-objecten op exact dezelfde plek, verwijst de oude pointer automatisch naar het nieuwe object. Pointervergelijking met == onderscheidt geen generaties. Is de vervanging niet transparant, ga dan niet uit van automatische aanpassing; gebruik de pointer die de constructie teruggeeft. std::launder heeft eigen voorwaarden en controleert geen logische identiteit.

Het voorbeeld zoekt begrensd lineair: create bekijkt hoogstens N slots (in het slechtste geval O(N)) en retourneert std::nullopt als geen slot bruikbaar is. Het is geen allocator met constante looptijd en geen implementatie van de standaard-allocatorinterface. get en erase controleren index, generatie en of er een levend object is. Na gebruik van de hoogste generatie wordt het slot bij verwijdering buiten gebruik gesteld, zodat de teller niet kan omslaan.

Gebruik handles alleen met dezelfde poolinstantie zolang die bestaat. Een teruggegeven ruwe pointer is geleend: hij verlengt de levensduur niet en voert later geen controles uit. Als threads de pool delen, synchroniseer dan zowel poolbewerkingen als toegang via geleende pointers extern.

Voorbeelden

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

Resultaat

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

Nadat beide slots zijn gevuld, vernietigt het programma het eerste object en construeert het `Item{40}` in hetzelfde slot. Het vergelijkt de pointers pas daarna; de oude handle wordt geweigerd ondanks het gelijke adres.

Gerelateerde lessen

  • C++ · Les 19 · Gevorderd · Versie: 3

Bronnen