Stack gegen Heap in C: Lebensdauern, baumelnde Zeiger und wann man was nimmt

Jede Variable in einem C-Programm lebt irgendwo, und wo bestimmt zwei Dinge, die du danach nicht mehr ändern kannst: wie lange sie überlebt und wie viel davon du haben kannst. C gibt dir drei Speicherbereiche, und falsch zu wählen erzeugt entweder einen Absturz oder ein Leck. Diese Seite legt sie aus und zeigt den klassischen Bug, der aus falschen Lebensdauern entsteht.

Die drei Bereiche

  hohe Adressen
  +---------------------------+
  |  Stack                    |  Lokale, Parameter, Rücksprungadressen
  |    wächst nach unten |    |  bei Rückkehr automatisch freigegeben
  |                      v    |
  +---------------------------+
  |         (ungenutzte Lücke)|
  +---------------------------+
  |                      ^    |
  |    wächst nach oben  |    |
  |  Heap                     |  malloc- / calloc- / realloc-Blöcke
  +---------------------------+  nur durch free() freigegeben
  |  statische/globale Daten  |  Globale und Statics, ganzer Lauf
  +---------------------------+
  |  Code (Text)              |  der Maschinencode, nur lesbar
  +---------------------------+
  niedrige Adressen

• Automatischer Speicher (der Stack) hält Funktionsparameter und nicht-statische Lokale. Ein Stück Stack wird beim Betreten einer Funktion beansprucht und bei ihrer Rückkehr freigegeben. Die Größe steht zur Übersetzungszeit fest.
• Dynamischer Speicher (der Heap) hält alles aus malloc, calloc und realloc. Die Größe wird zur Laufzeit bestimmt; die Lebensdauer endet erst bei free.
• Statischer Speicher hält globale Variablen und alles, was static deklariert ist. Er existiert für den gesamten Lauf des Programms und wird vor dem Start von main mit null initialisiert.

Die Adressen im Diagramm sind die übliche Anordnung, keine Garantie - der Standard beschreibt Lebensdauern, kein Layout.

Automatischer Speicher in Aktion

#include <stdio.h>

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

    printf("local = %d, table[0] = %d\n", local, table[0]);
}                               /* beide hier freigegeben */

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

Jeder Aufruf von demo bekommt ein frisches local und ein frisches table. Nichts wird von Hand freigegeben, nichts kann lecken, und die Belegung kostet eine einzige Instruktion, die den Stackzeiger verschiebt. Deshalb sollten gewöhnliche Lokale deine Voreinstellung sein: Sie sind der schnellste und sicherste Speicher, den C hat.

Der Haken ist die schließende Klammer. Sobald sie läuft, ist dieser Speicher fort.

Der baumelnde Zeiger

Hier ist der Bug, den jeder C-Programmierer einmal schreibt:

/* KAPUTT: liefert die Adresse von Speicher, den es nicht mehr gibt */
int *make_counter(void) {
    int count = 0;
    return &count;          /* count stirbt an dieser Klammer */
}

int main(void) {
    int *p = make_counter();
    *p = 5;                 /* schreibt in einen toten Stackrahmen */
    return 0;
}

&count war eine vollkommen gültige Adresse, solange make_counter lief. Bei der Rückkehr wird dieser Stackplatz an die nächste aufgerufene Funktion gereicht, p zeigt also nun in fremde lokale Variablen. Lesen liefert Müll; Schreiben beschädigt sie. GCC und Clang warnen vor genau dieser Form (-Wreturn-local-addr), kompiliere also mit eingeschalteten Warnungen.

Derselbe Bug tarnt sich bei Arrays, und dort greift die Warnung oft nicht:

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

/* Korrekt: der Aufrufer liefert den Speicher, der den Aufruf ueberlebt. */
void make_greeting(char *out, size_t size, const char *name) {
    snprintf(out, size, "Hallo, %s!", name);
}

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

Die kaputte Fassung dieser Funktion würde den Text in einem lokalen char buf[64] bauen und return buf; schreiben - und damit die Adresse eines Puffers zurückgeben, der im selben Augenblick aufhört zu existieren.

Drei Wege, es zu beheben

1. Der Aufrufer liefert den Puffer (oben gezeigt). Keine Belegung, keine Besitzfrage, und der verbreitetste Stil in C-Bibliotheken. Die Funktion nimmt die Größe entgegen, damit sie darin bleiben kann.

2. Gib Heap-Speicher zurück und sag, wer ihn freigibt.

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

/* Liefert eine neu belegte Zeichenkette; der Aufrufer muss sie freigeben. */
char *make_greeting(const char *name) {
    size_t size = strlen(name) + 16;
    char *out = malloc(size);
    if (out == NULL) {
        return NULL;
    }
    snprintf(out, size, "Hallo, %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;
}

Der Heap-Block überlebt die Funktion von Entwurfs wegen - das ist der ganze Sinn von dynamischem Speicher. Der Preis ist der Besitzkommentar und das free des Aufrufers.

3. Nimm statischen Speicher, wenn ein einziger gemeinsamer Puffer akzeptabel ist:

#include <stdio.h>

int *next_id(void) {
    static int id = 0;      /* eine Instanz, lebt fuer das ganze Programm */
    id++;
    return &id;             /* sicher: statischer Speicher verschwindet nie */
}

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

static innerhalb einer Funktion hält den Gültigkeitsbereich der Variablen lokal und gibt ihr zugleich die Lebensdauer des Programms, ihre Adresse zurückzugeben ist also erlaubt. Der Handel ist, dass es davon immer nur eine gibt: Jeder Aufrufer teilt sie sich, was dieses Muster in nebenläufigem Code unbrauchbar und selbst in einsträngigem Code überraschend macht, wenn zwei Aufrufer den Zeiger gleichzeitig halten.

Größe: wo dem Stack der Platz ausgeht

Stackplatz ist klein und fest. Der Hauptthread bekommt typischerweise 1 MB unter Windows und 8 MB unter Linux; ein erzeugter Thread oft weit weniger. Der Heap ist durch den verfügbaren Systemspeicher begrenzt.

void bad(void) {
    int huge[1000000];      /* ~4 MB Stack - stürzt beim Betreten wahrscheinlich ab */
    huge[0] = 1;
}

Es gibt keine Meldung und kein NULL zum Prüfen: Das Programm stirbt einfach, meist mit einem Segmentierungsfehler, bevor die erste Zeile des Rumpfes läuft. Die Heap-Fassung meldet den Fehlschlag ordentlich:

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

int main(void) {
    size_t n = 1000000;

    int *huge = malloc(n * sizeof *huge);
    if (huge == NULL) {
        fprintf(stderr, "konnte %zu ints nicht belegen\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;
}

Tiefe Rekursion erschöpft den Stack auf dieselbe Weise, Rahmen für Rahmen - eine entgleiste rekursive Funktion ist in der Praxis die häufigste Ursache eines Stacküberlaufs.

Kosten und Lokalität

Stackbelegung ist eine Rechenoperation auf einem Register. Heapbelegung ist ein Bibliotheksaufruf, der einen passenden Block sucht, womöglich eine Sperre nimmt und gelegentlich das Betriebssystem um mehr Speicher bittet. In einer heißen Schleife ist dieser Unterschied messbar.

Stackdaten sind außerdem kompakt und kürzlich angefasst, liegen also meist im Cache. Heapblöcke können verstreut sein. Keine dieser Tatsachen sollte einen Entwurf allein bestimmen - die Korrektheit der Lebensdauer kommt zuerst -, aber zwischen zwei gleichermaßen korrekten Entwürfen ist der mit dem Stack meist der schnellere.

Die Bereiche sichtbar machen

Adressen auszugeben macht das Layout greifbar. Die genauen Werte unterscheiden sich in jedem Lauf (moderne Systeme würfeln sie), aber die Gruppierung ist sichtbar:

#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("global: %p\n", (void *)&global_value);
    printf("static: %p\n", (void *)&static_value);
    printf("Heap:   %p\n", (void *)heap_value);
    printf("lokal:  %p\n", (void *)&local_value);

    free(heap_value);
    return 0;
}

Die globale und die statische Variable liegen nebeneinander; der Heapblock liegt woanders; die Lokale liegt typischerweise weit von beiden entfernt. Caste für %p nach void * - das verlangt die Formatangabe.

Die Wahl

Nimm den Stack, wenn:

• die Größe zur Übersetzungszeit bekannt ist,
• die Daten nur innerhalb dieser Funktion und der von ihr aufgerufenen gebraucht werden,
• und sie klein sind - ein paar Kilobyte, keine Megabyte.

Nimm den Heap, wenn:

• die Größe von einer Eingabe, einer Datei oder einer Berechnung abhängt,
• die Daten die Funktion überleben müssen, die sie erzeugt hat,
• oder sie groß genug sind, um die Stackgrenze zu bedrohen.

Nimm statischen Speicher, wenn:

• genau eine Instanz für das ganze Programm existieren soll,
• und das Teilen zwischen allen Aufrufern wirklich korrekt ist.

Die Voreinstellung ist der Stack. Greife zum Heap, wenn einer seiner drei Gründe zutrifft, und folge dann den Besitzregeln aus Speicherlecks, damit der Block, für den du eine Lebensdauer gewonnen hast, auch wieder freigegeben wird.

Zwei spiegelbildliche Bugs

Sie lohnen sich gemeinsam zu benennen, denn sie sind dieselbe Lebensdauerfrage, zweifach beantwortet:

• Baumelnder Zeiger - der Speicher starb vor dem Zeiger. &local zurückgeben oder einen Zeiger nach free benutzen. Das Programm liest oder schreibt Speicher, der nun etwas anderem gehört.
• Speicherleck - der Zeiger starb vor dem Speicher. Die letzte Referenz auf einen malloc-Block verlieren. Nichts geht sofort kaputt; der Prozess wächst einfach.

Beide entstehen aus einer Fehlpaarung zwischen der nötigen Lebensdauer der Daten und dem Bereich, in den du sie legst. Entscheide zuerst die Lebensdauer, und der Bereich ergibt sich.