C++中如何使用std::stack？栈容器push与pop用法详解

std::stack 是 C++ 标准库提供的容器适配器，它并不是一个独立的数据结构，而是通过限制底层容器的接口来实现后进先出（LIFO）语义。使用 std::stack 时，开发者只能访问栈顶元素，通过 push 压入、pop 弹出、top 查看，不能像 vector 或 deque 那样随机访问中间元素。这种约束让栈在表达式求值、括号匹配、函数调用栈模拟等场景中非常适用。要使用 std::stack，需要包含头文件 <stack>。

std::stack 的定义位于标准命名空间 std 中，最常用的声明方式是 std::stack<int> st;。尖括号中的 int 表示元素类型，可以是基础类型、自定义类或指针。默认情况下，std::stack 使用 std::deque 作为底层容器，这也是标准库推荐的默认选择，因为 deque 在两端插入和删除的效率都很稳定，并且不会像 vector 那样在扩容时整体复制元素。

std::stack 的底层原理与接口设计

从实现角度看，std::stack 是一个轻量级包装类，内部持有一个受保护的底层容器成员，比如 std::deque<int> c。push 操作会调用底层容器的 push_back，pop 操作调用 pop_back，top 操作调用 back。也就是说，std::stack 只是把 deque 的一端封住，让使用者只能从同一端操作，从而强制形成后进先出结构。

这种适配器设计的好处是：接口非常小，只有 empty、size、top、push、pop、emplace 和 swap 几个成员函数。越小的接口越不容易误用，也让编译器有更多优化空间。例如，在编译器优化开启后，std::stack 的 push 和 pop 通常会内联到底层容器的对应操作，几乎不会引入额外运行时开销。

下面的示例展示了 std::stack 的基本结构：声明一个整数栈，连续压入三个元素，再依次弹出。注意访问栈顶元素前必须先调用 empty 判断，否则空栈调用 top 或 pop 属于未定义行为。

#include <iostream>
#include <stack>

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

    st.push(10);   // 栈底
    st.push(20);
    st.push(30);   // 栈顶

    while (!st.empty()) {
        std::cout << st.top() << " ";  // 输出栈顶
        st.pop();                          // 移除栈顶
    }
    // 输出：30 20 10
    return 0;
}

从输出顺序可以看到，最后压入的 30 最先被访问和移除，这正是栈的核心特征。若把 push 理解为从顶部放入，pop 就是从顶部取走，top 则只是看一眼顶部内容而不改变栈的大小。

push 与 pop 的核心用法与参数传递

push 函数有两个重载：void push(const value_type& val) 和 void push(value_type&& val)。前者会将传入对象拷贝一份压入栈，后者则尝试移动构造，适合临时对象或不再需要的左值。例如 st.push(std::string("hello")) 会触发移动语义，避免一次不必要的深拷贝。

如果元素类型是自定义类，并且类禁用了拷贝构造，那么 push 的 const 引用重载将无法使用。此时可以通过 std::move 调用移动重载，或者使用 emplace 原地构造。std::stack 也提供了 emplace 函数，它接受构造参数并在栈顶直接构造元素，例如 st.emplace(12, 'a') 可以直接构造一个字符串，避免临时对象。

pop 的行为非常直接：删除栈顶元素，但它不会返回被删除的元素。这一点与很多其他语言或直觉习惯不同。在 Python、Java 等语言中，pop 通常同时返回栈顶值，但 C++ 选择把取值和删除拆开。这个设计并非缺陷，而是出于异常安全考量。下面通过一个常见错误示例说明：

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

int main() {
    std::stack<std::string> st;
    st.push("first");
    st.push("second");

    // 错误：pop 没有返回值，不能赋值
    // std::string val = st.pop();  // 编译错误

    // 正确写法：先 top 再 pop
    std::string val = st.top();
    st.pop();
    std::cout << val << std::endl;  // 输出 second
    return 0;
}

上面的错误写法如果尝试编译，会得到类似 no viable conversion 或 void 到 string 的转换错误。正确写法先通过 top 拿到栈顶元素的副本或引用，再调用 pop 删除它。如果元素体积较大，可以使用 std::move(st.top()) 将栈顶元素移动出来，然后再 pop，但需要注意移动后栈内对象已经处于有效但未指定状态，随后 pop 会正确析构它。

为什么 pop 不返回值：异常安全与资源管理

C++ 标准委员会设计 stack::pop 时，面临一个关键问题：如果 pop 返回栈顶元素，那么在返回过程中如果发生拷贝或移动异常，栈顶元素可能已经弹出，但值却没有成功交给调用者，结果就是元素永久丢失。具体来说，如果 pop 在内部先调用 top 获得元素，再调用底层 pop_back 删除，最后返回元素，一旦返回值的复制构造函数抛出异常，元素已经从栈中删除，无法恢复。

把取值和删除拆分为 top 与 pop 两个操作后，调用者可以先安全地拷贝或移动出栈顶元素，等确认拿到值之后再 pop。这样即使拷贝失败，栈也没有被修改，数据完好无损。对于持有动态内存、文件句柄等资源的自定义类型来说，这种设计尤其重要。

如果需要频繁取出并删除栈顶元素，可以封装一个辅助函数，但辅助函数内部依然必须面对异常安全。最稳妥的方式是让调用者根据元素类型选择拷贝或移动：对于不可抛异常的移动构造，可以直接 auto item = std::move(st.top()); st.pop();；对于拷贝可能抛异常的大型对象，则先检查栈是否为空，再执行拷贝，最后 pop。如果拷贝成功前的 pop 未被调用，栈的一致性得以保留。

底层容器选择与性能对比

std::stack 的第二个模板参数允许指定底层容器，例如 std::stack<int, std::vector<int>> 或 std::stack<int, std::list<int>>。默认的 deque 在两端插入和删除的时间复杂度都是常数级，并且内存按块分配，不会像 vector 那样在容量增长时整体搬移。对于大多数栈场景，deque 是性能与内存使用最均衡的选择。

如果栈的最大容量大致可以预估，并且元素类型较小，vector 可能拥有更好的缓存局部性，因为 vector 的内存是连续分布的。连续内存在遍历访问时对 CPU 缓存更友好，但栈的访问模式本身只涉及顶部，因此这一优势通常并不明显。list 作为底层容器时，每个元素单独分配节点，插入删除不涉及移动数据，但内存开销较大，缓存命中率低，通常不推荐。

下面的代码展示了如何切换底层容器：

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

int main() {
    // 使用 vector 作为底层容器
    std::stack<int, std::vector<int>> vecStack;
    vecStack.push(1);
    vecStack.push(2);
    vecStack.push(3);

    // 使用 list 作为底层容器
    std::stack<int, std::list<int>> listStack;
    listStack.push(10);
    listStack.push(20);

    std::cout << vecStack.top() << " " << listStack.top() << std::endl;
    return 0;
}

需要特别注意的是，不同底层容器的 std::stack 属于不同类型，不能直接互相赋值或比较，除非使用统一的抽象接口或者只通过模板泛型代码操作。比如 vecStack = listStack; 会编译失败，因为 vector 和 list 实例化的 stack 类型不同。如果需要容器无关的代码，可以考虑模板函数接受任意 stack 类型。

多线程环境与常见误区

std::stack 像标准库中其他容器一样，并不保证线程安全。多个线程同时调用 push 或 pop 会导致数据竞争，破坏内部容器结构，甚至崩溃。如果需要在多线程环境下共享栈，必须自行加锁保护。通常可以使用 std::mutex 与 std::lock_guard，将每次操作限制在临界区内。

一个常见的误区是认为 push 和 pop 分别只写或只删栈顶，不需要同步。实际上，即使 push 只是调用底层容器的 push_back，pop 调用 pop_back，deque 内部可能修改多个指针或大小成员，并发读写同一容器会发生未定义行为。另一个误区是在 empty 判断之后直接操作，例如先检查 !st.empty() 再 pop，但另一线程可能恰好在判断之后弹出元素，导致空栈 pop。解决方式是把判断和操作放进同一个锁的作用域，或者使用条件变量协调。

下面是一个加锁的最小示例，使用互斥锁保护整段栈操作：

#include <iostream>
#include <stack>
#include <mutex>
#include <thread>
#include <vector>

class ThreadSafeStack {
public:
    void push(int value) {
        std::lock_guard<std::mutex> lock(mtx_);
        data_.push(value);
    }

    bool try_pop(int& result) {
        std::lock_guard<std::mutex> lock(mtx_);
        if (data_.empty()) {
            return false;
        }
        result = data_.top();
        data_.pop();
        return true;
    }

private:
    std::stack<int> data_;
    std::mutex mtx_;
};

int main() {
    ThreadSafeStack ts;
    std::vector<std::thread> threads;
    for (int i = 0; i < 5; ++i) {
        threads.emplace_back([&ts, i]() {
            ts.push(i * 10);
        });
    }
    for (auto& t : threads) {
        t.join();
    }

    int value = 0;
    while (ts.try_pop(value)) {
        std::cout << value << " ";
    }
    return 0;
}

上面的示例中，push 和 try_pop 都在锁保护下操作底层栈，try_pop 把 empty 检查、top 取值和 pop 删除组成一个不可分割的临界区，从而避免多线程竞争。对于性能要求较高的场景，可以考虑无锁栈实现，但无锁编程复杂度较高，容易引入 ABA 问题和内存回收难题，一般建议优先使用互斥锁，等性能基准证明确实存在瓶颈后再做优化。

总结与最佳实践

std::stack 的 push 和 pop 看似简单，但正确使用需要理解几个关键点：push 负责压入元素，支持拷贝和移动两种语义；pop 只负责删除，不返回元素；top 只负责查看，不修改栈。访问前务必检查 empty，空栈操作属于未定义行为。默认 deque 底层容器能适应大多数场景，只有在特殊内存布局或性能要求下才考虑 vector 或 list。

在复杂业务中，栈常用于解析嵌套结构、回溯算法、括号匹配、DFS 迭代实现等。建议封装一个带异常处理和日志的栈工具类，集中处理空栈检查和类型转换，避免散落各处的重复判断。多线程环境下则统一采用锁保护或使用成熟的并发队列替代，不要直接在裸 std::stack 上做无保护并发操作。

最终写出可靠的栈操作代码并不困难，核心就是始终把 empty 检查、top 取值和 pop 删除作为一个完整操作来对待。只要理解了 pop 不返回值的异常安全原因，并根据场景选择合适的底层容器，std::stack 会在大量 C++ 项目中保持简单高效。

std::stackpushpop修改时间：2026-09-18 11:53:13