Stack e heap in C: durata, puntatori pendenti e quando usare l'uno o l'altro

Ogni variabile di un programma C vive da qualche parte, e il dove determina due cose che poi non puoi più cambiare: quanto sopravvive e quanta ne puoi avere. Il C ti offre tre regioni di memoria, e scegliere quella sbagliata produce un crash o un leak. Questa pagina le presenta e mostra il classico bug che nasce dallo sbagliare la durata.

Le tre regioni

  indirizzi alti
  +---------------------------+
  |  stack                    |  locali, parametri, indirizzi di ritorno
  |    cresce verso il basso  |  liberato in automatico al ritorno
  |                    v      |
  +---------------------------+
  |      (spazio inutilizzato)|
  +---------------------------+
  |                    ^      |
  |    cresce verso l'alto    |
  |  heap                     |  blocchi di malloc / calloc / realloc
  +---------------------------+  liberati solo da free()
  |  dati statici / globali   |  globali e static, per tutta l'esecuzione
  +---------------------------+
  |  codice (text)            |  il codice macchina, di sola lettura
  +---------------------------+
  indirizzi bassi

• La memoria automatica (lo stack) contiene i parametri delle funzioni e le locali non static. Un blocco di stack viene riservato quando si entra in una funzione e rilasciato quando questa restituisce. La dimensione è fissata in compilazione.
• La memoria dinamica (l'heap) contiene tutto ciò che arriva da malloc, calloc e realloc. La dimensione si decide a runtime; la durata finisce solo con free.
• La memoria statica contiene le globali e tutto ciò che è dichiarato static. Esiste per tutta l'esecuzione del programma e viene inizializzata a zero prima che parta main.

Gli indirizzi del diagramma sono la disposizione abituale, non una garanzia: lo standard descrive le durate, non la disposizione.

La memoria automatica in azione

#include <stdio.h>

void demo(void) {
    int local = 42;             /* creata qui */
    int table[4] = {1, 2, 3, 4};

    printf("local = %d, table[0] = %d\n", local, table[0]);
}                               /* entrambe rilasciate qui */

int main(void) {
    demo();
    demo();
    return 0;
}

Ogni chiamata a demo riceve un local nuovo e un table nuovo. Non si libera nulla a mano, non può esserci nessun leak e l'allocazione costa una sola istruzione che sposta lo stack pointer. Ecco perché le normali variabili locali dovrebbero essere la tua scelta predefinita: sono la memoria più veloce e più sicura che il C abbia.

Il problema è la graffa di chiusura. Una volta superata, quella memoria non c'è più.

Il puntatore pendente

Ecco il bug che ogni programmatore C scrive almeno una volta:

/* SBAGLIATO: restituisce l'indirizzo di memoria che non esiste piu */
int *make_counter(void) {
    int count = 0;
    return &count;          /* count muore a questa graffa */
}

int main(void) {
    int *p = make_counter();
    *p = 5;                 /* scrittura in uno stack frame morto */
    return 0;
}

&count era un indirizzo perfettamente valido mentre make_counter era in esecuzione. Al ritorno, quello spazio di stack passa alla prossima funzione chiamata, quindi ora p punta dentro le variabili locali di qualcun altro. Leggere dà spazzatura; scrivere le corrompe. GCC e Clang avvisano proprio per questa forma (-Wreturn-local-addr), quindi compila con gli avvisi attivi.

Con gli array lo stesso bug si traveste, e lì l'avviso spesso non scatta:

#include <stdio.h>
#include <string.h>

/* Corretto: e il chiamante a fornire la memoria, quindi sopravvive alla chiamata. */
void make_greeting(char *out, size_t size, const char *name) {
    snprintf(out, size, "Ciao, %s!", name);
}

int main(void) {
    char message[64];
    make_greeting(message, sizeof message, "Ada");
    printf("%s\n", message);
    return 0;
}

La versione sbagliata di quella funzione costruirebbe il testo in un char buf[64] locale e farebbe return buf;, restituendo l'indirizzo di un buffer che smette di esistere nello stesso istante.

Tre modi per correggerlo

1. Il chiamante fornisce il buffer (come sopra). Nessuna allocazione, nessuna questione di proprietà, ed è lo stile più comune nelle librerie C. La funzione riceve la dimensione così da restarci dentro.

2. Restituisci memoria dell'heap, e di' chi la libera.

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

/* Restituisce una stringa appena allocata; il chiamante deve liberarla. */
char *make_greeting(const char *name) {
    size_t size = strlen(name) + 16;
    char *out = malloc(size);
    if (out == NULL) {
        return NULL;
    }
    snprintf(out, size, "Ciao, %s!", name);
    return out;
}

int main(void) {
    char *message = make_greeting("Ada");
    if (message == NULL) {
        return 1;
    }
    printf("%s\n", message);
    free(message);
    return 0;
}

Il blocco dell'heap sopravvive alla funzione per progetto: è proprio lo scopo della memoria dinamica. Il prezzo è il commento sulla proprietà e il free del chiamante.

3. Usa la memoria statica, quando un unico buffer condiviso è accettabile:

#include <stdio.h>

int *next_id(void) {
    static int id = 0;      /* una sola istanza, vive per tutto il programma */
    id++;
    return &id;             /* sicuro: la memoria statica non sparisce mai */
}

int main(void) {
    printf("%d\n", *next_id());
    printf("%d\n", *next_id());
    printf("%d\n", *next_id());
    return 0;
}

static dentro una funzione mantiene locale lo scope della variabile ma le dà la durata del programma, quindi restituirne l'indirizzo è lecito. Il compromesso è che ne esiste sempre una sola: tutti i chiamanti la condividono, il che rende questo schema inutilizzabile nel codice multithread e sorprendente anche in quello a thread singolo quando due chiamanti tengono il puntatore nello stesso momento.

Dimensione: dove finisce lo stack

Lo spazio di stack è piccolo e fisso. Il thread principale di solito riceve 1 MB su Windows e 8 MB su Linux; un thread creato in seguito spesso riceve molto meno. L'heap è limitato dalla memoria disponibile nel sistema.

void bad(void) {
    int huge[1000000];      /* ~4 MB di stack: probabile crash appena si entra */
    huge[0] = 1;
}

Non c'è alcuna diagnostica e nessun NULL da controllare: il programma muore e basta, di solito con un segmentation fault, prima che venga eseguita la prima riga del corpo. La versione con l'heap segnala l'errore come si deve:

#include <stdio.h>
#include <stdlib.h>

int main(void) {
    size_t n = 1000000;

    int *huge = malloc(n * sizeof *huge);
    if (huge == NULL) {
        fprintf(stderr, "impossibile allocare %zu int\n", n);
        return 1;
    }

    huge[0] = 1;
    huge[n - 1] = 2;
    printf("%d ... %d (%zu bytes)\n", huge[0], huge[n - 1], n * sizeof *huge);

    free(huge);
    return 0;
}

Una ricorsione profonda esaurisce lo stack allo stesso modo, un frame alla volta: in pratica, una funzione ricorsiva senza freni è la causa più comune di stack overflow.

Costo e località

Allocare sullo stack è una singola operazione aritmetica su un registro. Allocare sull'heap è una chiamata di libreria che cerca un blocco adatto, può prendere un lock e ogni tanto chiede altra memoria al sistema operativo. In un ciclo molto usato la differenza si misura.

I dati sullo stack sono anche compatti e usati di recente, quindi tendono a stare in cache. I blocchi dell'heap possono essere sparsi. Nessuno dei due fatti dovrebbe guidare da solo un progetto, perché prima viene la correttezza della durata, ma tra due progetti entrambi corretti quello basato sullo stack di solito è il più veloce.

Vedere le regioni

Stampare gli indirizzi rende concreta la disposizione. I valori esatti cambiano a ogni esecuzione (i sistemi moderni li rendono casuali), ma i raggruppamenti si vedono:

#include <stdio.h>
#include <stdlib.h>

int global_value = 1;

int main(void) {
    static int static_value = 2;
    int local_value = 3;

    int *heap_value = malloc(sizeof *heap_value);
    if (heap_value == NULL) {
        return 1;
    }
    *heap_value = 4;

    printf("globale: %p\n", (void *)&global_value);
    printf("statica: %p\n", (void *)&static_value);
    printf("heap:    %p\n", (void *)heap_value);
    printf("locale:  %p\n", (void *)&local_value);

    free(heap_value);
    return 0;
}

La globale e la statica stanno una accanto all'altra; il blocco dell'heap è altrove; la locale di solito è lontana da entrambe. Fai il cast a void * per %p: è quello che richiede lo specificatore di formato.

Come scegliere

Usa lo stack quando:

• la dimensione è nota in compilazione,
• i dati servono solo dentro questa funzione e quelle che chiama,
• e sono piccoli: qualche kilobyte, non megabyte.

Usa l'heap quando:

• la dimensione dipende dall'input, da un file o da un calcolo,
• i dati devono sopravvivere alla funzione che li ha creati,
• oppure sono abbastanza grandi da mettere a rischio il limite dello stack.

Usa la memoria statica quando:

• deve esistere esattamente un'istanza per tutto il programma,
• e condividerla tra tutti i chiamanti è davvero corretto.

La scelta predefinita è lo stack. Passa all'heap quando vale uno dei suoi tre motivi e, quando lo fai, segui le regole di proprietà descritte nella pagina sui memory leak, così che il blocco a cui hai dato una durata venga comunque rilasciato.

Due bug speculari

Vale la pena nominarli insieme, perché sono la stessa domanda sulla durata con due risposte diverse:

• Puntatore pendente: la memoria è morta prima del puntatore. Restituire &local o usare un puntatore dopo free. Il programma legge o scrive memoria che ora appartiene a qualcos'altro.
• Memory leak: il puntatore è morto prima della memoria. Perdere l'ultimo riferimento a un blocco di malloc. Niente si rompe subito; il processo semplicemente cresce.

Entrambi nascono da una discrepanza tra quanto a lungo devono vivere i dati e la regione in cui li hai messi. Decidi prima la durata, e la regione viene di conseguenza.