Stapelspeicher



In der Informatik bezeichnet man einen Stapelspeicher oder Kellerspeicher (Kurz Stapel oder Keller , mit einer vollständigen englischen Version von Wort Stack bezeichnet) und eine dynamisch dynamische Struktur . Sie werden von Microprozessoren in der Hardware direkt unterstützt.

Funktion Prinzip

Eine Stufe kann den theoretisch gläubigen Men von von Objects aufnehmen. Elemente können nur auf die Stapel gelegt werden und auch nur von der draller. Elemente wurden tiefer gestapelt und im Riff eingeschlossen. Gesenke Wird Auch Last-In-First-Out -Prinzip (LIFO) genannt.

Dazu wurden folgende Operationen zur Verfügung gestellt:

push (auch „einkaufern“)
Lege deine Objekte auf den Stapel.
pop („auskellern“)
liefertes oberstes Objekt und entfernt vom Stapel. Bei Mancha Prozessor Wie sie MOS Technology 6502 Wird this Aktion dagegen ziehen ( „herunterziehen“) genannt.
peek ( „nachsehen“)
liefert das oberste Objekt, ohne es zu entfernen (oben auch oben genannt, auch „oben“).

In den Automaten Werden Stapel Benutzt, um Bestimmt Problemklasse theoretisch zu betrachten can (VGL. Keller – Maschine ). Sie unterscheidet deshalb genau between Ein Echter Kellerspeicher (kurz Keller ), bei ihnen kein Elemente außer ihnen Oberst Gelesen Werden Kann, und Ein Stapelspeicher , bei ihnen jedes Elemente betrachtet, aber nicht Verändert Werden Kann. In der Praxis ist dies die Unterscheidung jeder Menge Rolle; beinahe jede Implementierung ist ein Stapel. Dafür wurden die Begriffe im Allgemeinen Synonym.

Illustration

Skizze eines Stacks

Ein Stapelspeicher ist mit einem Stapel von Umzugskisten vergleichbar. Sie können immer wieder auf den Stapel von Pfählen zurückgreifen (Acht- Drück-Push ) oder andere Kiste von oben heruntergenommen werden (eentdicht pop ). Der Zug ist im Regelfall nur auf dem oberen Element des Stapels möglich. Ein Hinzufügen oder Entfernen einer Kiste weiter unten im Stapel ist nicht möglich. Die Aber in Manchen Implementation Units Befehle, über den Colonel Elemente zu vertauschen (SWAP, ROT).

Geschichte

Die verwendung Eines Stapelspeichers zur Übersetzung von Programmiersprachen Wurde 1957 von Friedrich L. Bauer und Klaus Samelson Unter dem Namen „Kellerprinzip“ patentiert [1] [2] und ETWA zur Zeit Selb unabhängig vom australischen Philosophen Charles Hamblin Entwickelt. Der lange ausgebliebene internationale Anerkennung und ihre Ehrung Leistung erfolgt erst im Jahr 1988. Bauer Erhielt den renommierten Computer – Pioneer Award ( IEEE ) für Computer – Stacks. Samelson Krieg bereitet 1980 verzerrt vor.

Anwendungen

Mit dem Namen des Stahlspeichers schweissen sich einfach Begriffe oder Syntaxen auf der rechten Seite aus, damit wer oft online für BB-Codes oder XML- Dokumente des Herbstes ist.

Mikroprozessoren

Bei Mikroprocessoren gibt es oft ein spezielles Register , den Stackpointer (Stapelzeiger). Dieses Register enthält eine Speicheradresse, die den aktuellen Stapeleintrag (den aktuellen Prozess ) betrachtet. Viele Befehle / Operation des Mikroprozessors brauchen diesen Stapeleintrag. Unter Anderem ist also befiehlt, mit Denen Mann im Stapel schreiben (z. B. Push beim x86 Prozessor ) oder von IHNEN Lese Scan (z. B. Pop ). Dabei wird automatisch der Stapelzeiger verschlechtert bzw. erhöht.

Die Operation Springe zu einem Unterprogramm setzt sie auf Stack die Rücksprung-Adresse ab, die sich von der Operation Return From Subroutine verwöhnt wird. Unterprogramme bzw. Die Funktion, die Programmierung heißt, die C lehrt, wurde zum Parameter des Stacks, der auch die Rückgabewerte aufnimmt. Außerdem wurden lokalisierte Variablen auf dem Stack lokalisiert. Dies geschieht unter anderer Rekursion, Das aufrufen Einer Funktion aus ebendieser Funktion heraus. Wird bei der Rückkehr Aus einer Funktion nur ein Eintrag zu viel oder zu wenig ausgelesen, Führen sterben zu BESONDERS gravierenden Programmfehlern, wenn Prozessor Dann Wird versuch, Code Völlig abhängig Zufällig Speicherposition auszuführen. Durch das ausnutzen Einer nicht korrekt Behandelt Größenangabe der Daten can Angreifer versuch, EINEM Pufferüberlauf zu Produzieren, wo der Stapel so Verändert that Durch umleiten Dezember Rücksprung bösartiger – Code ausgeführt Wird.

Bei den meisten der Prozessor Beginnt bei Stapel Einer Hohen Adresse und Wird in RICHTUNG der Adresse 0 gestapelt. Das Bedeutende that bei Push dort Stapelzeiger vermindert und etwas in den Stapel geschrieben Wird und bei Pop vom Stapel Gelesen und der Stapelzeiger erhöht Wird. Der Stapel wächst „nach unten“, in RICHTUNG niedrigerer Speicheradressen. Dies ist historisch begründet: Geheilte bei begrenztem Speicher der Stapel Unterhalb Dezember Speicherplatz, wo von dem Prog Rahmen Benutzt Wird, can also anderes Programm Daten (die normalen Hinter dem Programm abgelegt Werden) die Stapel nicht so leicht überschreiben und den Stapel nicht das Maschinenprogramm.

In Multitasking- Systemen Gibt es für jeden Prozess und innerhalb der Prozesse für jeden Thread einen eigenen Stapelspeicher. Beim switch switch processes Threads wird neben anderen Registratoren auch der jeweiligen Stapelzeiger Spione und geladen.

Um Fehler in der benutzung Dezember Stacks Durch einen „Unterlauf “ der Stapelzeiger aufzudecken, Arzt MANCHERMANCHEMANCHES Betriebssystem Wie beispielsweise DOS oder CP / M (bei COM – Anwendungen) oder Schaufel-O als unter Stein Wert im Stapel stirbt Sprungadresse Wacholder Abbruch- oder Fehlerbehandlungsroutine ab. Holt der Prozessor Durch EINEN Fehler in der Aufrufverschachtelung this Adresse vom Stapel, Kann GGF noch auf den Ablauffehler reagiert Werden. Manche Betriebssystem Können Auch die Stapelspeicher der Laufzeit vergrößern während, war bei Einem BEREITS sehr Grossen Stapel relativ viel Zeit in anspruch nehmen Kann. Bei other Betriebssystem Hass es Programmierer selbst anzugeben, Wie groß , wo Stapel sein soll.

Um die Nutzungsgrade Dezember meist Begrenzt Stapelspeicher zu ermitteln, bedient man sich die sogenannte Wasser Stände-Methode: Wo gesamt für den Stapelspeicher reservation Speicher Wird mit Einem fixen Datenmuster initialisiert Und dann das Programm Geste Liste. Anhand der Bereich, sterben nach Einer Gewiss noch das Laufzeit Initialisierungsmuster Enthalten, Kann festgestellt Werden, Wie viel Platz Auf dem Stapel Wirklich genutzt Wurde.

Programmierung Reden

Compiler BZW. Interpreter für Programmiersprachen verwenden gewöhnlich Push- Operationen für das Aufrufende Unterprogramm, um diesen Parameter zu übergehen. Weil der Compiler, der den Parameter lehrt, ist bekannt als die Großen haben. Ähnlich können auch Ergebnisse des Unterprogramms zurückgegeben werden. Für lokale Variablen des Unterprogramms wird dieser Mechanismus nochmals erweitert, so dass auch für den Stapelspeicher Platz reserviert wird. Dadurch wird das Unterprogramm rekursiv aufrufbar. When the Umwandlung eines rekursiven Unterprogramms in ein iteratives Unterprogramm muss dieser Mechanismus implementiert werden.

Programmiersprachen, sterben Auf eine (prozessbasierte) virtuelle Maschine aufsetzen (zum beispiel Java , P-Code – Pascal ), optimiert die kompilierten Zwischencode für sterben verwendung Eines Stapel, um zur LaufzeitInterpretation sterben of this Zwischencodes zu beschleunigen.

Stapel-Implementierung

In C ++:

#include <stdexcept>
template < Type - Name T >
Klasse Stack
{
 public :
 // Erzeugt EINEN Leeren Stapel
 Stapel () : size_ ( 0 ) {}
 // Erzeugt EINEN Stapel mit n Elemente von T -
 Stack ( size_t n , T Wert_ ) : size_ ( 0 )
 {
 für ( int i = 0 ; i < n ; ++ i )
 drücken ( Wert_);
 }
 // Konstruktor-
 Stack kopieren ( const stack & rhs ) : size_ ( 0 )
 {
 // Wenn der "straight" Stack keine Elemente enthält, muss nichts weiter getan.
 wenn ( rhs . size_ ! = 0 ) {
 Knoten * überquert = rhs . oben ;
 size_t size_ = rhs . Größe ();
 // Beenden zum ersten Element, dann zum zweiten Element, usw.
 für (; Größe_ > 0 ; - size_ ) {
 für ( unsigned in = 1 ; in < size_ ; ++ in )
 quert = quert -> vorherigen ;
 drücken ( Schiebebühne -> Wert );
 quert = rhs . oben ;
 }
 }
 }
 ~ stack ()
 {
 für { ; size_ ! = 0 ; pop ());
 }
 // Zuweisungsoperator
 stack & operator = ( const stack & rhs )
 {
 // Überprüft ob ein Stack sich selbst zugeworfen wird.
 if ( & rhs ! = & * this )
 {
 für (; size_ ! = 0 ; pop ());
 // vgl. Kopierkonstruktor
 wenn ( RHS . Size_ ! = 0 ) {
 Knoten * quert = rhs . oben ;
 size_t size_ = rhs . Größe ();
 für (; size_ > 0 ; - size_ ) {
 für ( unsigned in = 1 ; in < size_ ; ++ in )
 quert = quert -> vorherigen ;
 drücken ( Schiebebühne -> Wert );
 quert = rhs . oben ;
 }
 }
 }
 gib * das zurück;
 }
 void push ( T- Wert_ )
 {
 node * newNode ;
 // .previous des unteren Stackelementes muss 0 sein, damit das Ende des Stacks
 // ermittelt werden kann.
 if ( size_ == 0 )
 newNode = neuer Knoten ( value_ , 0 );
 sonst
 newNode = neuer Knoten ( value_ , top );
 top = neuer Knoten ;
 ++ Größe_ ;
 }
 T pop ()
 {
 wenn ( size_ == 0 )
 throw std :: underflow_error ( "Nichts Pop." );
 // Rückgabewert sichern
 T returnValue = top -> Wert ;
 Knoten * newTop = oben -> vorherige ;
 Top löschen ; top = newTop ; - Größe_ ; return returnValue ; } T peek () const
 { zurück nach oben -> Wert ; }
 size_t size () const { return size_ ; }
 privat :
 struct node
 {
 T- Wert ;
 Knoten * vorheriger ;
 Knoten ( T Wert_ , Knoten * vorheriger_ ) : Wert ( Wert_ ), vorheriger ( vorheriger_ ) {}
 };
 Knoten * oben ;
 std:: size_t size_ ; // ab C ++ 11 nicht mehr im Standard-Namensraum
};

In Java:

// Ein Stapel dynamischer Größe, alle
// Elemente Klasse
Tüde dein // Unterklassen verwalten können.
public class Stapel < T > {
Privat Artikel < T > Start = null ;
öffentliche Leere Push ( T Objekt ) { // Speichert ein neues Objekt
starten = neue Element < T > ( Objekt , beginnen );
}
öffentlich T top () { // Gibt das oberste Objekt wieder
zurück ! ( Leer ()) ? start . getObject () : null ;
}
public boolean empty () { // Prüfen, ob der Stapel leer ist
Zurück Start == null ;
}
public T pop () { // Gibt das oberste Objekt wieder und entfernt es aus dem Stapel
T tmp = ! ( leer ()) ? top () : null ;
wenn (!leer ()) start = starten . getNext ();
zurück tmp ;
}
}
public class Item < S > {
privates S- Objekt ; // Dies ist der Gewinnergegenstand
Private Item < S > next ; // Referenz auf den nächsten Knoten
Öffentlichkeit Artikel ( S Objekt , Artikel weiter ) {
diese . Objekt = Objekt ;
diese. nächste = nächste ;
}
public S getObject () { // Gibt das abgespeicherte Objekt aus
return object ;
}
Öffentliche Artikel < S > GetNext () { // Gibt den Nächsten Knoten aus
zurückkehren nächsten ;
}
}

In Python:

Klasse Stapel ( Objekt ):
 def __init__ ( Selbst )
 selbst . Maxindex = 5
 selbst . TopIndex = 0
 selbst . Speicher = [ 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 ]
 def isEmpty ( self ):
 Rückselbst .top index == 0
 def isFull ( self ):
 return self . Top-Index == selbst . max index
 def push ( selbst , element ):
 wenn nicht selbst . isFull ():
 Selbst . Top-Index + = 1
 selbst . speicher [ Selbst . top index ] = element
 def pop ( selbst ):
 wenn nicht selbst. isEmpty ():
 Selbst . top index - = 1
 def top ( selbst ):
 wenn nicht selbst . isEmpty ()
 zurückkehren Selbst . speicher [ Selbst . Top-Index ]
 def DisplayStack ( self ):
 M = selbst . topindex
 während M > 0 :
 drucken ( "|" , self . speicher [ M], "|" )
 M - = 1
 Druck ( "------------------ |" ) ,
wenn __name__ == "__main__" : #Beispiel
 MyStack = Stapel ()
 Druck ( MyStack . IsFull ( ))
 Drucken ( myStack . isEmpty ())
 myStack . Push ( 5 )
 MyStack . schieben ( 3 )
 MyStack . DisplayStack ()
 drucken (meinStack . isEmpty ())
 myStack . Push ( 13 )
 MyStack . DisplayStack ()

Darüber hinaus werden in der Standard Library implementierte Programming-Sind-Stacks implementiert. Also, Java Diese Funktionalität in der Klasse java.util.LinkedListzur Verfügung. In der C ++ Standard Template Library wird die Template stack<T>Eccentric Functionalit implementiert, die normalerweise als Alternative zu dieser Liste verwendet wird.

Compiler

Zur Übersetzung der Quellcodes Wacholder Form Ellen Sprache Nutzen Compiler und Interpreter EINES Parser , wo EIN Stapel used. Der Parser weiß z. B. Wie ein Keller – Maschine Arbeiten.

Verarbeitung von Klammerstrukturen

Der Stapelspeicher besitzt ein großes Glücksgefühl durch den Klammerausdrücken, der in der Mathematik lebt. Dabei wird zuerst für Operatoren und Operanden ein Stapelspeicher initialisiert. Der zu präparative Klammerdruck wird nur symbolweise eingelesen. Würde eine geöffnete Klemme eingelassen, so ist diese zu ignorieren. Wird ein Operand oder Operator eingelesen, so ist dieser auf der Jeweiligen Stapelspeicher zu legen.

Wird Eine Schließen Klammer eingelesen, so Wird der Oberste Operator vom Stapelspeicher für Betreiber Genommen und entsprechend diesem Operator Eine geeignete Anzahl von Operanden sterben, sterben zur Durchführung wo Betrieb benötigt Werden. Deshalb ist es ein guter Job für die Betreiber. Sobald in dem Stapelspeicher für Bediener leer ist sterben, befindet sich im Stapelspeicher für Werkzeug Operand das Plan Ergebnis.

Postfix Notation

Zur Berechnung von Begriff Wird gelegentlich sterben Postfixnotation used, sterben mit Hilfe Der Betrieb Eine Klammersetzung und der Prioritätsregeln für die Operation Überfluß macht sterben. Zahlwerte wurde automatisch aufgegeben. Binara Operator (zum beispiel +, -, *, /) Alkohol stirbt Oberen Beiden Werte, Unar Operator (zum beispiel Vorzeichenwechsel) EIN Wert vom Stapel und Arzt anschließend das (Zwischen-) Plan Ergebnis dort wieder ab.

Infixnotation

Bei der dort Auflösung von arithmetischen Ausdrücken maschinengestützten so genannte Infixnotation (wo Operator Steht between den beteiligten Zahlwerten) Wird zunächst vorrangigen Teilterme in Einem Stapel zwischengelagert und so faktisch wo Infix Term schrittweise in EINEM Postfix Term umgewandelt, Bevor das Plan Ergebnis Durch abarbeiten Dezember Stapel errechnet Wird.

Stapelorientierte Sprachen

Stapelorientierte Sprachen (z. B. Forth oder Postscript ) wickeln schnell alle Variablen ein -Operation über einen oder mehrere Stapel von Abkürzungen und Bemerkungen Operatoren oder weitere zur Verfügung. Beispielsweise täuscht , wo Forth Operator Swap sterben Oberst Beiden Elemente des heften. Arithmetische Operationen wurden in der Postfix-Notation und Flint Damit ebenfalls den Stapel geschrieben.

Forth verwendet einen zweiten Stapel (Return-Stapel) ist die Zwischenspeicherung der Rücksprung-Adressen von Unterprogrammen während der Ausführungsphase. Dieser Stapel wird auch während der Übersetzungsphase für die Adressen der Sprungziele für die Kontrollstrukturen verwendet. Die Übergabe und Rückgabe von Wert und Unterprogrammes erfolgt über den ersten Stapel, die zweite Adresse ist die Rücksprungadresse auf. In diesem Fall ist Implementierungen für einen weiteren Stapel für Gleitkommaoperationen vorgesehen.

Stack-Architektur

Eine Stack-Architektur widmet sich dem DATA-Betrieb (auch ohne separate Push- und Pop-Befehle) auf einem einzigen Stack. Bedenken Sie den Intel-FPU (Gleitkommaprozessor) und den Hewlett-Packard-Taschenrechner.

Verwendete Themen

Ihre First-In-First-Out- Date- Struktur wird als Warteschlange (Engl. Queue ) bezeichnet. Beide Struktur zeigen ein Unterschiedlich verhalten, aber HaBen Same Signatur (d. H. Methoden Struktur), weswegen sie oft zusammen unterrichtet Werden.

Ein weiterer Speicher ist die dynamische Speicherverwaltung , mit der die Speicheranforderungen bedient werden können. Of this Speicher Wird oft als Heap bezeichnet und Wird eingesetzt, Wenn Die lebensdauer der zu speichernden Objekte Unterschiedlich ist und nicht sie eingeschränkten Prinzip des Stapelspeichers oder der Warteschlange Entspricht.

Siehe auch

  • Flood Fill
  • deque
  • Stack Trace

Literatur

  • Patent DE1094019 : Verfahren zum automatischen Verarbeiten von Daten und Rechenmaschine zur Ausübung des Verfahrens. Erinnere dich an mich am 30. März 1957 , veröffentlicht am 1. Dezember 1960 , Erfinder: Friedrich Ludwig Bauer, Klaus Samelson (Erteilt 12. August 1971).

Weblinks

 Commons: Stack-Datenstruktur – Sammlung von Bildern, Videos und Audiodateien

Einzelstunden

  1. Hochspringen↑ Friedrich L. Bauer , Gerhard Goos : Informatik. Eine einführende Übersicht. Erster Teil. 3. Auflage. Springer, Berlin, 1982, ISBN 3-540-11722-9 , S. 222. „Die Bezeichnung, hierfür‘ Keller Würde von Bauer und Samelson in Einem deutschen Patentanmeldung vom 30. März 1957Hollywood.“
  2. Hochspringen↑ Patent DE1094019 : Elle Verfahren zum MATIC VERARBEITUNG von kodierten Daten und Rechenmaschine zur Ausübung Dezember Elle Verfahren. Angemeldet am 30. März 1957 , veröffentlicht am 1. Dezember 1960 , Erfinder: Friedrich Ludwig Bauer, Klaus Samelson.