Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

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

Fonti