WissensdatenbankPrüfungszentrum
DEDeutsch
Sprache wählen13

CKTIS / C++

Objektpool, Arena und alte Zeiger bei Adresswiederverwendung

Ein Pool verwendet einzelne Plätze wieder, eine monotone Arena gibt Speicher gesammelt frei. Ein Handle mit Generationsnummer unterscheidet alte und neue Objekte an derselben Adresse.

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

Ein Objektpool fester Kapazität kann in C++23 Objekte eines Typs in gleich großen Speicherplätzen halten. Jeder Platz hat eine eigene Objektlebensdauer: Placement-::new konstruiert in ausreichend großem und korrekt ausgerichtetem Speicher, std::destroy_at zerstört das Objekt, ohne den Speicherplatz freizugeben. Der Pooldestruktor zerstört alle noch lebenden Objekte.

Eine monotone Arena wie std::pmr::monotonic_buffer_resource bündelt Allokationen einer Phase. Einzelne Deallokationen bleiben wirkungslos; release() gibt Blöcke an die übergeordnete Speicherressource zurück und setzt die Ressource in ihren Anfangszustand. Dabei werden keine Destruktoren der dort angelegten Objekte aufgerufen. Zerstöre Objekte und Container, die den Speicher noch nutzen, vor dem Zurücksetzen oder Zerstören der Ressource.

Zwischen Zerstörung und erneuter Konstruktion darfst du über den alten Zeiger nicht auf das Objekt zugreifen. Bei transparentem Ersetzen, etwa bei zwei vollständigen, nicht const-qualifizierten Item-Objekten exakt am selben Ort, verweist der alte Zeiger automatisch auf das neue Objekt. Zeigervergleich mit == unterscheidet keine Generationen. Ohne transparentes Ersetzen ist diese Umleitung nicht garantiert; verwende den bei der Konstruktion zurückgegebenen Zeiger. std::launder hat eigene Vorbedingungen und prüft keine logische Identität.

Das Beispiel sucht begrenzt linear: create prüft höchstens N Plätze (schlimmstenfalls O(N)) und liefert std::nullopt, wenn keiner nutzbar ist. Es ist weder ein Allokator mit konstanter Laufzeit noch eine Implementierung der Standard-Allokatorschnittstelle. get und erase prüfen Index, Generation und ob das Objekt lebt. Nach Nutzung der maximalen Generation wird der Platz beim Löschen ausgemustert, sodass der Zähler nicht überläuft.

Handles gelten nur für dieselbe noch existierende Poolinstanz. Ein zurückgegebener roher Zeiger ist geliehen: Er verlängert die Objektlebensdauer nicht und führt später keine Prüfungen aus. Bei gemeinsamer Nutzung durch mehrere Threads müssen Pooloperationen und Zugriffe über geliehene Zeiger extern synchronisiert werden.

Beispiele

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

Ergebnis

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

Nachdem beide Plätze belegt sind, zerstört das Programm das erste Objekt und konstruiert `Item{40}` am selben Platz. Erst dann vergleicht es die Zeiger. Trotz gleicher Adresse wird das alte Handle abgewiesen.

Zugehörige Lektionen

  • C++ · Lektion 19 · Fortgeschritten · Version: 3

Quellen