Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / C++

Pool di oggetti, arena e puntatori obsoleti dopo il riuso dell’indirizzo

Un pool riusa i singoli slot; un’arena monotona recupera la memoria in blocco. Un handle con numero di generazione distingue oggetti successivi allo stesso indirizzo.

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

Sintassi

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 un pool di oggetti a capacità fissa può contenere oggetti dello stesso tipo in slot di dimensione fissa. La durata di vita è gestita per slot: il ::new di piazzamento costruisce in memoria di dimensione e allineamento adeguati, mentre std::destroy_at distrugge l’oggetto senza liberare lo slot. Il distruttore del pool distrugge gli oggetti ancora in vita.

Un’arena monotona, come std::pmr::monotonic_buffer_resource, raggruppa le allocazioni di una fase. La deallocazione individuale non fa nulla; release() restituisce i blocchi alla risorsa a monte e ripristina lo stato iniziale della risorsa. Non invoca i distruttori degli oggetti dell’utente. Distruggi gli oggetti e i contenitori che usano ancora quella memoria prima di ripristinare o distruggere la risorsa.

Tra distruzione e ricostruzione, non accedere all’oggetto tramite il vecchio puntatore. Con la sostituzione trasparente, come nel caso di due oggetti Item completi e non const esattamente nella stessa posizione, il vecchio puntatore si riferisce automaticamente al nuovo oggetto. Il confronto == fra puntatori non distingue le generazioni. Se la sostituzione non è trasparente, non dare per scontato questo effetto: usa il puntatore restituito dalla costruzione. std::launder ha precondizioni proprie e non verifica l’identità logica.

L’esempio usa una scansione lineare limitata: create esamina al massimo N slot (O(N) nel caso peggiore) e restituisce std::nullopt se nessuno è utilizzabile. Non è un allocatore a tempo costante e non implementa l’interfaccia standard degli allocatori. get ed erase controllano indice, generazione e presenza di un oggetto vivo. Dopo l’uso della generazione massima, lo slot viene ritirato quando l’oggetto viene rimosso, così il contatore non riparte da zero.

Usa gli handle solo con la stessa istanza del pool, finché esiste. Un puntatore grezzo restituito è in prestito: non estende la durata di vita dell’oggetto e non esegue controlli successivi. Se più thread condividono il pool, sincronizza esternamente sia le operazioni sul pool sia gli accessi tramite puntatori in prestito.

Esempi

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

Risultato

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

Dopo aver occupato entrambi gli slot, il programma distrugge il primo oggetto e costruisce `Item{40}` nello stesso slot. Confronta i puntatori solo dopo la ricostruzione; il vecchio handle viene rifiutato nonostante l’indirizzo coincida.

Lezioni correlate

  • C++ · Lezione 19 · Avanzato · Versione: 3

Fonti