Was und wo sind die stack und heap?

Den Stapel, ist die Erinnerung beiseite als scratch-Speicherplatz für einen thread der Ausführung. Wenn eine Funktion aufgerufen wird, wird ein block ist reserviert auf dem stack für lokale Variablen und einige buchhalterische Daten. Wenn die Funktion zurückgibt, wird der block wird nicht verwendete und verwendet werden können, das nächste mal, wenn eine Funktion aufgerufen wird. Der stack ist immer reserviert in einem LIFO - (last in first out) - Reihenfolge; die erst kürzlich reservierten block wird immer der nächste block freigegeben werden. Dies macht es wirklich einfach, den überblick zu behalten-Stapel; die Befreiung einen block aus dem Stapel ist nichts mehr als eine Anpassung Zeiger.

Wird der heap-Speicher beiseite gelegt für die dynamische Zuordnung. Im Gegensatz zu dem Stapel, es gibt keine durchgesetzte Muster, um die Allokation und Freigabe von Blöcken aus dem heap; Sie können reservieren eines Blockes jederzeit und kostenlos zu jeder Zeit. Dies macht es viel schwieriger zu verfolgen, welche Teile des heap zugewiesen werden oder frei zu einem bestimmten Zeitpunkt; es gibt viele custom-heap-allocators zur Optimierung der heap Leistung für verschiedene Nutzungsmuster.

Jeder thread bekommt einen Stapel, während es in der Regel nur ein heap für die Anwendung (obwohl es nicht ungewöhnlich, dass mehrere heaps für die verschiedenen Arten der Zuweisung).

Beantworten Ihre Fragen direkt:

Inwieweit sind Sie gesteuert durch das Betriebssystem oder die Sprache der Laufzeit?

Das OS reserviert, wird der Stapel für jedes system-level-thread, wenn der thread erstellt wird. In der Regel das OS ist als die Sprache, die Laufzeitumgebung, um die Allokation der heap für die Anwendung.

Was ist Ihr Anwendungsbereich?

Dem Stapel wird an einem Faden, so dass, wenn der thread beendet wird, wird der stack zurückgefordert. Der heap ist in der Regel reserviert, die beim Start der Anwendung von der Laufzeitumgebung und wird zurückgefordert, wenn die Anwendung (technisch-Prozess) beendet.

Was bestimmt die Größe eines jeden von Ihnen?

Die Größe des stack wird gesetzt, wenn ein thread erstellt wird. Die Größe des Heaps festgelegt ist, beim starten der Anwendung, kann aber wachsen, wenn Platz benötigt wird (die Zuweisung Anfragen mehr Arbeitsspeicher vom Betriebssystem).

, Was macht man schneller?

Dem stack ist schneller, da der Zugriff Muster macht es sehr einfach zu reservieren und freigeben von Speicher (ein pointer/integer ist einfach inkrementiert oder dekrementiert), während der heap ist sehr viel komplexer, Buchhaltung betroffen sind, zuordnen oder aufheben der Zuordnung. Auch, jedes byte in den stack neigt dazu, wiederverwendet werden sehr Häufig was bedeutet, dass es tendenziell zugeordnet, um den Prozessor-cache, so dass es sehr schnell. Ein weiterer performance-Treffer für den Haufen, der Haufen, da meist eine Globale Ressource, in der Regel hat die multi-threading-sicher, d.h. jede Zuweisung und-Freigabe werden muss - in der Regel - synchronisiert mit "alle" anderen heap-Zugriffe im Programm.

Eine klare demonstration:


_{Bild Quelle: vikashazrati.wordpress.com}

InformationsquelleAutor Jeff Hill

Der wichtigste Punkt ist, dass heap und stack sind generische Begriffe für die Möglichkeiten, die in dem Speicher zugeordnet werden kann. Sie umgesetzt werden können in viele verschiedene Möglichkeiten, und die Nutzungsbedingungen gelten für die grundlegenden Konzepte.

• In einem Stapel von Elementen, Elemente sitzen oben auf dem anderen in der Reihenfolge, wie Sie platziert waren es, und Sie können nur entfernen Sie die oberen (ohne Sturz das ganze über).

  

  Die Einfachheit von einem Stapel ist, dass Sie nicht brauchen, um zu erhalten eine Tabelle mit einem Eintrag für jeden Abschnitt zugewiesenen Speicher; der einzige Staat Informationen, die Sie brauchen, ist ein einzelner Zeiger auf das Ende des stack. Zum reservieren und freigeben, die Sie nur Inkrementieren und Dekrementieren, die einzelnen Zeiger. Hinweis: ein Stapel kann manchmal umgesetzt werden, beginnen Sie oben von einem Abschnitt des Speichers und zu verlängern, nach unten anstatt nach oben wächst.

• In einem Haufen, es gibt keine bestimmte Reihenfolge, um die Art und Weise Elemente platziert werden. Erreichen Sie in und entfernen von Elementen in beliebiger Reihenfolge, denn es gibt kein klares 'top' Position.

  

  Heap erfordert die Aufrechterhaltung eines vollständigen Datensatzes, was Speicher reserviert ist und was nicht, sowie einige overhead-Wartung, die Fragmentierung zu verringern, finden zusammenhängenden memory-Segmente groß genug, um die angeforderte Größe, und so weiter. Speicher kann freigegeben ist, jederzeit verlassen freien Raum. Manchmal ist ein memory-allocator wird Wartungsaufgaben wie Defragmentierung Speicher durch verschieben von zugeordneten Speicher um, oder Müll sammeln - die Ermittlung der Laufzeit beim Arbeitsspeicher ist nicht mehr in Umfang und freigeben.

Diese Bilder sollten tun, einen ziemlich guten job zu beschreiben die zwei Möglichkeiten der Zuweisung und Freigabe von Speicher in einen stack und einen heap. Yum!

• Inwieweit sind Sie gesteuert durch das Betriebssystem oder die Sprache der Laufzeit?

  Wie bereits erwähnt, heap-und stack sind die Allgemeinen Bedingungen realisiert werden können, in vielerlei Hinsicht. Computer-Programme haben in der Regel ein stack genannt call-stack, die speichert Informationen, die relevant für die aktuelle Funktion, wie z.B. einen Zeiger zu welcher Funktion es hieß aus, und alle lokalen Variablen. Da Funktionen andere Funktionen aufrufen, und dann die Rückkehr, der stack wächst und schrumpft, um Informationen aus den Funktionen weiter unten im Aufruf-stack. Ein Programm nicht wirklich runtime Kontrolle über es; es ist bestimmt durch die Programmiersprache, Betriebssystem und sogar die system-Architektur.

  Ein heap ist ein allgemeiner Begriff für alle Speicher wird dynamisch zugewiesen und zufällig; d.h. nicht in Ordnung. Der Speicher ist in der Regel der Zuweisung durch die OS, die mit der Anwendung aufrufen von API-Funktionen zu tun, diese Zuordnung. Es ist ein gutes Stück der Verwaltungsaufwand in der Verwaltung von dynamisch allozierten Speicher, die in der Regel behandelt durch die OS.

• Was ist Ihr Anwendungsbereich?

  Den call-stack ist so ein low-level-Konzept, dass es nicht beziehen sich auf "Umfang" im Sinne von Programmierung. Wenn Sie zerlegen einige code, den Sie sehen, relative Mauszeiger-Stil Verweise auf Teile des Stapels, aber so weit als einer Sprache auf höherer Ebene ist betroffen, die Sprache schreibt seine eigenen Regeln, die in den Anwendungsbereich. Ein wichtiger Aspekt auf einem Stapel, jedoch, ist, dass, sobald eine Funktion gibt, alles lokale auf, die Funktion ist sofort befreit vom Stapel. Das funktioniert so, wie du erwartest, dass es Arbeit gegeben, wie Sie Ihre Programmier-Sprachen arbeiten. In einem Haufen, es ist auch schwer zu definieren. Der Umfang ist, was auch immer ausgesetzt ist, von der OS, aber Ihre Programmiersprache wahrscheinlich fügt seine Regeln darüber, was ein "Rahmen" ist in Ihrer Anwendung. Die Prozessor-Architektur und das Betriebssystem verwenden, virtuelle Adressierung, die den Prozessor übersetzt zu physischen Adressen, und es gibt Seitenfehler usw. Sie verfolgen welche Seiten gehören die Anwendungen. Man kann nie wirklich brauchen, um über diese, obwohl, weil Sie nur verwenden, was Methode Ihre Programmiersprache verwendet, um die Zuweisung und Freigabe von Speicher, und Fehler prüfen (wenn der Verwendungszweck/die Befreiung aus einem beliebigen Grund fehlschlägt).

• Was bestimmt die Größe eines jeden von Ihnen?

  Wieder, es hängt von der Sprache, compiler, Betriebssystem und die Architektur. Ein Stapel wird in der Regel im Voraus reserviert, weil es per definition sein müssen, zusammenhängenden Speicher (dazu mehr im letzten Absatz). Die Sprache, compiler oder das Betriebssystem bestimmen seine Größe. Sie nicht speichern Sie große Brocken von Daten auf dem stack, es wird also groß genug sein, dass es sollte nie vollständig verwendet, außer in Fällen von unerwünschten endlose Rekursion (daher "stack overflow") oder andere ungewöhnliche Programmierung Entscheidungen.

  Ein heap ist ein allgemeiner Begriff für alles, was, die kann dynamisch zugewiesen. Je nachdem, auf welche Art und Weise man es betrachtet, es ist ständig verändernde Größe. In modernen Prozessoren und Betriebssysteme an, die genaue Art und Weise, die es funktioniert, ist sehr abstrahiert, wie auch immer, also Sie müssen normalerweise nicht zu viel sorgen darüber, wie es arbeitet tief unten, mit der Ausnahme, dass (in den Sprachen, wo es können Sie) Sie dürfen nicht verwendet Speicher, die man noch nicht zugeteilt noch oder Speicher, die Sie freigegeben haben.

• Was macht man schneller?

  Dem stack ist schneller, weil alle freier Speicher ist immer zusammenhängend. So eine Liste muss gepflegt werden, der alle Segmente des freien Speichers, der nur einen einzelnen Zeiger auf die aktuelle Spitze des Stacks. Compiler in der Regel speichern diese Zeiger in einer speziellen, schnell registrieren für diesen Zweck. Was mehr ist, können nachfolgende Operationen auf einem stack sind in der Regel konzentrierte sich in den sehr nahe gelegenen Bereiche des Arbeitsspeichers, die auf einem sehr niedrigen Niveau ist gut für die Optimierung durch den Prozessor mit on-die-caches.

InformationsquelleAutor thomasrutter

In der folgende C# - code

public void Method1()
{
    int i = 4;
    int y = 2;
    class1 cls1 = new class1();
}

Hier ist, wie der Speicher verwaltet wird

Local Variables , die müssen nur so lange, wie der Funktions-Aufruf gehen in den Stapel. Der heap wird für Variablen verwendet, deren Leben wir nicht wirklich im Vorfeld wissen, aber wir erwarten, dass Sie eine Weile dauern. In den meisten Sprachen ist es wichtig, dass wir wissen, dass zur compile-Zeit, wie groß eine variable ist, wenn wir wollen, speichern Sie es auf dem Stapel.

Objekte (die in der Größe variieren, so aktualisieren wir Ihnen) gehen über den Haufen, weil wir nicht wissen, zum Zeitpunkt der Erstellung, wie lange Sie noch dauern wird. In vielen Sprachen wird der Haufen Müll gesammelt, um Gegenstände zu finden (wie der cls1 Objekt), die haben nicht mehr alle Referenzen.

In Java, die meisten Objekte gehen direkt in den heap. In Sprachen wie C /C++ Strukturen und Klassen können, bleiben oft auf den Stapel, wenn Sie nicht den Umgang mit Zeigern.

Mehr Informationen finden Sie hier:

Der Unterschied zwischen stack und heap-Speicher-Zuweisung « timmurphy.org

und hier:

Erstellen von Objekten auf dem Stack und Heap

Dieser Artikel ist die Quelle Bild oben: Sechs wichtige .NET-Konzepte: Stack, heap, Wertetypen, Referenztypen-boxing und unboxing - CodeProject

aber bewusst sein, es enthält einige Ungenauigkeiten.

InformationsquelleAutor Snowcrash

Klären, diese Antwort hat falsche Informationen (thomas befestigt seine Antwort nach Kommentaren, cool 🙂 ). Andere Antworten nur vermeiden erklären, was die statische Zuordnung bedeutet. Also werde ich die drei wichtigsten Formen der Zuweisung und wie Sie in der Regel beziehen sich auf den heap, stack und Daten-segment weiter unten. Ich werde auch zeigen einige Beispiele sowohl in C/C++ und Python, um Menschen helfen zu verstehen.

"Statische" (AKA statisch reservierte) Variablen werden nicht auf dem Stapel reserviert. Nicht davon ausgehen, so viele Menschen tun, nur weil Sie "statisch" klingt viel wie "Stapel". Sie tatsächlich existieren, weder auf dem stack noch die heap. Die sind Teil von dem, was heißt die Daten-segment.

Jedoch ist es im Allgemeinen besser zu berücksichtigen "Umfang" und "Lebensdauer" statt "stack" und "heap".

Geltungsbereich bezieht sich auf das, was Teile des Codes können Sie den Zugriff auf eine variable. Generell denken wir an lokalen Bereich (kann nur zugegriffen werden, die von der aktuellen Funktion) versus globalen Bereich (zugegriffen werden kann, überall) obwohl Rahmen viel komplexer.

Lebensdauer bezieht sich auf, wenn eine variable zugeordnet ist, und freigegeben ist, während der Ausführung des Programms. Normalerweise denken wir, dass der statische Zuordnung (variable beibehalten wird, die über die gesamte Dauer des Programms, so dass es nützlich für die Speicherung von gleichen Informationen über mehrere Funktionsaufrufe) versus automatische Zuordnung (variable nur weiterhin über einen einzigen Aufruf einer Funktion, so dass es nützlich für die Speicherung von Informationen, die nur in Ihrer Funktion und können verworfen werden, sobald Sie fertig sind) im Vergleich zu dynamische Zuordnung (Variablen, deren Dauer definiert ist, zur Laufzeit, statt compile-Zeit, wie z.B. statische oder automatisch).

Obwohl die meisten Compiler und-Interpreter implementieren Sie dieses Verhalten auch in Bezug auf die Verwendung von stacks, heaps, etc., ein compiler kann manchmal brechen diese Konventionen, wenn es will, solange das Verhalten korrekt ist. Zum Beispiel durch die Optimierung eine lokale variable kann nur existieren, in einem register oder vollständig entfernt werden, auch wenn die meisten lokale Variablen existieren, die in den Stapel. Wie hat gewesen wies darauf hin, in ein paar Kommentare, Sie sind frei, implementieren Sie einen compiler, der nicht einmal mit einem Stapel oder Haufen, sondern einige andere Speicher-Mechanismen (selten getan, da Stapel und Haufen sind großartig für diese).

Werde ich Ihnen einige einfache kommentierten C-code zu veranschaulichen. Der beste Weg zu lernen ist, führen Sie ein Programm unter einem debugger und beobachten Sie das Verhalten. Wenn Sie es vorziehen, zu Lesen, python, überspringen, um das Ende der Antwort 🙂

//Statically allocated in the data segment when the program/DLL is first loaded
//Deallocated when the program/DLL exits
//scope - can be accessed from anywhere in the code
int someGlobalVariable;

//Statically allocated in the data segment when the program is first loaded
//Deallocated when the program/DLL exits
//scope - can be accessed from anywhere in this particular code file
static int someStaticVariable;

//"someArgument" is allocated on the stack each time MyFunction is called
//"someArgument" is deallocated when MyFunction returns
//scope - can be accessed only within MyFunction()
void MyFunction(int someArgument) {

    //Statically allocated in the data segment when the program is first loaded
    //Deallocated when the program/DLL exits
    //scope - can be accessed only within MyFunction()
    static int someLocalStaticVariable;

    //Allocated on the stack each time MyFunction is called
    //Deallocated when MyFunction returns
    //scope - can be accessed only within MyFunction()
    int someLocalVariable;

    //A *pointer* is allocated on the stack each time MyFunction is called
    //This pointer is deallocated when MyFunction returns
    //scope - the pointer can be accessed only within MyFunction()
    int* someDynamicVariable;

    //This line causes space for an integer to be allocated in the heap
    //when this line is executed. Note this is not at the beginning of
    //the call to MyFunction(), like the automatic variables
    //scope - only code within MyFunction() can access this space
    //*through this particular variable*.
    //However, if you pass the address somewhere else, that code
    //can access it too
    someDynamicVariable = new int;


    //This line deallocates the space for the integer in the heap.
    //If we did not write it, the memory would be "leaked".
    //Note a fundamental difference between the stack and heap
    //the heap must be managed. The stack is managed for us.
    delete someDynamicVariable;

    //In other cases, instead of deallocating this heap space you
    //might store the address somewhere more permanent to use later.
    //Some languages even take care of deallocation for you... but
    //always it needs to be taken care of at runtime by some mechanism.

    //When the function returns, someArgument, someLocalVariable
    //and the pointer someDynamicVariable are deallocated.
    //The space pointed to by someDynamicVariable was already
    //deallocated prior to returning.
    return;
}

//Note that someGlobalVariable, someStaticVariable and
//someLocalStaticVariable continue to exist, and are not
//deallocated until the program exits.

Ein besonders ergreifendes Beispiel dafür, warum es wichtig ist zu unterscheiden zwischen Lebensdauer und Reichweite ist, dass eine variable kann lokal aber statische Lebensdauer - zum Beispiel, "someLocalStaticVariable" in dem Beispielcode oben. Solche Variablen können unsere gemeinsamen, aber informellen Benennung Gewohnheiten sehr verwirrend. Zum Beispiel, wenn wir sagen "lokalen" meinen wir meist "lokal gültigen automatisch zugewiesene variable" und wenn wir sagen, dass wir global in der Regel bedeuten, "Global statisch zugewiesene variable". Leider, wenn es um Dinge wie "Datei-Gültigkeitsbereich statisch allokierten Variablen" viele Leute sagen... "huh???".

Einige der syntax Entscheidungen in C/C++ verschärfen dieses problem - zum Beispiel, viele Leute denken, Globale Variablen sind nicht "statisch", weil die syntax unten.

int var1; //Has global scope and static allocation
static int var2; //Has file scope and static allocation

int main() {return 0;}

Beachten Sie, dass putting das Schlüsselwort "static" in der Deklaration oben verhindert var2 aus mit einem globalen Gültigkeitsbereich. Dennoch, die global var1 hat die statische Zuordnung. Dies ist nicht intuitiv! Aus diesem Grund ich versuchen, verwenden Sie niemals das Wort "static" bei der Beschreibung von Umfang und stattdessen etwas sagen wie "Datei" oder "Datei " eingeschränkten" Umfang. Doch viele Menschen verwenden den Begriff "statisch" oder "static scope" zu beschreiben, eine variable, die nur zugegriffen werden kann, aus einer code-Datei. Im Rahmen der Lebensdauer, "static" immer bedeutet, dass die variable zugeordnet wird, die bei Programm-start und freigegeben, wenn das Programm beendet wird.

Einige Leute denken, der diese Konzepte als C/C++ - spezifisch. Sie sind es nicht. Zum Beispiel die Python-Beispiel unten zeigt alle drei Arten der Vergabe (es gibt einige subtile Unterschiede in interpretierten Sprachen, die ich nicht hier).

from datetime import datetime

class Animal:
    _FavoriteFood = 'Undefined' # _FavoriteFood is statically allocated

    def PetAnimal(self):
        curTime = datetime.time(datetime.now()) # curTime is automatically allocatedion
        print("Thank you for petting me. But it's " + str(curTime) + ", you should feed me. My favorite food is " + self._FavoriteFood)

class Cat(Animal):
    _FavoriteFood = 'tuna' # Note since we override, Cat class has its own statically allocated _FavoriteFood variable, different from Animal's

class Dog(Animal):
    _FavoriteFood = 'steak' # Likewise, the Dog class gets its own static variable. Important to note - this one static variable is shared among all instances of Dog, hence it is not dynamic!


if __name__ == "__main__":
    whiskers = Cat() # Dynamically allocated
    fido = Dog() # Dynamically allocated
    rinTinTin = Dog() # Dynamically allocated

    whiskers.PetAnimal()
    fido.PetAnimal()
    rinTinTin.PetAnimal()

    Dog._FavoriteFood = 'milkbones'
    whiskers.PetAnimal()
    fido.PetAnimal()
    rinTinTin.PetAnimal()

# Output is:
# Thank you for petting me. But it's 13:05:02.255000, you should feed me. My favorite food is tuna
# Thank you for petting me. But it's 13:05:02.255000, you should feed me. My favorite food is steak
# Thank you for petting me. But it's 13:05:02.255000, you should feed me. My favorite food is steak
# Thank you for petting me. But it's 13:05:02.255000, you should feed me. My favorite food is tuna
# Thank you for petting me. But it's 13:05:02.255000, you should feed me. My favorite food is milkbones
# Thank you for petting me. But it's 13:05:02.256000, you should feed me. My favorite food is milkbones

InformationsquelleAutor

Andere haben direkt Ihre Frage beantwortet, aber wenn man versucht zu verstehen, stack und heap, denke ich, ist es hilfreich zu betrachten, das Speicher-layout von einer traditionellen UNIX-Prozess (ohne Gewinde und mmap()-basierte allocators). Die Memory-Management-Glossar web-Seite hat eine Abbildung dieses memory-layout.

Stack und heap sind traditionell befindet sich an den gegenüberliegenden enden der Prozess des virtuellen Adressraums. Der stack wächst automatisch, wenn Sie aufgerufen werden, bis zu einer Größe gesetzt, die durch den kernel (das kann angepasst werden, mit setrlimit(RLIMIT_STACK, ...)). Der heap wächst, wenn die arbeitsspeicherzuweisung ruft die brk() oder sbrk() system call, mapping-weitere Seiten von physikalischen Speicher, in den Prozess der virtuellen Adressraums.

In Systemen ohne virtuellen Speicher, wie einige embedded-Systeme, die gleichen grundlegenden layout oft gilt, es sei denn der stack und heap sind eine Feste Größe. Jedoch, in anderen embedded-Systemen (wie solche, die auf Microchip PIC-mikrocontroller), die Programm-stack ist ein separater block von Speicher ist nicht adressierbar Daten Bewegung Anweisungen, und können nur geändert werden, oder Lesen Sie indirekt über Programm-Ablauf-Anweisungen (call, return, usw.). Andere Architekturen, wie Intel Itanium-Prozessoren, haben mehrere stacks. In diesem Sinne, ist der stack ein element von der CPU-Architektur.

InformationsquelleAutor bk1e

Ich denke, viele andere Menschen gegeben haben, die Sie meistens richtige Antworten auf diese Frage.

Ein detail wurde übersehen, ist jedoch, dass der "Haufen" sollte in der Tat wohl als "frei speichern". Der Grund für diese Unterscheidung ist, dass die original-free-Shop wurde umgesetzt mit einer Daten-Struktur, bekannt als eine "binomial heap". Aus diesem Grund, die Zuweisung von frühen Implementierungen von malloc()/free() wurde die Zuteilung aus einem heap. Jedoch, in dieser modernen Tag, die meisten free-Shops umgesetzt werden, mit sehr aufwendigen Datenstrukturen, die sich nicht binomial-heaps.

InformationsquelleAutor

Können Sie einige interessante Dinge mit dem stack. Zum Beispiel, Sie haben Funktionen wie alloca (vorausgesetzt, Sie können vorbei an den reichlich Warnungen über seine Verwendung), das ist eine form von malloc, die speziell verwendet den Stapel nicht auf dem heap für den Speicher.

Sagte, stack-basierter Speicher-Fehler sind einige der schlimmsten, die ich erlebt habe. Wenn Sie verwenden, heap-Speicher, und Sie überschreiten die Grenzen der Ihr zugewiesenen block, Sie haben eine gute chance zur Auslösung von segment-Fehler. (Nicht 100%: deine Sperre ist übrigens zusammenhängend mit einem anderen, das Sie zuvor zugewiesen.) Aber da die erstellten Variablen auf dem stack sind immer zusammenhängend mit einander, schreiben out-of-bounds können den Wert einer anderen Variablen. Ich habe gelernt, dass, Wann immer ich das Gefühl, dass mein Programm hat aufgehört zu Gehorsam gegenüber den Gesetzen der Logik, ist es wahrscheinlich Pufferüberlauf.

InformationsquelleAutor Peter

Vom WikiAnwser.

Stack

Wenn eine Funktion oder eine Methode ruft eine weitere Funktion, die wiederum ruft eine andere Funktion, etc., die Ausführung aller dieser Funktionen bleibt angehalten, bis Sie die Letzte Funktion gibt seinen Wert zurück.

Diese Kette aufgehängt-Funktionsaufrufe stack ist, da die einzelnen Elemente im Stapel (function calls), die voneinander abhängen.

Dem Stapel ist wichtig, zu betrachten, Ausnahmebehandlung und Threads Ausführungen.

Heap

Der Haufen ist einfach nur der Arbeitsspeicher, der von Programmen zum speichern von Variablen.
Element des Heaps (Variablen), die keine Abhängigkeiten haben, die mit einander und können jederzeit aufgerufen werden, nach dem Zufallsprinzip zu jeder Zeit.

InformationsquelleAutor devXen

OK, einfach und in kurzen Worten, Sie bedeuten bestellt und nicht bestellt...!

Stack: In der stack-Elemente, die Dinge auf die Spitze jedes-anderen, heißt, wird schneller und effizienter verarbeitet werden!...

So gibt es immer einen index, um die spezifische Element, auch die Verarbeitung wird schneller, es ist die Beziehung zwischen den Elementen, wie gut!...

Heap: Keine Ordnung, die Verarbeitung wird langsamer und Werte sind Durcheinander, zusammen mit keine bestimmte Reihenfolge oder index... gibt es zufällig und es gibt keine Beziehung zwischen Ihnen... so dass die Ausführung und Verwendung Zeit könnte man variieren...

Ich auch das Bild unten, um zu zeigen, wie Sie Aussehen könnte:

InformationsquelleAutor Alireza

In den 1980er Jahren, UNIX vermehrten wie die karnickel mit großen Unternehmen Rollen Ihre eigenen.
Exxon hatte eine, ebenso wie Dutzende von Markennamen Laufe der Geschichte verloren gegangen.
Wie Speicher gelegt wurde, war im Ermessen der vielen implementors.

Einer typischen C-Programm war flach ausgebreitet in Speicher mit
die Möglichkeit zu erhöhen, durch änderung der brk () - Wert.
In der Regel, wird der HAUFEN war direkt unter diesem brk-Wert
und Erhöhung der brk-erhöht die Menge der verfügbaren heap.

Den single-STACK wurde in der Regel ein Bereich unterhalb des HEAP-das war ein Stück Erinnerung
mit nichts von Wert, bis die Spitze der nächsten festen block im Speicher.
Das nächste block war oft CODE, die überschrieben werden können, die von stack-Daten
in einer der bekanntesten hacks seiner Zeit.

Einer typischen Speicher-block wurde BSS (block null-Werte)
war versehentlich nicht genullt bei einem Hersteller anbietet.
Ein weiterer war die DATEN, die initialisiert Werte, einschließlich strings und zahlen.
Ein Dritter wurde CODE mit CRT (C-runtime), Haupt, - Funktionen und-Bibliotheken.

Dem Aufkommen virtueller Speicher in UNIX-Veränderungen, die viele der Einschränkungen.
Es gibt keinen objektiven Grund, warum diese Bausteine müssen aufeinander Folgen
oder eine Feste Größe, oder bestellt eine bestimmte Art und Weise jetzt.
Natürlich, bevor UNIX Multics, die nicht leiden unter diesen Einschränkungen.
Hier ist ein Schema zeigt einer der Speicher-layouts der ära.

InformationsquelleAutor jlettvin

Ein paar cents: ich denke, es wird gut sein, zu zeichnen, memory grafische und mehr einfach:

Pfeile - zeigen Sie, wo Sie wachsen stack und heap, Prozess-stack-Größe zu begrenzen, definiert in OS, thread-stack-Größe, Grenzen, die durch die Parameter im thread erstellen-API in der Regel. Heap in der Regel die Begrenzung von Prozess-maximale Größe des virtuellen Speichers, für 32 bit 2-4 GB zum Beispiel.

So einfach Weg: Prozess-heap ist allgemein für Prozess-und alle Fäden im Innern, die Verwendung für die Speicherzuordnung im Allgemeinen Fall mit so etwas wie malloc().

Stack ist schnell der Speicher für store in common case-Funktion return Zeiger und Variablen verarbeitet, die als Parameter in den Funktionsaufruf, lokalen Funktions-Variablen.

InformationsquelleAutor Maxim Akristiniy

Ich habe etwas zu teilen, obwohl die wichtigsten Punkte sind bereits abgedeckt.

Stack

• Sehr schnellen Zugriff.
• Im RAM gespeichert werden.
• Funktion Anrufe geladen werden hier zusammen mit den lokalen Variablen und Parameter der Funktion übergeben werden.
• Speicherplatz wird automatisch freigegeben, wenn das Programm geht aus einem Anwendungsbereich.
• Gespeichert sequentielle Speicher.

Heap

• Langsam Zugang vergleichsweise zu Stapeln.
• Im RAM gespeichert werden.
• Dynamisch erzeugten Variablen werden hier gespeichert, die später erfordert die Freigabe des allokierten Speichers nach dem Gebrauch.
• Gespeichert, wo Speicherreservierung geschehen ist, zugegriffen, auf den der pointer immer.

Interessante Anmerkung:

• Sollte die Funktion Anrufe gespeichert wurden, in Haufen, es würde hätten dazu geführt, dass in 2 unordentlichen Punkte:
  1. Durch sequentielle Speicherung im stack, die Ausführung ist schneller. Speicher im heap geführt hätte großen Zeitaufwand, wodurch das ganze Programm ausführen langsamer.
  2. Wenn-Funktionen gespeichert wurden, in Haufen (messy Lagerung zeigte Zeiger), es hätte keine Möglichkeit, an den Aufrufer zurückgeben-Adresse zurück (die stack gibt aufgrund der sequentiellen Speicherung im Arbeitsspeicher).

InformationsquelleAutor Pankaj Kumar Thapa

Wow! So viele Antworten und ich glaube nicht, dass einer von Ihnen hat es hinbekommen.

1) Wo und was sind Sie (physisch in einer realen computer-Speicher)?

Ist der stack-Speicher beginnt, als die höchste Speicheradresse zugewiesen zu Ihrem Programm Bild, und es dann sinkt der Wert von dort aus. Es ist reserviert für die aufgerufene Funktion Parameter, und für alle temporären Variablen, die in Funktionen.

Gibt es zwei Haufen: öffentliche und private.

Dem privaten heap beginnt auf einer 16-byte-Grenze (für 64-bit-Programme) oder einen 8-byte-Grenze (für 32-bit-Programme) nach dem letzten byte code in Ihr Programm, und steigt dann im Wert von dort aus. Es wird auch als Standard-heap.

Wenn der private heap wird zu groß, überlappt Sie den stack-Bereich, so wird der stack überlappung der Haufen, wenn er zu groß wird. Da der stack beginnt bei einer höheren Adresse und arbeitet seinen Weg nach unten, um den unteren-Adresse, mit der richtigen hacking-Sie bekommen kann, machen die Stapel so groß, dass es überrennen die private heap-Bereich und überlappen Sie die code-Bereich. Der trick ist dann zu überschneidungen genug von den code-Bereich, können Sie Haken in den code. Es ist ein wenig schwierig zu tun und riskieren Sie einen Absturz, aber es ist einfach und sehr effektiv.

Der öffentlichkeit heap befindet sich in einem eigenen Speicherbereich außerhalb des Programms image space. Es ist diese Erinnerung, wird abgeschöpft werden nun auf die Festplatte, wenn der Speicher Ressourcen knapp sind.

2.) inwiefern werden Sie kontrolliert durch das Betriebssystem oder die Sprache der Laufzeit?

Den stack gesteuert, der durch den Programmierer, der private heap verwaltet wird durch die Bs und die öffentlichkeit heap wird von niemandem kontrolliert, weil es ein OS service-Sie stellen Anforderungen und entweder gewährt oder verweigert.

2b) Was ist Ihr Anwendungsbereich?

Sind Sie alle global auf dem Programm, aber deren Inhalte können sich private, public oder global.

2c), Was bestimmt die Größe eines jeden von Ihnen?

Die Größe des stack und des privaten heap sind, hängt von der compiler-runtime-Optionen. Die öffentlichkeit heap initialisiert wird zur Laufzeit mit Hilfe der parameter size.

2d), Was macht man schneller?

Sind Sie nicht entworfen, um schnell, Sie sind entworfen, um nützlich zu sein. Wie der Programmierer nutzt Sie bestimmt, ob Sie "schnell" oder "langsam"

REF:

https://norasandler.com/2019/02/18/Write-a-Compiler-10.html

https://docs.microsoft.com/en-us/windows/desktop/api/heapapi/nf-heapapi-getprocessheap

https://docs.microsoft.com/en-us/windows/desktop/api/heapapi/nf-heapapi-heapcreate

InformationsquelleAutor ar18