stack

C++ <stack> Header

The <stack> header is part of the C++ Standard Template Library (STL) that provides the std::stack container adapter. A stack is a Last-In-First-Out (LIFO) data structure, where elements are inserted and removed only from one end, called the top of the stack. This container adapter is implemented on top of other container classes like deque (default), vector, or list, providing a specific interface to the underlying container.

Key Characteristics

• Implements a Last-In-First-Out (LIFO) data structure
• Provides a restricted interface to the underlying container
• Supports operations like push (insert), pop (remove), and top (access)
• Does not allow iteration through its elements
• Can be implemented on top of different container classes
• Offers constant time complexity for push and pop operations
• Does not provide direct access to elements other than the top

Example 1: Basic Stack Operations

#include <iostream>
#include <stack>

int main() {
    std::stack<int> myStack;

    // Pushing elements
    myStack.push(10);
    myStack.push(20);
    myStack.push(30);

    std::cout << "Stack size: " << myStack.size() << std::endl;
    std::cout << "Top element: " << myStack.top() << std::endl;

    // Popping elements
    myStack.pop();
    std::cout << "After pop, top element: " << myStack.top() << std::endl;

    // Checking if stack is empty
    std::cout << "Is stack empty? " << (myStack.empty() ? "Yes" : "No") << std::endl;

    return 0;
}

Explanation:

• We create a stack of integers using the default underlying container (std::deque).
• push() is used to add elements to the top of the stack.
• top() accesses the top element without removing it.
• pop() removes the top element.
• size() returns the number of elements in the stack.
• empty() checks if the stack is empty.

2. Using Stack with Custom Types

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

struct Book {
    std::string title;
    int year;

    Book(std::string t, int y) : title(std::move(t)), year(y) {}
};

int main() {
    std::stack<Book> bookStack;

    bookStack.push({"The C++ Programming Language", 2013});
    bookStack.push({"Effective Modern C++", 2014});
    bookStack.push({"C++ Concurrency in Action", 2019});

    std::cout << "Books in stack:" << std::endl;
    while (!bookStack.empty()) {
        const Book& book = bookStack.top();
        std::cout << book.title << " (" << book.year << ")" << std::endl;
        bookStack.pop();
    }

    return 0;
}

Explanation:

• We define a custom Book struct to demonstrate using stack with user-defined types.
• Books are pushed onto the stack.
• We use a while loop to print and remove all books from the stack.
• This example shows how stack maintains the LIFO order of inserted elements.

Example 3: Stack with Different Underlying Container

#include <iostream>
#include <stack>
#include <vector>
#include <list>

template <typename T>
void printStackInfo(const std::stack<T>& s) {
    std::cout << "Stack size: " << s.size() 
              << ", Top element: " << (s.empty() ? 0 : s.top()) << std::endl;
}

int main() {
    std::stack<int> defaultStack;
    std::stack<int, std::vector<int>> vectorStack;
    std::stack<int, std::list<int>> listStack;

    for (int i = 1; i <= 5; ++i) {
        defaultStack.push(i);
        vectorStack.push(i * 10);
        listStack.push(i * 100);
    }

    std::cout << "Default stack (deque): ";
    printStackInfo(defaultStack);

    std::cout << "Vector-based stack: ";
    printStackInfo(vectorStack);

    std::cout << "List-based stack: ";
    printStackInfo(listStack);

    return 0;
}

Explanation:

• We create stacks with different underlying containers: default (std::deque), std::vector, and std::list.
• The interface and usage of the stack remain the same regardless of the underlying container.
• This demonstrates the flexibility of the stack adapter in working with different container types.

Example 4: Implementing a Simple Calculator using Stack

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

int evaluatePostfix(const std::string& expression) {
    std::stack<int> stack;
    std::istringstream iss(expression);
    std::string token;

    while (iss >> token) {
        if (isdigit(token[0])) {
            stack.push(std::stoi(token));
        } else {
            int operand2 = stack.top(); stack.pop();
            int operand1 = stack.top(); stack.pop();

            switch (token[0]) {
                case '+': stack.push(operand1 + operand2); break;
                case '-': stack.push(operand1 - operand2); break;
                case '*': stack.push(operand1 * operand2); break;
                case '/': stack.push(operand1 / operand2); break;
            }
        }
    }

    return stack.top();
}

int main() {
    std::string expression = "5 3 + 2 * 4 -";
    std::cout << "Postfix expression: " << expression << std::endl;
    std::cout << "Result: " << evaluatePostfix(expression) << std::endl;

    return 0;
}

Explanation:

• This example implements a simple postfix expression evaluator using a stack.
• Numbers are pushed onto the stack.
• When an operator is encountered, two operands are popped, the operation is performed, and the result is pushed back.
• This demonstrates a practical use of stack in parsing and evaluating expressions.

Example 5: Checking for Balanced Parentheses

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

bool areParenthesesBalanced(const std::string& expression) {
    std::stack<char> stack;

    for (char c : expression) {
        if (c == '(' || c == '[' || c == '{') {
            stack.push(c);
        } else if (c == ')' || c == ']' || c == '}') {
            if (stack.empty()) return false;

            char top = stack.top();
            stack.pop();

            if ((c == ')' && top != '(') ||
                (c == ']' && top != '[') ||
                (c == '}' && top != '{')) {
                return false;
            }
        }
    }

    return stack.empty();
}

int main() {
    std::string expr1 = "{[()]}";
    std::string expr2 = "([)]";
    std::string expr3 = "((";

    std::cout << expr1 << " is " << (areParenthesesBalanced(expr1) ? "balanced" : "not balanced") << std::endl;
    std::cout << expr2 << " is " << (areParenthesesBalanced(expr2) ? "balanced" : "not balanced") << std::endl;
    std::cout << expr3 << " is " << (areParenthesesBalanced(expr3) ? "balanced" : "not balanced") << std::endl;

    return 0;
}

Explanation:

• This example uses a stack to check if parentheses in an expression are balanced.
• Opening brackets are pushed onto the stack.
• For each closing bracket, we check if it matches the top of the stack.
• The expression is balanced if all brackets match and the stack is empty at the end.
• This is a common interview question and practical application of stacks.

Additional Considerations

1. Performance: Operations on a stack are generally constant time O(1), but this can depend on the underlying container.

2. Memory Usage: The memory usage of a stack depends on its underlying container and the number of elements.

3. Thread Safety: std::stack is not thread-safe by default. For concurrent access, external synchronization is needed.

4. Adaptors vs Containers: Remember that std::stack is an adaptor, not a container itself. It provides a specific interface to an underlying container.

5. Limitations: Stack doesn't provide iterators or allow access to elements other than the top, which can be limiting in some scenarios.

Summary

The <stack> header in C++ provides the std::stack container adapter, implementing a Last-In-First-Out (LIFO) data structure:

• It offers a restricted set of operations: push, pop, top, size, and empty.
• The stack can be implemented on top of various container classes, with std::deque as the default.
• It's useful for algorithms that require LIFO ordering, such as depth-first search, expression evaluation, and backtracking.
• Stack operations typically have constant time complexity, making it efficient for its specific use cases.
• While limited in its interface, the stack is powerful in scenarios where LIFO behavior is required.

The std::stack is an essential tool in a C++ programmer's toolkit, particularly useful in parsing, algorithm implementation, and memory management scenarios. Its simplicity and efficiency make it a go-to choice when LIFO behavior is needed. However, its restricted interface means that for more complex data manipulation, other container types might be more appropriate. Understanding when and how to use std::stack effectively can lead to cleaner, more efficient code in many algorithmic and data processing applications.

Related

• What are the main functions provided by the include file
• How can be used to manage dynamic memory in C++
• What are the common use cases for the library
• How does compare to other container classes in C++
• Can be used with generic programming in C++