Stack in C++: how std::stack works, with examples

A stack in C++ is a std::stack, from the header <stack>: a container that hands back the most recently added element first, last in, first out. push() adds an element on top, top() reads the top element and pop() removes it. pop() returns nothing, so read top() first, and check empty() before either.

A browser’s back button, in a whole program:

#include <iostream>
#include <stack>
#include <string>

int main() {
    std::stack<std::string> history;
    history.push("home");
    history.push("search");
    history.push("article");

    std::cout << history.top() << '\n';    // article
    history.pop();                         // removes "article"
    std::cout << history.top() << '\n';    // search
    std::cout << history.size() << '\n';   // 2
}

It printed:

article
search
2

The last page pushed, article, is the first one top() reads and the first one pop() removes. The answer is written for C++17 (Since When’s C++17 table gives the first GCC, Clang and MSVC releases of its features). The samples were built as C++17 with MSVC 19.44, Clang 19.1 (MSVC STL), GCC 16.2 and Clang 23.1 (libc++), and all four printed the same.

How do push, top and pop work?

All three act on the top only: push() puts a new element there, top() gives you that element to read or change, and pop() takes it off. emplace(), in the library since C++11, also adds on top, but builds the element in place from its arguments:

std::stack<std::string> history;
std::cout << std::boolalpha;
std::cout << history.empty() << '\n';  // true

history.push("home");                  // copies or moves it in
history.push("search");
history.emplace("article");            // builds it in place

std::cout << history.top() << '\n';    // article
history.top() = "settings";            // top() is a reference
std::cout << history.top() << '\n';    // settings

std::cout << history.size() << '\n';   // 3
std::cout << history.empty() << '\n';  // false

All four printed true, article, settings, 3 and false. top() returns a reference to the top element, so assigning through it changed article to settings.

The members of std::stack:

Because pop() returns void, code that expects the removed element from it does not compile:

std::string page = history.pop();   // error: pop() returns void

Clang said:

error: no viable conversion from 'void' to 'std::string'

MSVC reports the same line as error C2440. To keep the element, copy it first and pop second: std::string page = history.top();, then history.pop();.

What happens if you pop or top an empty stack?

Calling top() or pop() on an empty stack is undefined behavior: the standard sets no rule for what happens next and promises neither an exception nor a crash, unless, since C++26, a hardened standard library checks the call first and reports a contract violation. A stack passes both calls to its container’s back() and pop_back(), and those require a container that is not empty ([sequence.reqmts]). Test empty() first:

void go_back(std::stack<std::string>& history) {
    if (history.empty()) {              // check before top() and pop()
        std::cout << "nothing to go back to\n";
        return;
    }
    std::cout << "back from " << history.top() << '\n';
    history.pop();
}

Called twice on a stack holding only article, it printed back from article, then nothing to go back to.

How do you loop through a stack?

Loop while the stack is not empty, reading top() and then popping; the elements come out newest first:

while (!history.empty()) {
    std::cout << history.top() << '\n';
    history.pop();
}
std::cout << history.size() << '\n';   // 0: the loop emptied it

With home, search and article pushed in that order, all four printed article, search and home, then 0.

A stack has no iterators, the objects a range-for uses to walk through a container, so for (const auto& page : history) does not compile. Clang stops with invalid range expression of type 'std::stack<std::string>' and no viable 'begin' function available.

What is a stack used for?

A stack fits any job where the last thing in is the first thing you need back: a back button, an undo list, the brackets still open in a line of code. Two of them are common course exercises.

Reverse a word

Push each letter, then pop them all; the last letter comes out first:

std::string reversed(const std::string& word) {
    std::stack<char> letters;
    for (char letter : word)
        letters.push(letter);           // first letter at the bottom

    std::string result;
    while (!letters.empty()) {
        result += letters.top();        // last letter comes out first
        letters.pop();
    }
    return result;
}

It printed kcats for “stack” and elcitra for “article”.

Check that brackets are balanced

Push each opening bracket; each closing bracket must match the one on top, which is the most recent bracket still open:

char opener_for(char closer) {
    if (closer == ')') return '(';
    if (closer == ']') return '[';
    return '{';
}

bool balanced(const std::string& text) {
    std::stack<char> open;
    for (char c : text) {
        if (c == '(' || c == '[' || c == '{') {
            open.push(c);
        } else if (c == ')' || c == ']' || c == '}') {
            if (open.empty())
                return false;           // a closer with nothing open
            if (open.top() != opener_for(c))
                return false;           // it closes the wrong bracket
            open.pop();
        }
    }
    return open.empty();                // anything left was never closed
}

All four printed true for {[()]}, false for ([)], whose ) meets a [ on top, and false for ((, which leaves two brackets open.

How is a stack implemented in the STL?

On top of another container: a std::deque, a double-ended queue, unless you name another. std::stack is a container adaptor, a class that wraps a container and lets you reach only its top: its push(), top() and pop() call the container’s push_back(), back() and pop_back() ([stack.defn]). Any sequence container with those three can sit underneath, and std::vector, std::deque and std::list all qualify. A second template argument picks one, here a std::vector:

std::stack<int, std::vector<int>> numbers;   // a vector underneath
numbers.push(10);
numbers.push(20);
numbers.push(30);

std::cout << numbers.top() << '\n';    // 30
numbers.pop();
std::cout << numbers.top() << '\n';    // 20
std::cout << numbers.size() << '\n';   // 2

All four printed 30, 20 and 2. Courses also ask for a stack written by hand on an array or a linked list; in real code, std::stack is the one to use. The other containers are in Standard library.

Stack vs queue: what is the difference?

A stack hands back the newest element first, last in, first out; a queue hands back the oldest, first in, first out:

The queue’s members and examples are in C++ queue: how std::queue works.

Is std::stack the same as “the stack” in memory?

No. “The stack”, as opposed to “the heap”, is the region of memory where a function’s local variables live, and std::stack is a container you create. They share the last-in, first-out idea and nothing else: with the default allocator, the std::deque under a std::stack allocates its elements on the heap.

A checklist for stack code

• Include <stack>, and <string> for a stack of strings.
• Read top() before pop(): pop() returns nothing.
• Check empty() before top() or pop().
• Loop with while (!history.empty()); a range-for does not compile.
• To look below the top, keep the elements in a std::vector or a std::deque instead.