std::stack in C++ Onder de Knie: Uitgebreide Handleiding met Praktische Voorbeelden

Wat is std::stack?

std::stack is een container‑adapter die het LIFO‑principe (Last In, First Out) implementeert. Het staat toevoeging en verwijdering van elementen alleen aan één kant toe – de top. Standaard gebruikt het std::deque als onderliggende container, maar elke sequence container (bijv. std::vector of std::list) kan opgegeven worden.

Container‑adapters blootleggen geen iterators, dus je kunt een stack niet direct doorlopen. In plaats daarvan interacteer je ermee via de member‑functies.

Leerdoelen

• std::stack definiëren en LIFO‑gedrag begrijpen
• Syntaxis voor het declareren van een stack leren
• Member types en kernoperaties verkennen
• Werken met push, pop, top, empty, size, emplace en swap
• Een stack implementeren in de Standard Template Library (STL)

Syntaxis

Include de <stack>-header en declareer een stack met de volgende template:

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

• T – Elementtype; elk geldig C++‑type, inclusief user‑defined klassen.
• Container – Onderliggende container; standaard std::deque.

Member Types

• value_type – Het elementtype T.
• container_type – Het type van de onderliggende container.
• size_type – Unsigned integraal type voor container‑grootte.

Kernoperaties

• push() – Voeg een element toe aan de top.
• pop() – Verwijder het top‑element.
• top() – Benader het top‑element zonder verwijdering.
• empty() – Controleer of de stack leeg is.
• size() – Geef het aantal elementen terug.
• emplace() – Construeer en voeg een element direct aan de top in.
• swap() – Wissel inhoud met een andere stack efficiënt.

Implementatie Overzicht

Hieronder een visuele voorstelling van stack‑operaties (top van de stack aangeduid door de pijl).

push() en pop()

De push()-methode voegt een nieuw element toe, wat de grootte met één verhoogt:

stack.push(value);

Omgekeerd verwijdert pop() het top‑element en verlaagt de grootte:

stack.pop();

Voorbeeld 1: Basis Stack Manipulatie

#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(); // verwijdert 40
    st.pop(); // verwijdert 30
    while (!st.empty()) {
        cout << ' ' << st.top();
        st.pop();
    }
    return 0;
}

Output: 20 10

empty(), size(), top()

Deze hulpfuncties geven snel inzicht in de staat van de stack.

Voorbeeld 2: Stack‑Staat Inspecteren

#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 << "The stack st is: ";
    display(st);
    cout << "\n st.size() : " << st.size();
    cout << "\n st.top() : " << st.top();
    st.pop();
    cout << "\n st after pop: ";
    display(st);
    return 0;
}

Output: toont stack‑inhoud, grootte, top‑element en staat na een pop.

emplace() en swap()

• emplace() construëert een element in‑place, wat een extra kopie voorkomt.
• swap() wisselt de inhoud van twee stacks efficiënt.

Voorbeeld 3: emplace() en swap() Gebruiken

#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();
    }
 } 

Output: demonstreert stack‑inhoud voor en na swappen.

std::stack in STL Gebruiken

Implementeer een stack met één regel:

std::stack<T> st;

Voorbeeld:

#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;
 }

Samenvatting

• std::stack implementeert LIFO en staat alleen toegang tot het top‑element toe.
• Het is een container‑adapter; standaard onderliggende container is std::deque, maar kan aangepast worden.
• Kernfuncties: push, pop, top, empty, size, emplace, swap.
• Stack is een lichtgewicht, efficiënt hulpmiddel voor scenario's die tijdelijke opslag van elementen vereisen.