Stack Overflow

Der Fehler Nummer 1 bei Anfängern, die Rekursion lernen. Vergessene Abbruchbedingung (Base Case):

def run():
    run() # Ruft sich selbst auf, für immer.

Bumm -> RecursionError: maximum recursion depth exceeded.

1. Stack Size

Der Stack ist winzig (meist 1 MB bis 8 MB pro Thread). Der Heap (für Daten) ist riesig (Gigabytes). Warum? Der Stack muss extrem schnell sein (CPU Cache). Große Daten gehören auf den Heap. Wenn du ein riesiges Array im Stack anlegst (int hugeArray[1000000]), kriegst du auch einen Stack Overflow, ohne Rekursion.

2. Tail Call Optimization (TCO)

Schlaue Compiler können Stack Overflows verhindern. Wenn der rekursive Aufruf das allerletzte ist, was die Funktion tut, kann der Compiler tricksen: Er nutzt den gleichen Stack-Frame wieder, statt einen neuen draufzulegen. Aus Rekursion wird intern eine Schleife ("Jump"). Java und Python können das nicht. Funktionale Sprachen (Haskell, Scala) können es.

1. Stack Frames & Return Addresses

Technisch gesehen ist der Stack eine Abfolge von Stack Frames. Jeder Frame enthält:

• Die Parameter der Funktion.
• Lokale Variablen (Zahlen, Pointer).
• Die Return Address (der wichtigste Teil!). Wenn ein Stack Overflow passiert, schreibt das Programm über das Ende des reservierten Bereichs hinaus. In unsicheren Sprachen (C/C++) kann das dazu führen, dass die "Return Address" mit einer Adresse überschrieben wird, die der Hacker kontrolliert. Wenn die Funktion fertig ist, springt die CPU nicht zurück zum Hauptprogramm, sondern zum Schadcode des Hackers. Das ist die Basis für Buffer Overflow Exploits. Modernes OS-Design nutzt daher "Stack Canaries" (Zufallswerte am Ende des Stacks), um Korruption vor dem Absturz zu erkennen.

2. Stack vs. Heap Allocation Performance

Warum nutzen wir den Stack überhaupt, wenn er so klein ist? Weil er extrem schnell ist. Eine Stack-Alloc ist nur ein einziger CPU-Befehl: sub esp, 4 (den Stack-Pointer um 4 Byte verschieben). Fertig. Eine Heap-Alloc (via malloc oder new) muss ein freies Stück Speicher im RAM suchen, Sperren verwalten (Multithreading) und Metadaten führen. Sogar der Garbage Collector muss den Heap später scannen. Performance-Gurus programmieren daher so "Stack-heavy" wie möglich. In Rust oder C++ versucht man, Daten als lokale Variablen zu halten (Value Types), anstatt sie mit new auf dem Heap zu verteilen.

3. Stack Guard Pages

Moderne Betriebssysteme Schützen den Stack mit Guard Pages. Hinter dem eigentlichen Stack-Speicher liegt eine Speicherseite, auf der Lese- und Schreibzugriffe verboten sind. Sowie der Stack-Pointer diese Grenze berührt, feuert die Hardware (MMU) eine Exception (Segmentation Fault). Das System erkennt den Stack-Überlauf bevor er anderen Speicher korrumpiert. Das schützt das System vor Instabilität, rettet aber dein Programm nicht vor dem Absturz – es ist ein reiner Sicherheitsmechanismus.