std::stack in C++ meistern: Umfassender Guide mit Praxisbeispielen

Was ist std::stack?

std::stack ist ein Container‑Adapter, der das LIFO‑Prinzip (Last In, First Out) implementiert. Er erlaubt Einfügen und Entfernen von Elementen nur an einem Ende – dem Top. Standardmäßig nutzt er std::deque als zugrundeliegenden Container, aber jeder Sequenz‑Container (z. B. std::vector oder std::list) kann angegeben werden.

Container‑Adapter stellen keine Iteratoren bereit, daher kann man einen Stack nicht direkt durchlaufen. Die Interaktion erfolgt ausschließlich über seine Member‑Funktionen.

Lernziele

• std::stack definieren und LIFO‑Verhalten verstehen
• Syntax für die Deklaration eines Stacks
• Member‑Typen und Kernoperationen kennenlernen
• push, pop, top, empty, size, emplace, swap anwenden
• Stack in der Standard Template Library (STL) implementieren

Syntax

Header <stack> einbinden und Stack mit folgendem Template deklarieren:

template<class T, class Container = std::deque<T>> class stack;

• T – Elementtyp; jeder gültige C++‑Typ, auch benutzerdefinierte Klassen.
• Container – zugrundeliegender Container; Default ist std::deque.

Member‑Typen

• value_type – Elementtyp T.
• container_type – Typ des zugrundeliegenden Containers.
• size_type – Vorzeichenloser Integer für Containergröße.

Kernoperationen

• push() – Element oben anhängen.
• pop() – Oberstes Element entfernen.
• top() – Oberstes Element lesen, ohne zu entfernen.
• empty() – Prüfen, ob Stack leer ist.
• size() – Anzahl Elemente zurückgeben.
• emplace() – Element direkt oben konstruieren und einfügen.
• swap() – Inhalte mit einem anderen Stack tauschen.

Implementierungs‑Überblick

Visuelle Darstellung der Stack‑Operationen (Top durch Pfeil markiert).

push() und pop()

push() fügt ein neues Element an, erhöht die Größe um eins:

stack.push(wert);

pop() entfernt das oberste Element und verringert die Größe:

stack.pop();

Beispiel 1: Grundlegende Stack‑Manipulation

#include <iostream>
#include <stack>
using namespace std;
int main() {
    stack<int> st;
    st.push(10);
    st.push(20);
    st.push(30);
    st.push(40);
    st.pop(); // entfernt 40
    st.pop(); // entfernt 30
    while (!st.empty()) {
        cout << ' ' << st.top();
        st.pop();
    }
    return 0;
}

Ausgabe: 20 10

empty(), size(), top()

Diese Hilfsfunktionen geben schnellen Einblick in den Stack‑Zustand.

Beispiel 2: Stack‑Zustand prüfen

#include <iostream>
#include <stack>
using namespace std;
void display(stack<int> s) {
    while (!s.empty()) {
        cout << '\t' << s.top();
        s.pop();
    }
    cout << '\n';
}
int main() {
    stack<int> st;
    st.push(32);
    st.push(21);
    st.push(39);
    st.push(89);
    st.push(25);
    cout << "Der Stack st ist: ";
    display(st);
    cout << "\n st.size() : " << st.size();
    cout << "\n st.top() : " << st.top();
    st.pop();
    cout << "\n st nach pop: ";
    display(st);
    return 0;
}

Ausgabe: zeigt Stack‑Inhalt, Größe, Top‑Element und Zustand nach einem pop.

emplace() und swap()

• emplace() konstruiert ein Element direkt an Ort und Stelle, vermeidet ein zusätzliches Kopieren.
• swap() tauscht die Inhalte zweier Stacks effizient.

Beispiel 3: emplace() und swap() nutzen

#include <iostream>
#include <stack>
using namespace std;
int main() {
    stack<int> st1, st2;
    st1.emplace(12);
    st1.emplace(19);
    st2.emplace(20);
    st2.emplace(23);
    st1.swap(st2);
    cout << "st1 = ";
    while (!st1.empty()) {
        cout << st1.top() << " ";
        st1.pop();
    }
    cout << endl << "st2 = ";
    while (!st2.empty()) {
        cout << st2.top() << " ";
        st2.pop();
    }
}

Ausgabe: demonstriert Stack‑Inhalte vor und nach dem Tausch.

std::stack in der STL verwenden

Einen Stack mit einer Zeile implementieren:

std::stack<T> st;

Beispiel:

#include <iostream>
#include <stack>
using namespace std;
int main() {
    stack<int> st;
    st.push(12);
    st.push(19);
    st.push(20);
    cout << st.top(); // 20
    cout << st.size(); // 3
    return 0;
}

Zusammenfassung

• std::stack implementiert LIFO und erlaubt nur Zugriff auf das oberste Element.
• Es ist ein Container‑Adapter; Standard‑Container ist std::deque, anpassbar.
• Kernfunktionen: push, pop, top, empty, size, emplace, swap.
• Stack ist ein leichtgewichtiges, effizientes Werkzeug für Szenarien, die temporäre Speicherung von Elementen erfordern.