C++ STL Stack and Queue Explained — Usage, Pitfalls and Patterns

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

// Simulates a browser's back-button history using std::stack.
// Each page visit is pushed; clicking Back pops the most recent page.

void visitPage(std::stack<std::string>& history, const std::string& url) {
    history.push(url);  // Add the new URL on top of the stack
    std::cout << "  Visited: " << url << "\n";
}

void goBack(std::stack<std::string>& history) {
    if (history.empty()) {
        std::cout << "  [Back] Nothing to go back to.\n";
        return;
    }
    // Read the top BEFORE popping — pop() returns void in STL!
    std::string currentPage = history.top();
    history.pop();  // Remove the current page from history

    if (history.empty()) {
        std::cout << "  [Back] Left " << currentPage << " — no previous page.\n";
    } else {
        std::cout << "  [Back] Left " << currentPage
                  << " — now on: " << history.top() << "\n";
    }
}

int main() {
    // Use std::vector as the underlying container — faster for known-depth stacks
    std::stack<std::string, std::vector<std::string>> browserHistory;

    std::cout << "--- Browsing Session ---\n";
    visitPage(browserHistory, "https://thecodeforge.io");
    visitPage(browserHistory, "https://thecodeforge.io/cpp");
    visitPage(browserHistory, "https://thecodeforge.io/cpp/stl");

    std::cout << "\n--- Clicking Back Three Times ---\n";
    goBack(browserHistory);  // leaves cpp/stl, lands on /cpp
    goBack(browserHistory);  // leaves /cpp, lands on homepage
    goBack(browserHistory);  // leaves homepage, nothing left
    goBack(browserHistory);  // guard clause fires — already empty

    return 0;
}

#include <iostream>
#include <queue>
#include <string>

// Models a printer's job queue.
// Jobs are submitted in arbitrary order but always printed FIFO.

struct PrintJob {
    int         jobId;
    std::string documentName;
    int         pageCount;
};

void submitJob(std::queue<PrintJob>& jobQueue, const PrintJob& job) {
    jobQueue.push(job);  // New job joins the back of the queue
    std::cout << "  Queued   [#" << job.jobId << "] "
              << job.documentName << " (" << job.pageCount << " pages)\n";
}

void processNextJob(std::queue<PrintJob>& jobQueue) {
    if (jobQueue.empty()) {
        std::cout << "  [Printer] Queue is empty — nothing to print.\n";
        return;
    }

    // front() gives us the oldest job without removing it
    const PrintJob& nextJob = jobQueue.front();
    std::cout << "  Printing [#" << nextJob.jobId << "] "
              << nextJob.documentName << " — "
              << nextJob.pageCount << " pages...\n";

    jobQueue.pop();  // Job is done — remove from the front

    // Show what's waiting next (if anything)
    if (!jobQueue.empty()) {
        std::cout << "  Next up  [#" << jobQueue.front().jobId << "] "
                  << jobQueue.front().documentName << "\n";
    } else {
        std::cout << "  Queue is now empty.\n";
    }
}

int main() {
    std::queue<PrintJob> printerQueue;  // Uses std::deque internally by default

    std::cout << "--- Submitting Print Jobs ---\n";
    submitJob(printerQueue, {101, "Q3_Financial_Report.pdf",  42});
    submitJob(printerQueue, {102, "Team_Photo.png",            1});
    submitJob(printerQueue, {103, "Employee_Handbook.pdf",   120});

    std::cout << "\n--- Printer Working Through Queue ---\n";
    std::cout << "Jobs waiting: " << printerQueue.size() << "\n\n";

    while (!printerQueue.empty()) {
        processNextJob(printerQueue);
        std::cout << "\n";
    }

    // One extra call to confirm the empty guard works
    processNextJob(printerQueue);

    return 0;
}

#include <iostream>
#include <stack>
#include <queue>
#include <vector>
#include <unordered_set>

// Simple undirected graph stored as an adjacency list.
// Demonstrates that DFS naturally uses a stack and BFS a queue.
// Graph topology: 0-1, 0-2, 1-3, 1-4, 2-5
//
//        0
//       / \
//      1   2
//     / \   \
//    3   4   5

using Graph = std::vector<std::vector<int>>;

void depthFirstSearch(const Graph& graph, int startNode) {
    std::stack<int> toVisit;          // LIFO — explore deep before wide
    std::unordered_set<int> visited;

    toVisit.push(startNode);
    std::cout << "DFS order: ";

    while (!toVisit.empty()) {
        int currentNode = toVisit.top();  // Peek at the most recently added node
        toVisit.pop();

        if (visited.count(currentNode)) continue;  // Skip already-visited nodes
        visited.insert(currentNode);
        std::cout << currentNode << " ";

        // Push neighbours — they'll be explored before wider siblings
        for (int neighbour : graph[currentNode]) {
            if (!visited.count(neighbour)) {
                toVisit.push(neighbour);
            }
        }
    }
    std::cout << "\n";
}

void breadthFirstSearch(const Graph& graph, int startNode) {
    std::queue<int> toVisit;          // FIFO — explore wide before deep
    std::unordered_set<int> visited;

    toVisit.push(startNode);
    visited.insert(startNode);
    std::cout << "BFS order: ";

    while (!toVisit.empty()) {
        int currentNode = toVisit.front();  // Always process the oldest node
        toVisit.pop();
        std::cout << currentNode << " ";

        for (int neighbour : graph[currentNode]) {
            if (!visited.count(neighbour)) {
                visited.insert(neighbour);
                toVisit.push(neighbour);  // Neighbour joins back of the line
            }
        }
    }
    std::cout << "\n";
}

int main() {
    // Build adjacency list for the tree shown above
    Graph cityNetwork(6);
    auto addEdge = [&](int u, int v) {
        cityNetwork[u].push_back(v);
        cityNetwork[v].push_back(u);
    };

    addEdge(0, 1); addEdge(0, 2);
    addEdge(1, 3); addEdge(1, 4);
    addEdge(2, 5);

    depthFirstSearch(cityNetwork, 0);   // Goes deep: 0 -> 2 -> 5 -> 1 -> 4 -> 3
    breadthFirstSearch(cityNetwork, 0); // Level by level: 0 -> 1 -> 2 -> 3 -> 4 -> 5

    return 0;
}