C++ Academy · Lezione

Allocazione nello stack

Come funziona la memoria automatica

Allocazione nello stack è una lezione C++ Academy gratuita su CoddyKit. Questa è la lezione 1 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento C++ Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso C++ Academy include 4 lezioni in totale.

Memoria automatica

Le variabili locali risiedono nella memoria automatica, comunemente chiamata stack. Vengono create quando l'esecuzione entra nel loro scope e distrutte quando ne esce.

#include <iostream>

int main() {
    int x = 42;          // on the stack
    double pi = 3.14;    // on the stack
    std::cout << x << " " << pi << "\n";
}

Lo stack cresce e si riduce

Ogni chiamata di funzione inserisce un frame dello stack che contiene le variabili locali. Quando la funzione restituisce il controllo, il frame viene rimosso e le variabili locali scompaiono: non è necessaria alcuna pulizia manuale.

#include <iostream>

void greet() {
    int local = 7;          // pushed on call
    std::cout << local << "\n";
}                            // popped on return

int main() { greet(); }

Ordinamento LIFO

Lo stack segue l'ordine Last In, First Out. L'elemento locale creato più recentemente è il primo a essere distrutto quando termina lo scope.

#include <iostream>

int main() {
    int a = 1;
    {
        int b = 2;   // created after a
        std::cout << b << "\n";
    }                // b destroyed first
    std::cout << a << "\n";
}

Veloce ed economica

L'allocazione sullo stack è estremamente veloce: sposta semplicemente il puntatore dello stack. Non è necessario cercare memoria libera né mantenere informazioni di gestione come avviene con lo heap.

Lo scope determina il lifetime

Un oggetto sullo stack è valido solo all'interno del blocco in cui viene dichiarato. I blocchi annidati hanno un proprio scope.

#include <iostream>

int main() {
    for (int i = 0; i < 3; ++i) {
        int square = i * i;   // recreated each iteration
        std::cout << square << "\n";
    }
}

Dimensioni limitate

Lo stack ha una dimensione fissa e limitata, spesso di pochi megabyte. Allocare array enormi sullo stack può causare un crash per stack overflow.

// Risky: a large fixed array on the stack
int big[1000000];   // may overflow the stack

Restituire un indirizzo dello stack è un bug

Non restituisca mai un puntatore o un riferimento a una variabile locale. Quando la funzione restituisce il controllo, quella memoria non è più disponibile e il puntatore diventa dangling.

int* bad() {
    int local = 5;
    return &local;   // BUG: local dies here
}

Passare oggetti grandi per riferimento

Copiare oggetti grandi nello stack è uno spreco. Li passi tramite const& per evitare la copia e mantenere ridotto l'uso dello stack.

#include <string>

void print(const std::string& s) {  // no copy
    // use s
}

Gli oggetti nello stack non richiedono delete

Poiché il compilatore ne gestisce automaticamente la durata, non deve mai chiamare delete su una variabile nello stack.

#include <iostream>

int main() {
    int n = 10;
    // delete &n;   // ERROR: not heap-allocated
    std::cout << n << "\n";
}

Array nello stack

Gli array di dimensione fissa e lunghezza nota risiedono nello stack e vengono rilasciati automaticamente quando termina l'ambito.

#include <iostream>

int main() {
    int values[3] = {10, 20, 30};
    for (int v : values) std::cout << v << "\n";
}

Quando preferire lo stack

Preferisca lo stack per gli oggetti piccoli e di breve durata, la cui dimensione è nota al momento della compilazione. È più veloce e si libera automaticamente: ricorra all'heap solo quando ne ha davvero bisogno.

Verifica rapida

Verifichi la sua comprensione dell'allocazione nello stack.

Riepilogo

Ha imparato che l'allocazione nello stack usa una memoria automatica legata all'ambito: le variabili vengono create all'ingresso e distrutte all'uscita, in ordine LIFO. È veloce, si libera automaticamente e ha dimensioni limitate. Non restituisca mai gli indirizzi di variabili locali e non usi mai delete sugli oggetti nello stack.

Domande Frequenti

La lezione «Allocazione nello stack» è gratuita?

Sì — il testo completo di «Allocazione nello stack» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso C++ Academy, passa a CoddyKit PRO. Il corso C++ Academy include 4 lezioni in totale.

Cosa imparerò in «Allocazione nello stack»?

Come funziona la memoria automatica Eserciti C++ Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare C++ Academy?

Non è richiesta alcuna esperienza precedente. C++ Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 1 di 4.

Quanto tempo richiede la lezione «Allocazione nello stack»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione C++ Academy?

Sì. Ogni lezione C++ Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

← Torna a C++ Academy