CKTIS / C++
Stack e heap: durata di memorizzazione automatica e allocazione dinamica
C++23 definisce la durata di memorizzazione e le regole di vita degli oggetti, non la loro posizione fisica. Un oggetto automatico può contenere uno `std::string` che alloca dinamicamente memoria per i caratteri.
Versione: ISO C++23; implementation support may vary
Sintassi
struct Record { std::string text; };
std::unique_ptr<Record> owner;
{
Record local{"abc"};
owner = std::make_unique<Record>();
} // local is destroyed; the Record owned by owner remains alive
owner.reset(); // destroys the owned Record and releases its storage«Stack e heap» è una formula per indicare una scelta implementativa comune, non una disposizione fisica garantita da C++23. La durata di memorizzazione indica il periodo minimo potenziale di disponibilità della memoria di un oggetto; non coincide con il suo tempo di vita. Una comune variabile di blocco dichiarata senza static, thread_local o extern ha durata di memorizzazione automatica. Se il suo oggetto è stato costruito, viene distrutto quando si esce dal blocco, anche durante lo svolgimento dello stack dovuto a un’eccezione.
std::make_unique<Record>() crea un Record separato con durata di memorizzazione dinamica. La variabile locale owner può avere a sua volta durata di memorizzazione automatica, mentre l’oggetto gestito può sopravvivere al blocco che lo ha creato. Quando owner viene distrutto, il suo deleter predefinito distrugge l’oggetto che possiede ancora e ne rilascia la memoria. Questo è RAII: l’oggetto proprietario gestisce la risorsa. Non restituire puntatori o riferimenti a un oggetto locale che sarà distrutto al ritorno dalla funzione.
Il membro text è un sotto-oggetto std::string con la stessa durata di memorizzazione del Record che lo contiene. La memoria per i caratteri è un aspetto distinto: la stringa usa il proprio allocatore quando serve. Un’implementazione può conservare stringhe corte all’interno dell’oggetto stringa (SSO), ma C++23 non garantisce né questa ottimizzazione né una soglia. Un Record automatico, quindi, non esclude allocazioni dinamiche.
Esempi
#include <iostream>
#include <memory>
#include <string>
struct Record {
std::string text;
};
int main() {
std::unique_ptr<Record> owner;
{
Record local{"abc"};
owner = std::make_unique<Record>();
owner->text = "hello";
std::cout << "local: " << local.text.size() << '\n';
}
std::cout << "owned: " << owner->text.size() << '\n';
}
Risultato
local: 3 owned: 5
`local` viene distrutto all’uscita dal blocco interno. La seconda riga si può comunque stampare, perché `owner` possiede l’altro `Record` fino alla fine di `main`. L’output non indica la posizione fisica né il numero di allocazioni.
Lezioni correlate
- C++ · Lezione 22 · Avanzato · Versione: 3