CKTIS / C++
Zbirka objektov, arena in zastareli kazalci ob ponovni uporabi naslova
Zbirka znova uporabi posamezne reže, monotona arena pa sprošča pomnilnik v celoti. Identifikator s številko generacije loči zaporedna objekta na istem naslovu.
Različica: ISO C++23; implementation support may vary
Sintaksa
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 lahko zbirka objektov s fiksno zmogljivostjo hrani objekte istega tipa v režah fiksne velikosti. Življenjska doba se upravlja za vsako režo posebej: umestitveni ::new konstruira objekt v dovolj velikem in pravilno poravnanem pomnilniku, std::destroy_at pa objekt uniči, ne da bi sprostil režo. Destruktor zbirke uniči vse še žive objekte.
Monotona arena, kot je std::pmr::monotonic_buffer_resource, združuje dodelitve iz ene faze. Posamična sprostitev nima učinka; release() vrne bloke nadrejenemu pomnilniškemu viru in obnovi začetno stanje vira. Pri tem se destruktorji uporabniških objektov ne kličejo. Objekte in vsebnike, ki ta pomnilnik še uporabljajo, uniči pred ponastavitvijo ali uničenjem vira.
Med uničenjem in ponovno konstrukcijo ne dostopaj do objekta prek starega kazalca. Pri transparentni zamenjavi, kot pri dveh popolnih objektih Item brez const na povsem istem mestu, stari kazalec samodejno kaže na novi objekt. Primerjava kazalcev z == ne loči generacij. Če zamenjava ni transparentna, ne predpostavljaj samodejne preusmeritve; uporabi kazalec, ki ga vrne konstrukcija. std::launder ima svoje predpogoje in ne preverja logične identitete.
Primer uporablja omejeno linearno iskanje: create pregleda največ N rež (O(N) v najslabšem primeru) in vrne std::nullopt, če nobena ni uporabna. To ni niti alokator s konstantnim časom niti implementacija standardnega vmesnika alokatorja. get in erase preverita indeks, generacijo in prisotnost živega objekta. Ko je najvišja generacija porabljena, se reža ob odstranitvi objekta neha uporabljati, da se števec ne vrne na nič.
Identifikatorje uporabljaj samo z istim, še obstoječim primerkom zbirke. Vrnjeni surovi kazalec je izposojen: ne podaljša življenjske dobe objekta in ne izvaja poznejših preverjanj. Če si zbirko deli več niti, zunanje sinhroniziraj operacije zbirke in dostope prek izposojenih kazalcev.
Primeri
#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';
}Rezultat
full: true same address: true stale handle rejected: true fresh value: 40
Ko sta obe reži zasedeni, program uniči prvi objekt in v isti reži konstruira `Item{40}`. Kazalca primerja šele po ponovni konstrukciji; stari identifikator je zavrnjen kljub istemu naslovu.
Povezane lekcije
- C++ · Lekcija 19 · Napredna · Različica: 3
Viri
- 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]