C++如何使用STL容器实现队列和栈

std::queue

std::stack

std::deque

std::list

std::vector

std::queue

std::stack

std::deque

std::deque

std::stack

push

pop

top

empty

size

#include <iostream>
#include <stack> // 包含stack头文件
#include <string>

void demonstrateStack() {
    std::stack<std::string> myStack;

    // 入栈操作
    myStack.push("Apple");
    myStack.push("Banana");
    myStack.push("Cherry");
    std::cout << "当前栈顶元素: " << myStack.top() << std::endl; // Cherry

    // 栈的大小
    std::cout << "栈中元素数量: " << myStack.size() << std::endl; // 3

    // 遍历并出栈
    std::cout << "开始出栈: " << std::endl;
    while (!myStack.empty()) {
        std::cout << "弹出: " << myStack.top() << std::endl;
        myStack.pop();
    }
    std::cout << "栈是否为空? " << (myStack.empty() ? "是" : "否") << std::endl; // 是
}

std::queue

push

pop

front

back

empty

size

#include <iostream>
#include <queue> // 包含queue头文件
#include <string>

void demonstrateQueue() {
    std::queue<int> myQueue;

    // 入队操作
    myQueue.push(10);
    myQueue.push(20);
    myQueue.push(30);
    std::cout << "当前队头元素: " << myQueue.front() << std::endl; // 10
    std::cout << "当前队尾元素: " << myQueue.back() << std::endl;  // 30

    // 队列的大小
    std::cout << "队列中元素数量: " << myQueue.size() << std::endl; // 3

    // 遍历并出队
    std::cout << "开始出队: " << std::endl;
    while (!myQueue.empty()) {
        std::cout << "出队: " << myQueue.front() << std::endl;
        myQueue.pop();
    }
    std::cout << "队列是否为空? " << (myQueue.empty() ? "是" : "否") << std::endl; // 是
}

main

std::stack

std::queue

std::vector

std::list

std::stack

std::vector

push_back

pop_back

std::vector

operator[]

insert

erase

std::stack

std::queue

std::deque

std::list

std::vector

std::vector

std::queue

std::deque

std::list

std::stack

std::queue

std::deque

std::list

std::vector

std::deque

std::list

std::vector

#include <stack>
#include <queue>
#include <vector> // 用于作为底层容器
#include <list>   // 用于作为底层容器
#include <deque>  // 默认，但也可以显式指定

// 使用std::list作为底层容器的栈
std::stack<int, std::list<int>> myStackWithList;

// 使用std::vector作为底层容器的栈
// 注意：std::vector作为栈的底层，其push_back和pop_back操作是高效的
std::stack<int, std::vector<int>> myStackWithVector;

// 使用std::list作为底层容器的队列
std::queue<int, std::list<int>> myQueueWithList;

// 使用std::deque作为底层容器的队列（显式指定，与默认行为一致）
std::queue<int, std::deque<int>> myQueueWithDeque;

std::deque

std::queue

std::stack

std::queue

std::stack

push

pop

top

front

back

size

push

pop

push

pop

std::queue

std::stack

std::mutex

#include <mutex>
#include <queue>
#include <condition_variable> // 对于阻塞队列/栈很有用
#include <stdexcept>          // 用于异常处理

// 示例：一个简单的线程安全队列
template <typename T>
class ThreadSafeQueue {
private:
    std::queue<T> q;
    mutable std::mutex mtx; // mutable allows const methods to lock
    std::condition_variable cv; // 用于等待和通知

public:
    void push(const T& value) {
        std::lock_guard<std::mutex> lock(mtx); // 自动加锁解锁
        q.push(value);
        cv.notify_one(); // 通知一个等待的线程有新数据了
    }

    T pop() {
        std::unique_lock<std::mutex> lock(mtx); // 允许在等待时解锁
        // 等待直到队列不为空
        cv.wait(lock, [this]{ return !q.empty(); });
        T value = q.front();
        q.pop();
        return value;
    }

    bool try_pop(T& value) { // 非阻塞式pop
        std::lock_guard<std::mutex> lock(mtx);
        if (q.empty()) {
            return false;
        }
        value = q.front();
        q.pop();
        return true;
    }

    bool empty() const {
        std::lock_guard<std::mutex> lock(mtx);
        return q.empty();
    }

    size_t size() const {
        std::lock_guard<std::mutex> lock(mtx);
        return q.size();
    }
};

// 线程安全栈的实现类似，只是操作接口不同

concurrent_queue

std::mutex

std::condition_variable