CKTIS / C++
Пул от обекти, арена и остарели указатели при повторно използване на адрес
Пулът използва повторно отделни слотове, а монотонната арена освобождава паметта наведнъж. Идентификатор с номер на поколение различава последователни обекти на един и същ адрес.
Версия: ISO C++23; implementation support may vary
Синтаксис
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>`).В C++23 пул от обекти с фиксиран капацитет може да съхранява обекти от един тип в слотове с фиксиран размер. Жизненият цикъл се управлява за всеки слот поотделно: позициониращият ::new конструира обекта в памет с подходящ размер и подравняване, а std::destroy_at го унищожава, без да освобождава паметта на слота. Деструкторът на пула унищожава останалите живи обекти.
Монотонна арена, например std::pmr::monotonic_buffer_resource, групира заделянията на памет за един етап. Освобождаването на отделен блок няма ефект; release() връща блоковете на горестоящия ресурс и възстановява началното състояние на ресурса. Не извиква деструкторите на потребителските обекти. Унищожи обектите и контейнерите, които още използват тази памет, преди да възстановиш началното състояние на ресурса или да го унищожиш.
Между унищожаването и повторното конструиране не достъпвай обекта чрез стария указател. При прозрачна замяна, както при два пълни обекта Item без const на точно едно и също място, старият указател автоматично сочи към новия обект. Сравнението на указатели с == не различава поколенията. Ако замяната не е прозрачна, не разчитай на автоматично пренасочване; използвай указателя, върнат при конструирането. std::launder има свои предусловия и не проверява логическата идентичност.
Примерът използва ограничено линейно търсене: create проверява най-много N слота (O(N) в най-лошия случай) и връща std::nullopt, ако няма използваем слот. Това не е алокатор с константно време, нито реализация на стандартния интерфейс за алокатори. get и erase проверяват индекса, поколението и наличието на жив обект. След използване на максималното поколение слотът се изважда от употреба при изтриване, за да не се върне броячът на нула.
Използвай идентификаторите само със същата, все още съществуваща инстанция на пула. Върнатият суров указател е предоставен назаем: не удължава живота на обекта и не извършва последващи проверки. Ако няколко нишки споделят пула, синхронизирай външно операциите върху него и достъпа чрез указателите, предоставени назаем.
Примери
#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';
}Резултат
full: true same address: true stale handle rejected: true fresh value: 40
След запълването на двата слота програмата унищожава първия обект и конструира `Item{40}` в същия слот. Сравнява указателите едва след повторното конструиране; старият идентификатор се отхвърля въпреки съвпадението на адреса.
Свързани уроци
- C++ · Урок 19 · Напреднало · Версия: 3
Източници
- 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]