Heap und Stack - Unterschiede
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! |
AW: Heap und Stack - Unterschiede
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? |
AW: Heap und Stack - Unterschiede
|
AW: Heap und Stack - Unterschiede
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. |
AW: Heap und Stack - Unterschiede
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. |
AW: Heap und Stack - Unterschiede
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! |
AW: Heap und Stack - Unterschiede
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.
|
AW: Heap und Stack - Unterschiede
Zitat:
Zitat:
|
AW: Heap und Stack - Unterschiede
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 |
AW: Heap und Stack - Unterschiede
Zitat:
|
AW: Heap und Stack - Unterschiede
Zitat:
Zitat:
Deswegen:
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... |
AW: Heap und Stack - Unterschiede
Zitat:
|
AW: Heap und Stack - Unterschiede
korrigiert :oops:
|
AW: Heap und Stack - Unterschiede
Alles klar, Dankeschön an alle !:)
|
AW: Heap und Stack - Unterschiede
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? |
AW: Heap und Stack - Unterschiede
Ja, sind wir.
Die lokalen Variablen, Rücksprungungadressen usw. werden auf den Stack gepusht und beim Verlassen der Prozeduren wieder gepoppt. Aber der Zugriff auf die darauf befindlichen Inhalte geht direkt, über die relative Adresse zum aktuellen Stackpointer. Im Prinzip hat dieser Stack meistens eine feste Größe (MinStackSize bis MaxStackSize) und es gibt nur einen/zwei Stack-Pointer (ESP und EBP), für die aktuelle Position im Speicher ... an der Stelle werden neue Werte draufgepusht und dabei der Pointer verschoben. [add] String ist ein "Reservierter Bezeichner" www.bergt.de/workshop/delphi/html/delphi33.htm http://delphi.programmieren.vias.org...ved_words.html |
AW: Heap und Stack - Unterschiede
Der Stack passt doch perfekt. Beim Aufruf werden die Parameter und dann die lokalen Variablen auf den Stack gelegt
Code:
Innerhalb der Prozedur weiß der Rechner, dass sich
variable : string
lokale : integer Sender : TObject Rücksprung-Adresse ...
Delphi-Quellcode:
an der Stelle Stack-1 und
lokale
Delphi-Quellcode:
an Stack-0 befindet.
variable
Wird diese Prozedur jetzt erneut aufgerufen, dann
Code:
passt das doch wie die Faust aufs Auge ;)
variable : string
lokale : integer Sender : TObject Rücksprung-Adresse variable : string lokale : integer Sender : TObject Rücksprung-Adresse ... |
AW: Heap und Stack - Unterschiede
Ok stimmt, man kann den Stack ja auch per Pointer und MOV.. beschreiben und lesen.
Hierdurch wird der Stackpointer nicht Inc/Dec. Push und Pop hilft verändert ja bequemer weiße den SP mit. Ok ich glaub ich habs jetzt auch *g* PPS: Und warum ist Integer kein Reserviertes Wort. Das interessiert mich schon seit Jahren. |
AW: Heap und Stack - Unterschiede
Das wiederum wäre ein neues Thema!
Gruß K-H |
AW: Heap und Stack - Unterschiede
Zitat:
|
AW: Heap und Stack - Unterschiede
Zitat:
String ist ein Systemtyp, Integer nicht, sondern nur eine Ausprägung des Ordinaltyps. Oder: "string" ist ein reserviertes Schlüsselwort, "Integer" nur ein vordefinierter Datentyp. |
AW: Heap und Stack - Unterschiede
[edit] wo? :mrgreen:
|
AW: Heap und Stack - Unterschiede
@himitsu
Falscher Thread, Guten Morgen :mrgreen: |
Alle Zeitangaben in WEZ +1. Es ist jetzt 23:19 Uhr. |
Powered by vBulletin® Copyright ©2000 - 2024, Jelsoft Enterprises Ltd.
LinkBacks Enabled by vBSEO © 2011, Crawlability, Inc.
Delphi-PRAXiS (c) 2002 - 2023 by Daniel R. Wolf, 2024 by Thomas Breitkreuz