Heap und Stack - Unterschiede

[-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.

[sirius]

Zitat von himitsu:

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

(Goreckdur (das Dicke) von mir)

Zitat von himitsu:

Globale Variablen liegen im Heap

Die liegen in der Data-Section vom Programm. Da hier kein (zusätzlicher) Speicher reserviert oder irgendetwas freigegebenen werden kann, würde ich dies nach der Definition von Heap nicht als Heap bezeichnen.
Deswegen:

• globale Variablen -> Im Programmcode (Data-Section)
• lokale Variablen -> Stack (ggf. auch nur im Prozessor/Register)
• der ganze Rest an Speicher -> Heap

Ansonsten ist schon alles gesagt. Auf dem Stack landen neben den lokalen Variablen noch:

• Übergabeparameter (wenn nicht im Prozessor/Register) an Funktionen
• Rücksprungadressen
• Exception-Frames (jedes mal wenn man try aufruft, biss das finally oder except kommt)
• der Inhalt von Registern, der mal kurzfristig zwischengespeichert werden muss

Für den Stack hat die Intel-Architektur (nicht nur die) auch spzielle Befehle (push und pop) für deren Nutzung, oder Befehle, die den Stack gleich mal mitbenutzen (call, ret)


Im Grunde genommen passiert bei der Programmausführung folgendes:
Die EXE (inkl. aller benötigten, statisch eingebundenen DLLs) wird in den Speicher geladen. Damit sind schon mal alle globalen Variablen (die ja mit ihrem Initialisierungswert schon in der EXE direkt drin stehen) im Speicher. Bei den globalen Variablen kannst du deswegen zwar jederzeit deren Inhalt ändern, aber nie deren Speicherplatz freigeben.
Die nächste spannende Speicheraktion kommt, wenn dein Programm (im Mainthread) gestartet wird. Dann bekommst du (bei Standardeinstellung) 16kB Speicher reserviert. Im Prozessoer gibt es dafür dann ein Register (kleiner Speicherplatz) namens ESP, der dir zeigt wo der Stack liegt und der auch von solchen Befehlen wie push, pop, call und ret enstsprechend genutzt wird. Darauf landen, wie gesagt, die lokalen Variablen und diverses schon Genanntes.
Und was jetzt noch (von den 2GB virtuellem Adressraum) übrig ist, nennt sich Heap, auf dem du dich austopben kannst. Das heißt, du kannst jederzeit von Windows Speicher anfordern (was u.a. getmem für dich erledigt, welches auch von jedem Constructor TKlasse.Create genutzt wird) und den frei für Daten nutzen und jederzeit asuch wieder an Windows zurückgeben.

Soweit von mir...

[gammatester]

Zitat von himitsu:

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

Du solltest mal ausschlafen! Das Zeug kommt doch hoffentlich auch bei Dir auf den Stack (Sonst würde es wohl auch besser Heapframe heißen).

[himitsu]

korrigiert

[-187-]

Alles klar, Dankeschön an alle !

[jdelphi]

Sodele ich betätige mich mal als Leichenschänder.

Seit ihr euch sicher das Lokale Variablen im Stack landen?

Wenn ich eine Lokale Variable ändern will, muss ja dann der ganz stack bis zur Variable hinauf geppopt werden, die Variable geändert und anschließend schön brav wieder alles zurück pushen. Vor allem woher weiß die CPU den noch an welcher stelle im Stack die Variable beerdigt liegt.

Vielleicht ist aber mit lokaler Variable was anderes gemeint, als ich meine.

Code:

procedure TForm1.Button1Click(Sender: TObject);
var
 lokale   : integer;
 variable : String;
begin

end;

PS: Warum wird eigentlich String Fett abgebildet und Integer als Normalschrift?