Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

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