CKTIS / C++
Memoria: proprietà, copie e durata di vita degli oggetti
Distingui lo spazio di memoria, l’oggetto che lo occupa e la responsabilità per la risorsa. Scopri la durata di memorizzazione automatica e dinamica, la semantica della copia, il placement new, la distruzione esplicita e lo strict aliasing.
Versione: C++23; repository compiler flag, production runtime not attested
Sintassi
T copy = original; T* alias = &original; T* p = ::new (static_cast<void*>(storage)) T{args}; p->~T();La memoria offre spazio ai dati; la durata di vita riguarda l’oggetto che lo occupa. Di norma inizia quando lo spazio è sufficiente, ben allineato e l’inizializzazione è conclusa. Per un oggetto di classe termina all’inizio della chiamata al distruttore; anche liberare o riusare lo spazio può farla terminare. Un indirizzo valido non basta per accedere all’oggetto.
Durata di memorizzazione. Determina la disponibilità dello spazio. Per una normale variabile locale è automatica, fino all’uscita dal blocco. Gli oggetti creati da new con allocazione hanno durata dinamica e possono sopravvivere al blocco. Un std::unique_ptr locale può avere durata automatica e il suo oggetto durata dinamica. Stack e heap sono modelli tipici di implementazione, non definizioni.
Proprietà. Significa dover liberare la risorsa. Usa RAII: se ne occupa il distruttore del proprietario. std::unique_ptr si può spostare ma non copiare. Copiare un puntatore grezzo copia l’indirizzo, non l’oggetto né il dovere di eliminarlo. La copia predefinita di una classe copia i membri; un membro puntatore mantiene la destinazione. La copia non è per forza profonda; due proprietari indipendenti dello stesso indirizzo rischiano una doppia eliminazione.
Placement new. In ::new (storage) T{args}, il :: iniziale limita all’ambito globale la ricerca della funzione di allocazione, ma non impone la scelta dell’overload standard che accetta un void*. Un overload globale più adatto al tipo di storage può allocare memoria. L’esempio usa la forma ::new (static_cast<void*>(storage)) T{args} con il tipo Item: viene selezionato l’overload standard che non alloca memoria e l’oggetto viene costruito nello spazio fornito. La conversione a void* da sola non garantisce questa scelta per qualsiasi T. Se T richiede un allineamento superiore a quello predefinito per new (alignof(T) > __STDCPP_DEFAULT_NEW_ALIGNMENT__), al primo passaggio della risoluzione dell’overload viene considerato un argomento di tipo std::align_val_t prima dell’argomento di placement. Un overload globale applicabile operator new(std::size_t, std::align_val_t, void*) può quindi essere selezionato al posto dell’overload standard che non alloca memoria. Lo spazio deve essere sufficiente e correttamente allineato. p->~T() distrugge esplicitamente l’oggetto senza liberare lo spazio. Non usare delete per oggetti in un buffer locale. Non distruggere due volte un oggetto: distrutta esplicitamente una normale variabile locale con distruttore non banale, ricostruisci correttamente un oggetto del tipo originale prima della distruzione automatica.
Strict aliasing. Limita i tipi per leggere o modificare il valore di un oggetto. reinterpret_cast non rende lecito un accesso con tipo incompatibile. char, unsigned char e std::byte danno accesso alla rappresentazione senza sostituire le regole di durata di vita. L’esempio usa un sottoinsieme compatibile con C++23; l’URL dello standard porta alla bozza in evoluzione, non all’edizione C++23 fissata.
Identificatori di riferimento trattati in questa voce: Object lifetime, placement new, explicit destruction and strict aliasing, Automatic and dynamic storage duration.
Esempi
#include <cstddef>
#include <iostream>
#include <memory>
#include <new>
struct Item {
int value;
~Item() {}
};
int main() {
Item original{7};
Item copy = original;
Item* alias = &original;
alias->value = 9;
auto owner = std::make_unique<Item>();
owner->value = 11;
alignas(Item) std::byte storage[sizeof(Item)];
Item* placed = ::new (static_cast<void*>(storage)) Item{13};
std::cout << original.value << ' ' << copy.value << ' '
<< owner->value << ' ' << placed->value << '\n';
placed->~Item();
}
Risultato
9 7 11 13
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.