CKTIS / C++
Pool de objetos, arena e ponteiros obsoletos após reutilização de endereços
Um pool reutiliza ranhuras individuais; uma arena monótona recupera memória em bloco. Um identificador com número de geração distingue objetos sucessivos no mesmo endereço.
Versão: ISO C++23; implementation support may vary
Sintaxe
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>`).Em C++23, um pool de objetos de capacidade fixa pode guardar objetos de um só tipo em ranhuras de tamanho fixo. O tempo de vida é gerido por ranhura: o ::new de colocação constrói em memória com tamanho e alinhamento adequados, e std::destroy_at destrói o objeto sem libertar a ranhura. O destrutor do pool destrói os objetos ainda vivos.
Uma arena monótona, como std::pmr::monotonic_buffer_resource, agrupa as alocações de uma fase. A desalocação individual não tem efeito; release() devolve os blocos ao recurso a montante e repõe o estado inicial do recurso. Não chama os destrutores dos objetos do utilizador. Destrói os objetos e contentores que ainda usam essa memória antes de repor ou destruir o recurso.
Entre a destruição e a reconstrução, não acedas ao objeto através do ponteiro antigo. Com substituição transparente, como no caso de dois objetos Item completos e não const exatamente no mesmo local, o ponteiro antigo passa automaticamente a referir-se ao novo objeto. A comparação == de ponteiros não distingue gerações. Se a substituição não for transparente, não assumas que isso acontece; usa o ponteiro devolvido pela construção. std::launder tem as suas próprias pré-condições e não verifica a identidade lógica.
O exemplo faz uma pesquisa linear limitada: create examina no máximo N ranhuras (O(N) no pior caso) e devolve std::nullopt se nenhuma for utilizável. Não é um alocador de tempo constante nem uma implementação da interface normalizada de alocadores. get e erase verificam o índice, a geração e se há um objeto vivo. Depois de usada a geração máxima, a ranhura é retirada aquando da remoção do objeto, para que o contador não volte a zero.
Usa os identificadores apenas com a mesma instância do pool enquanto esta existir. Um ponteiro simples devolvido é emprestado: não prolonga o tempo de vida do objeto nem faz verificações posteriores. Se o pool for partilhado entre threads, sincroniza externamente tanto as operações do pool como os acessos por ponteiros emprestados.
Exemplos
#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';
}Resultado
full: true same address: true stale handle rejected: true fresh value: 40
Depois de preencher as duas ranhuras, o programa destrói o primeiro objeto e constrói `Item{40}` na mesma ranhura. Só compara os ponteiros depois da reconstrução; o identificador antigo é rejeitado apesar de o endereço ser o mesmo.
Lições relacionadas
- C++ · Lição 19 · Avançado · Versão: 3
Fontes
- 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]