CKTIS / C++
Durata di memorizzazione automatica e allocazione dinamica
Distingui la durata di memorizzazione e il tempo di vita di un oggetto dalle allocazioni separate dei suoi membri, ad esempio quelle per i caratteri di uno `std::string`.
Versione: ISO C++23; implementation support may vary
Sintassi
T local{args...}; // Direct declaration; automatic in an ordinary block.
std::unique_ptr<T> owner = std::make_unique<T>(args...); // The local owner and its dynamically created T are separate objects.
owner.reset(); // Destroy the owned T; owner remains alive and becomes empty.In C++23, la durata di memorizzazione indica per quanto tempo la memoria di un oggetto può rimanere disponibile; il tempo di vita indica quando esiste l’oggetto stesso. Una normale variabile di blocco dichiarata senza static, thread_local o extern ha durata di memorizzazione automatica. Un oggetto di tipo classe già costruito viene distrutto all’uscita dal blocco, anche durante lo svolgimento dello stack dovuto a un’eccezione. Questa regola del linguaggio non impone di collocare l’oggetto su uno stack fisico.
std::make_unique<Record>() crea un Record mediante un’espressione new e restituisce uno std::unique_ptr<Record> che ne ha la proprietà esclusiva. Nell’esempio, owner ha durata di memorizzazione automatica, ma il Record che possiede ha durata di memorizzazione dinamica e sopravvive all’uscita dal blocco interno. owner.reset() distrugge quel Record e ne libera la memoria; owner continua a esistere, ma è vuoto. Non usare un puntatore o un riferimento per accedere a un oggetto distrutto.
Il membro Record::text ha la stessa durata di memorizzazione del Record che lo contiene. La memoria per i caratteri è una questione separata: std::string può ottenerla tramite il proprio allocatore quando serve. L’ottimizzazione per le stringhe corte (SSO) può conservare i caratteri nell’oggetto stringa stesso, ma C++23 non impone né la SSO né una soglia di lunghezza specifica.
«Stack o heap» è una scorciatoia informale, non una garanzia di collocazione fisica. Preferisci un oggetto locale dichiarato direttamente quando il suo tempo di vita deve terminare con il blocco e std::unique_ptr quando un oggetto separato, creato dinamicamente, richiede un proprietario esclusivo.
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.assign(1000, 'x');
std::cout << local.text.size() << ' ' << owner->text.size() << '\n';
}
std::cout << owner->text.size() << '\n';
owner.reset();
std::cout << (owner ? "owns a record" : "empty") << '\n';
}Risultato
3 1000 1000 empty
Se l’allocazione e l’output riescono, il programma stampa entrambe le lunghezze, poi di nuovo la lunghezza della stringa dell’oggetto posseduto dopo il blocco interno e infine `empty` dopo `reset()`. L’output non mostra indirizzi né conta le allocazioni.
Lezioni correlate
- C++ · Lezione 22 · Avanzato · Versione: 3
Fonti
- N4950 — Working Draft, Standard for Programming Language C++ (C++23)
- Automatic storage duration [basic.stc.auto]
- Storage duration — General [basic.stc.general]
- Lifetime [basic.life]
- Declaration statement [stmt.dcl]
- New [expr.new]
- unique_ptr creation [unique.ptr.create]
- unique_ptr modifiers for single objects [unique.ptr.single.modifiers]
- basic_string general requirements [string.require]