CKTIS / C++
Pool d’objets, arène et pointeurs périmés après réutilisation d’une adresse
Un pool réutilise ses emplacements un par un, tandis qu’une arène monotone récupère la mémoire en bloc. Un identifiant avec numéro de génération distingue deux objets successifs à la même adresse.
Version : ISO C++23; implementation support may vary
Syntaxe
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>`).En C++23, un pool d’objets à capacité fixe peut stocker des objets d’un même type dans des emplacements de taille fixe. La durée de vie est gérée par emplacement : le ::new de placement construit l’objet dans une zone de taille et d’alignement suffisants, et std::destroy_at le détruit sans libérer l’emplacement. Le destructeur du pool détruit les objets encore vivants.
Une arène monotone, telle que std::pmr::monotonic_buffer_resource, regroupe les allocations d’une phase. La désallocation individuelle ne fait rien ; release() rend les blocs à la ressource amont et rétablit l’état initial de la ressource. Cette opération n’appelle pas les destructeurs des objets de l’utilisateur. Détruisez les objets et conteneurs qui utilisent encore cette mémoire avant de réinitialiser ou de détruire la ressource.
Entre la destruction et la reconstruction, n’accédez pas à l’objet par l’ancien pointeur. En cas de remplacement transparent, comme pour deux objets Item complets et non const au même emplacement exact, l’ancien pointeur désigne automatiquement le nouvel objet. La comparaison == des pointeurs ne distingue pas les générations. Sans remplacement transparent, ne supposez pas que le pointeur change de cible : utilisez celui renvoyé par la construction. std::launder a ses propres préconditions et ne vérifie pas l’identité logique.
L’exemple effectue un parcours linéaire borné : create examine au plus N emplacements (O(N) au pire) et renvoie std::nullopt si aucun n’est utilisable. Ce n’est ni un allocateur à temps constant ni une implémentation de l’interface d’allocateur standard. get et erase vérifient l’indice, la génération et la présence d’un objet vivant. Après utilisation de la génération maximale, l’emplacement est retiré à la suppression pour empêcher le compteur de revenir à zéro.
Utilisez chaque identifiant uniquement avec la même instance du pool, tant qu’elle existe. Un pointeur brut renvoyé est emprunté : il ne prolonge pas la durée de vie de l’objet et ne fait aucune vérification ultérieure. En cas de partage entre threads, synchronisez extérieurement les opérations du pool et les accès par les pointeurs empruntés.
Exemples
#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';
}Résultat
full: true same address: true stale handle rejected: true fresh value: 40
Une fois les deux emplacements occupés, le programme détruit le premier objet et construit `Item{40}` au même endroit. Il compare les pointeurs seulement après la reconstruction ; l’ancien identifiant est rejeté malgré l’adresse identique.
Leçons associées
- C++ · Leçon 19 · Avancé · Version : 3
Sources
- 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]