CKTIS / C++
Pool di oggetti, arene e riutilizzo di puntatori obsoleti
Pool e arene gestiscono la memoria, ma un indirizzo non stabilisce l’identità di un oggetto. Riutilizzare uno slot può lasciare un puntatore senza un oggetto vivo come destinazione oppure farlo riferire a un oggetto diverso. Distingui durata della memoria, durata dell’oggetto e validità degli handle a livello applicativo.
Versione: C++23; repository compiler flag, production runtime not attested
Sintassi
alignas(T) unsigned char storage[sizeof(T)]; T* p = ::new (static_cast<void*>(storage)) T{args}; p->~T();Pool o arena
Un pool di oggetti riutilizza in genere singoli slot; un’arena raggruppa le allocazioni e recupera la memoria collettivamente. std::pmr::unsynchronized_pool_resource gestisce blocchi di memoria, non oggetti applicativi. std::pmr::monotonic_buffer_resource rappresenta una strategia di tipo arena: una deallocazione individuale non recupera spazio. Una risorsa di memoria non invoca di per sé i distruttori degli oggetti memorizzati al suo interno.
Memoria e oggetto
L’Item mostrato richiede dimensioni sufficienti, allineamento corretto e inizializzazione completata. placement new costruisce un oggetto nella posizione indicata; chiamare il distruttore ne termina la durata senza liberare lo slot. Leggere stale->value tra la distruzione e la ricostruzione ha comportamento indefinito.
Stesso indirizzo, identità diversa
Nell’esempio, un nuovo Item completo sostituisce esattamente il precedente oggetto completo dello stesso tipo, che non è const. Si applica la sostituzione trasparente: stale si riferisce automaticamente al nuovo oggetto e la lettura restituisce 20. Ciò è valido secondo il linguaggio, ma può violare l’aspettativa dell’applicazione che un handle continui a identificare l’elemento originale. Non generalizzare il caso a tipi o sotto-oggetti arbitrari. std::launder ha precondizioni: non fa rivivere un oggetto distrutto né verifica l’identità logica.
Regole di implementazione
Usa il puntatore restituito dalla costruzione. Se i vecchi handle devono essere rifiutati, controlla l’occupazione dello slot e una generazione, con una politica che eviti collisioni dopo l’overflow del contatore. Gestisci le eccezioni dei costruttori, distruggi gli oggetti che richiedono pulizia prima di reimpostare un’arena e sincronizza gli accessi concorrenti. L’esempio mostra uno slot, non un pool completo. L’obiettivo di compilazione è C++23; non è attestato un ambiente di esecuzione di produzione. Le fonti fornite sono una bozza di lavoro in evoluzione, non un’edizione C++23 definitiva.
Identificatori di riferimento trattati in questa voce: Object pools, arenas and stale pointer reuse.
Esempi
#include <iostream>
#include <new>
struct Item {
int value;
~Item() noexcept {}
};
int main() {
alignas(Item) unsigned char slot[sizeof(Item)];
Item* first = ::new (static_cast<void*>(slot)) Item{10};
Item* stale = first;
std::cout << first->value << '\n';
first->~Item();
// Do not access stale->value here: no live Item exists.
Item* current = ::new (static_cast<void*>(slot)) Item{20};
std::cout << current->value << '\n';
// Transparent replacement: stale now denotes the new Item.
std::cout << stale->value << '\n';
current->~Item();
}
Risultato
10 20 20
Il codice mostrato e il risultato dichiarato sono stati verificati in un ambiente isolato con il metodo registrato nella prova di verifica di questa versione esatta.
Fonti
- C++ working draft — Lifetime [basic.life]
- C++ working draft — Pointer optimization barrier [ptr.launder]
- C++ working draft — Pool resource classes [mem.res.pool]
- C++ working draft — Class monotonic_buffer_resource [mem.res.monotonic.buffer]
- C++ working draft — Non-allocating forms [new.delete.placement]