Heap und Stack - Unterschiede

[-187-]

Moin, ich hab mal ne Frage bezüglich "Heap und Stack" !

Also was ist denn eigentlich der Heap und was ist der Stack ? Recherchen im Netz waren -für mich- widersprüchlich. Kann mir jemand in eigenen Worten erklären was der wesentliche Unterschied ist und welche Variablen vom Stack und welche vom Heap verwaltet werden ?

Danke schonmal für eure Antworten,

Ciao!

[implementation]

Den Stack als Datenstruktur kannst du dir wie einen Stapel vorstellen.
Wenn du oben was draufgepackt hast (push) kannst du auch nur das oberste Element wieder runternehmen (pop) oder es dir anschauen (peek).

Der Stack als Speicherbereich ist in etwa so aufgebaut wie die gerade erwähnte Datenstruktur:
Mit den Assemblerbefehlen push und pop können Bytes draufgeschoben werden.
Entgegen der bildlichen Vorstellung eines Stapels wächst er jedoch nach unten.
Auf den Stack kommt alles, was verschachtelt wird:

> Funktion A wird aufgerufen mit Argument B
>> Return-Pointer kommt auf den Stapel
>> B kommt auf den Stapel
>> A macht was mit B
>> Funktion A wird rekursiv aufgerufen mit Argument C
>>> Return-Pointer kommt auf den Stapel
>>> C kommt auf den Stapel
>>> A macht was mit C
>>> Stapel wird bereinigt
>>> Return-Pointer wird gepopt
>> Stapel wird gereinigt
>> Return-Pointer wird gepopt
> und wir sind wieder im Hauptprogramm

Verstanden?

[Bummi]

ich meine
http://de.wikipedia.org/wiki/Dynamischer_Speicher
liefert eine verständliche Erklärung

[ehX]

Der Heap ist der Speicher, den du für dynamische Speicherzuweisungen verwendest. Dieser hat so viel "Platz" wie dein System noch frei hat.
Der Stack hat dagegen einen feste Grösse und ist vieeel kleiner als der Heap, dafür aber wesentlich schneller und so aufgebaut wie ein LiFo-Puffer.
Im Stack werden lokale Variablen und generell alles, was temporär zur Laufzeit einer Routine (calls by value etc.) an Speicher benötigt wird, abgelegt.
Im Heap sind die Allokationen persistenter, d.h., jeglicher Speicher, den du anforderst (malloc und Konsorten) landet im Heap.

[BUG]

Der Stack (auf Deutsch: "Stapel") wird hauptsächlich für Funktionen genutzt: Argumente übergeben, lokale Variablen speichern, Rücksprungadresse und nicht-flüchtige Register speichern.
Der Stack wird im Internet eigentlich meist korrekt beschrieben.

Beim Heap (auf Deutsch: "Haufen") kann es gut Verwirrungen geben.
Gemeint sein kann: eine Datenstruktur mit Heap-Eigenschaft, ein binärer Heap oder eben eben der Speicherbereich, aus dem man Speicher reservieren kann.
Du meinst den Letzten.
In diesem Speicher kann man Bereiche bestimmter Größe anfordern und ein Algorithmus sucht dafür einen freien Platz (z.B. mit getMem in Delphi).
Die Heapverwaltung kann sehr unterschiedlich organisiert sein.

[-187-]

Danke für eure Informationen. Dann kommen zum Beispiel Stringlisten (TStringList) auf den Heap weil die Größe ungewiss ist ?

//Edit: @implementation, tolle Erklärung, Dankeschön!

[Bummi]

wenn Dich das ganze wirklich interessiert, damm schau Dir mal ein paar Assemblercodeblöcke an, ich durfte damit groß werden, nativer siehst nirgends was wirklich passiert.

[ConnorMcLeod]

Zitat von -187-:

Dann kommen zum Beispiel Stringlisten (TStringList) auf den Heap ?

Ja

Zitat von -187-:

weil die Größe ungewiss ist ?

Nein, sondern, weil es angeforderter Speicherbereich ist.

[himitsu]

Auf den Stack kommen vorallem lokale Variablen, Rücksprungadressen der Prozeduraufrufe und Stackframes.

Dynamische Arrays, "lange" Strings (also alles außer ShortStrings und statischen Char-Arrays), Objekte und Interfces sind intern Zeiger, also liegen dann maximal ihre Zeiger auf'm Stack und der Rest im Heap, da dessen Speicher intern z.B. über GetMem angefordert wird.

Globale Variablen und typisierte Konstanten liegen in der DataSektion der EXE/DLL.
"Echte" Konstanten landen meißt in der CodeSektion, bzw. werden ja direkt in den Nutzungsstellen wertmäßig eingebaut.
Felder/Membervariablen von Objekten, da dieses ja in dem Objekt liegen, landen somit auch auf dem Heap landen.


Deshalb bekommt man gerne mal Probleme (Stacküberlauf) bei:
- zirkulären Prozeduraufrufen / Endlosschleifen
- zu großen statischen Arrays

[DeddyH]

Zitat von himitsu:

Auf den Heap kommen vorallem lokale Variablen, Rücksprungadressen der Prozeduraufrufe und Stackframes.