Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

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