C Academy · Lektion

Stack Overflow vermeiden

Begrenzen Sie die Rekursion.

Stack Overflow vermeiden ist eine kostenlose C Academy-Lektion auf CoddyKit. Dies ist Lektion 4 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des C Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der C Academy-Kurs umfasst insgesamt 4 Lektionen.

Was ist ein Stack-Überlauf?

Der Call-Stack hat eine begrenzte Größe. Jeder Funktionsaufruf verwendet einen Teil davon für Parameter und lokale Variablen.

Wenn die Rekursion zu tief geht, füllt sich der Stack, und das Programm stürzt mit einem Stack-Überlauf ab.

Fehlender Basisfall

Die häufigste Ursache ist ein Basisfall, der nie erreicht wird. Dadurch läuft die Funktion endlos weiter und der Stack läuft über.

Führen Sie eine solche Funktion nicht aus, sondern untersuchen Sie, warum sie fehlschlägt.

int broken(int n) {
    /* no base case: never stops */
    return broken(n + 1);
}

Das Argument wird nicht kleiner

Selbst wenn ein Basisfall vorhanden ist, muss sich das Argument auf ihn zubewegen. Hier wird n größer und erreicht daher nie 0.

Prüfen Sie immer, ob jeder Aufruf näher an die Abbruchbedingung führt.

int oops(int n) {
    if (n == 0) return 0;
    return oops(n + 1); /* wrong direction */
}

Eine korrekte Version

Durch die Korrektur der Richtung endet die Funktion. Nun nimmt n in Richtung des Basisfalls 0 ab.

#include <stdio.h>

int good(int n) {
    if (n == 0) return 0;
    return n + good(n - 1);
}

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

Tiefenbegrenzungen sind real

Selbst eine korrekte Rekursion kann bei großer Tiefe einen Stack-Überlauf verursachen. Ein Funktionsaufruf mit mehreren Millionen Ebenen kann den Stack überschreiten, der oft nur wenige Megabyte groß ist.

Bei sehr großen Tiefen sollten Sie Iteration bevorzugen.

Tiefe Rekursion in eine Schleife umwandeln

Wenn die Rekursionstiefe mit der Eingabegröße wächst, wechseln Sie zu einer Schleife. Dadurch werden Tausende von Stack-Frames vermieden.

Die folgende Schleife summiert 1 bis zu einem großen n sicher mit konstantem Speicherbedarf.

#include <stdio.h>

int main(void) {
    long total = 0;
    for (int i = 1; i <= 1000000; i++)
        total += i;
    printf("%ld\n", total);
    return 0;
}

Tiefe durch Divide and Conquer verringern

Durch das Halbieren der Arbeit bleibt die Tiefe gering. Wird ein Bereich durch wiederholtes Halbieren summiert, wächst die Tiefe logarithmisch mit der Größe statt linear.

long range_sum(int lo, int hi) {
    if (lo == hi) return lo;
    int mid = (lo + hi) / 2;
    return range_sum(lo, mid) + range_sum(mid + 1, hi);
}

Auf große lokale Arrays achten

Große lokale Variablen machen jeden Stack-Frame umfangreicher, sodass sich der Stack schneller füllt.

Vermeiden Sie es, große Arrays innerhalb einer rekursiven Funktion zu deklarieren. Übergeben Sie stattdessen Zeiger oder verwenden Sie den Heap.

void heavy(int n) {
    int buffer[10000]; /* big frame each call */
    if (n == 0) return;
    heavy(n - 1);
}

Einen Akkumulator verwenden

Wenn Sie eine laufende Summe als Akkumulator übergeben, bleibt jeder Stack-Frame klein und die Rekursion erhält eine endrekursive Struktur.

Einige Compiler können dann einen einzigen Stack-Frame wiederverwenden.

#include <stdio.h>

long sum_acc(int n, long acc) {
    if (n == 0) return acc;
    return sum_acc(n - 1, acc + n);
}

int main(void) {
    printf("%ld\n", sum_acc(100, 0));
    return 0;
}

Eine Sicherheits-Checkliste

Bevor Sie einer rekursiven Funktion vertrauen, prüfen Sie:

1. Gibt es einen Basisfall?
2. Führt jeder Aufruf näher zu ihm?
3. Könnte die Tiefe bei großen Eingaben sehr groß werden?

Wenn die Tiefe stark anwachsen kann, verwenden Sie stattdessen eine Schleife.

Mit kleinen Eingaben testen

Testen Sie Rekursion immer zuerst mit winzigen Eingaben, deren Ergebnis Sie von Hand überprüfen können.

Wenn kleine Fälle funktionieren und die Tiefe begrenzt bleibt, können Sie die Eingabe zuversichtlich vergrößern.

Kurztest

Erkennen Sie die sicherste Lösung.

Zusammenfassung

Ein Stack-Überlauf tritt auf, wenn die Rekursion zu tief geht oder nie endet. Sorgen Sie immer für einen erreichbaren Basisfall, verkleinern Sie das Argument bei jedem Aufruf, halten Sie die Stack-Frames klein und wechseln Sie zur Iteration, wenn die Tiefe mit der Eingabegröße wachsen kann.

Häufig gestellte Fragen

Ist die Lektion „Stack Overflow vermeiden“ kostenlos?

Ja — der vollständige Text von „Stack Overflow vermeiden“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des C Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der C Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Stack Overflow vermeiden“?

Begrenzen Sie die Rekursion. Du übst C Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um C Academy zu starten?

Keine Vorkenntnisse erforderlich. C Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 4 von 4.

Wie lange dauert die Lektion „Stack Overflow vermeiden“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser C Academy-Lektion Code schreiben und ausführen?

Ja. Jede C Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu C Academy