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
- WG21 N4950 — Working Draft, Standard for Programming Language C++ (C++23 draft; [intro.object], [basic.life], [expr.eq])
- C++ working draft — New expressions [expr.new]
- C++ working draft — Placement forms [new.delete.placement]
- C++ working draft — destroy [specialized.destroy]
- C++ working draft — Pointer optimization barrier [ptr.launder]
- C++ working draft — Class monotonic_buffer_resource [mem.res.monotonic.buffer]
- C++ working draft — Allocator requirements [allocator.requirements]