C++ STL 标准模板库中的 stack、queue 和 deque 是高频使用的线性容器。deque 是原生序列容器，支持双端高效操作和随机访问；stack 和 queue 是基于 deque 实现的容器适配器，分别遵循后进先出和先进先出规则。文章详细讲解了它们的头文件引入、构造函数、核心成员函数、常见误区以及括号匹配、消息队列、滑动窗口等实战案例，帮助开发者根据场景选择合适的容器。
在 C++ STL 标准模板库中，stack（栈）、queue（队列）、deque（双端队列）是三组高频使用的线性容器，其中 stack 和 queue 并非「原生序列容器」，而是基于实现的特殊数据结构，且它们的默认底层容器正是 deque。这三者各有独特的访问规则和适用场景，本文将从核心特性出发，逐步讲解它们的构造、常用操作及实战用法。
在正式学习用法前，先建立对这三个容器的整体认知，避免混淆核心概念：
简单比喻：
使用这三个容器前，必须包含对应的头文件，若想简化代码，可引入 std 命名空间（否则需显式使用 std:: 前缀）：
// 分别包含对应头文件，按需引入
#include <deque> // deque 头文件
#include <stack> // stack 头文件
#include <queue> // queue 头文件
using namespace std;
deqeue 是「double-ended queue」的缩写，作为原生序列容器，它弥补了 vector（仅尾部高效）和 list（不支持随机访问）的部分短板，具备独特的优势。
[] 或 at()），时间复杂度 O(1)，区别于 list 的双向迭代器。++、--、+、- 操作，如 it+3），可正向、反向遍历。和 list、vector 的构造方式高度相似，初学者可快速迁移知识：
// 1. 空构造（默认构造）：创建一个空的 deque，存储 int 类型元素
deque<int> dq;
// 2. 填充构造：创建包含 n 个相同值的 deque
deque<int> dq1(5, 10); // 5 个元素，每个值为 10
deque<int> dq2(3); // 3 个元素，每个值为 int 默认值 0
// 3. 迭代器范围构造：通过其他容器的迭代器范围复制构造
vector<int> vec = {1,2,3,4,5};
deque<int> dq3(vec.begin(), vec.end()); // 复制 vec 所有元素
deque<int> dq4(vec.begin(), vec.begin()+3); // 复制前 3 个元素
// 4. 拷贝构造：通过另一个 deque 复制构造
deque<int> dq5(5, 10);
deque<int> dq6(dq5); // dq6 与 dq5 完全一致
deqeue 的成员函数兼具 vector 和 list 的部分特性，核心操作可分为「增、删、查、改、容器管理」五类：
deque<int> dq;
// 1. 尾部插入：push_back()，O(1)
dq.push_back(10);
dq.push_back(20);
// 2. 头部插入：push_front()，O(1)（vector 无此函数）
dq.push_front(5);
dq.push_front(1);
// 3. 中间插入：insert()，O(n)（需移动元素）
// 迭代器指向第 2 个元素（值为 5），插入 15
deque<int>::iterator it = ++dq.begin();
dq.insert(it, 15);
// 此时 dq 内容：1 15 5 10 20
deque<int> dq = {1,15,5,10,20};
// 1. 尾部删除：pop_back()，O(1)，删除 20
dq.pop_back();
// 2. 头部删除：pop_front()，O(1)，删除 1
dq.pop_front();
// 3. 中间删除：erase()，O(n)
// 删除迭代器指向的元素（15），返回下一个元素的迭代器
it = dq.begin();
it = dq.erase(it);
// 4. 清空所有元素：clear()，O(n)
dq.clear();
deqeue 支持两种访问方式，满足不同场景需求：
deque<int> dq = {1,2,3,4,5};
// 方式 1：随机访问（下标 [] 或 at()），O(1)
cout << "第 3 个元素（下标 2）：" << dq[2] << endl; // 输出 3（无越界检查）
cout << "第 4 个元素（下标 3）：" << dq.at(3) << endl; // 输出 4（有越界检查，更安全）
// 方式 2：双端访问（front() 头部、back() 尾部），O(1)
cout << "头部元素：" << dq.front() << endl; // 输出 1
cout << "尾部元素：" << dq.back() << endl; // 输出 5
// 修改元素（两种方式均可）
dq[2] = 30; // 下标修改，将 3 改为 30
dq.front() = 10; // 头部修改，将 1 改为 10
dq.back() = 50; // 尾部修改，将 5 改为 50
// 此时 dq 内容：10 2 30 4 50
deque<int> dq = {1,2,3};
// 1. 获取元素个数：size()，O(1)
cout << "元素个数：" << dq.size() << endl; // 输出 3
// 2. 判断是否为空：empty()，O(1)
cout << "是否为空：" << dq.empty() << endl; // 输出 0（false）
// 3. 调整容器大小：resize()
dq.resize(5, 100); // 调整为 5 个元素，新增元素为 100，结果{1,2,3,100,100}
dq.resize(2); // 调整为 2 个元素，删除多余元素，结果{1,2}
#include <deque>
#include <iostream>
using namespace std;
int main() {
deque<int> dq = {10,20,30,40,50};
// 1. 正向遍历（随机访问迭代器）
cout << "正向遍历：";
for (deque<int>::iterator it = dq.begin(); it != dq.end(); it++) {
cout << *it << " ";
}
cout << endl;
// 2. 反向遍历
cout << "反向遍历：";
for (deque<int>::reverse_iterator it = dq.rbegin(); it != dq.rend(); it++) {
cout << *it << " ";
}
cout << endl;
// 3. 下标遍历（支持随机访问的优势）
cout << "下标遍历：";
for (int i = 0; i < dq.size(); i++) {
cout << dq[i] << " ";
}
cout << endl;
return 0;
}
输出结果：
stack 是一种「适配器容器」，它不直接实现数据存储，而是封装了底层容器（默认 deque），并提供专属的接口，强制限制只能在「栈顶」进行操作，符合后进先出的规则。
stack<int, vector<int>> st;）。stack 的构造方式较为简单，主要有两种：
// 1. 空构造（默认构造）：创建一个空的栈，默认底层容器为 deque
stack<int> st;
// 2. 拷贝构造：通过另一个 stack 复制构造
stack<int> st1;
st1.push(10);
st1.push(20);
stack<int> st2(st1); // st2 与 st1 完全一致，包含 10、20（栈顶为 20）
stack 的接口非常简洁，仅提供与栈顶相关的操作，无复杂逻辑，初学者容易掌握：
#include <stack>
#include <iostream>
using namespace std;
int main() {
stack<int> st;
// 1. 栈顶插入元素：push(elem)，O(1)（压栈）
st.push(10);
st.push(20);
st.push(30);
// 此时栈内元素（从栈底到栈顶）：10 → 20 → 30
// 2. 访问栈顶元素：top()，O(1)（仅查看，不删除）
cout << "当前栈顶元素：" << st.top() << endl; // 输出 30
// 3. 删除栈顶元素：pop()，O(1)（出栈，无返回值，仅删除）
st.pop(); // 删除 30，栈顶变为 20
cout << "出栈后栈顶元素：" << st.top() << endl; // 输出 20
// 4. 获取元素个数：size()，O(1)
cout << "栈内元素个数：" << st.size() << endl; // 输出 2
// 5. 判断栈是否为空：empty()，O(1)
cout << "栈是否为空：" << st.empty() << endl; // 输出 0（false）
// 6. 清空栈（stack 无 clear() 函数，需通过循环 pop() 实现）
while (!st.empty()) {
st.pop();
}
cout << "清空后栈是否为空：" << st.empty() << endl; // 输出 1（true）
return 0;
}
输出结果：
注意：
pop()函数无返回值，仅删除栈顶元素，若需要获取栈顶元素，需先调用top()查看，再调用pop()删除。stack 没有clear()成员函数，清空栈需通过循环调用pop()，直到empty()返回 true。当栈为空时，调用top()和pop()会触发未定义行为，建议操作前先用empty()判断。
queue 同样是「适配器容器」，默认底层容器为 deque，它强制限制「一端插入、另一端删除」，符合先进先出的规则，类似日常生活中的排队场景。
queue<int, list<int>> q;，不推荐 vector，因为 vector 头部删除效率低）。和 stack 类似，queue 的构造方式也较为简洁：
// 1. 空构造（默认构造）：创建一个空的队列，默认底层容器为 deque
queue<int> q;
// 2. 拷贝构造：通过另一个 queue 复制构造
queue<int> q1;
q1.push(10);
q1.push(20);
queue<int> q2(q1); // q2 与 q1 完全一致，包含 10、20（队头 10，队尾 20）
queue 的接口同样简洁，仅提供与队头、队尾相关的操作，逻辑清晰：
#include <queue>
#include <iostream>
using namespace std;
int main() {
queue<int> q;
// 1. 队尾插入元素：push(elem)，O(1)（入队）
q.push(10);
q.push(20);
q.push(30);
// 此时队列元素（从队头到队尾）：10 → 20 → 30
// 2. 访问队头元素：front()，O(1)（仅查看，不删除）
cout << "当前队头元素：" << q.front() << endl; // 输出 10
// 3. 访问队尾元素：back()，O(1)（仅查看，不删除）
cout << "当前队尾元素：" << q.back() << endl; // 输出 30
// 4. 删除队头元素：pop()，O(1)（出队，无返回值，仅删除）
q.pop(); // 删除 10，队头变为 20
cout << "出队后队头元素：" << q.front() << endl; // 输出 20
// 5. 获取元素个数：size()，O(1)
cout << "队列内元素个数：" << q.size() << endl; // 输出 2
// 6. 判断队列是否为空：empty()，O(1)
cout << "队列是否为空：" << q.empty() << endl; // 输出 0（false）
// 7. 清空队列（queue 无 clear() 函数，需通过循环 pop() 实现）
while (!q.empty()) {
q.pop();
}
cout << "清空后队列是否为空：" << q.empty() << endl; // 输出 1（true）
return 0;
}
输出结果：
注意：
pop()函数无返回值，仅删除队头元素，若需要获取队头元素，需先调用front()查看，再调用pop()删除。queue 没有clear()成员函数，清空队列需通过循环调用pop()，直到empty()返回 true。当队列为空时，调用front()、back()和pop()会触发未定义行为，操作前务必用empty()判断。
#include <stack>
#include <iostream>
#include <string>
using namespace std;
// 判断括号是否有效匹配
bool isValidBracket(const string& s) {
stack<char> st;
for (char c : s) {
// 左括号入栈
if (c == '(' || c == '[' || c == '{') {
st.push(c);
} else {
// 右括号：栈为空则无匹配的左括号，直接返回 false
if (st.empty()) {
return false;
}
// 取出栈顶左括号，判断是否与当前右括号匹配
char topChar = st.top();
st.pop();
if ((c == ')' && topChar != '(') || (c == ']' && topChar != '[') || (c == '}' && topChar != '{')) {
return false;
}
}
}
// 遍历结束后，栈为空说明所有括号都匹配完成
return st.empty();
}
int main() {
string s1 = "()[]{}";
string s2 = "([)]";
string s3 = "{[]}";
cout << s1 << " 是否有效：" << (isValidBracket(s1) ? "是" : "否") << endl;
cout << s2 << " 是否有效：" << (isValidBracket(s2) ? "是" : "否") << endl;
cout << s3 << " 是否有效：" << (isValidBracket(s3) ? "是" : "否") << endl;
return 0;
}
输出结果：
#include <queue>
#include <iostream>
#include <string>
using namespace std;
// 简单消息队列类
class MessageQueue {
private:
queue<string> msgQueue; // 存储消息的 queue
public:
// 发送消息（队尾入队）
void sendMsg(const string& msg) {
msgQueue.push(msg);
cout << "发送消息：" << msg << endl;
}
// 接收消息（队头出队）
void recvMsg() {
if (msgQueue.empty()) {
cout << "无未读消息！" << endl;
return;
}
string msg = msgQueue.front();
msgQueue.pop();
cout << "接收消息：" << msg << endl;
}
// 查看未读消息数量
int getUnreadCount() const {
return msgQueue.size();
}
};
int main() {
MessageQueue mq;
mq.sendMsg("Hello, C++ STL!");
mq.sendMsg("这是一个队列消息");
mq.sendMsg("消息处理完成～");
cout << "未读消息数量：" << mq.getUnreadCount() << endl;
mq.recvMsg();
mq.recvMsg();
mq.recvMsg();
mq.recvMsg();
return 0;
}
输出结果：
#include <deque>
#include <iostream>
#include <vector>
using namespace std;
// 滑动窗口：窗口大小为 k，输出每个窗口的最大值（简化版）
void slidingWindowMax(const vector<int>& nums, int k) {
deque<int> dq; // 存储数组下标，维护窗口内的最大值下标
for (int i = 0; i < nums.size(); i++) {
// 1. 移除超出窗口范围的下标
if (!dq.empty() && dq.front() < i - k + 1) {
dq.pop_front();
}
// 2. 移除 deque 中比当前元素小的下标，保证 deque 头部是窗口最大值下标
while (!dq.empty() && nums[dq.back()] < nums[i]) {
dq.pop_back();
}
// 3. 当前下标入队
dq.push_back(i);
// 4. 窗口大小达到 k 时，输出最大值
if (i >= k - 1) {
cout << "窗口 [" << i - k + 1 << "," << i << "] 最大值：" << nums[dq.front()] << endl;
}
}
}
int main() {
vector<int> nums = {1,3,-1,-3,5,3,6,7};
int k = 3;
slidingWindowMax(nums, k);
return 0;
}
输出结果：
为了方便大家快速梳理和记忆，整理了 stack、queue、deque 的核心特性对比：
| 特性 | stack（栈） | queue（队列） | deque（双端队列） |
|---|---|---|---|
| 数据结构类型 | 容器适配器 | 容器适配器 | 原生序列容器 |
| 访问规则 | 后进先出（LIFO），仅栈顶操作 | 先进先出（FIFO），队尾入、队头出 | 双端操作 + 随机访问 |
| 底层默认容器 | deque | deque | -（自身为底层容器） |
| 支持的核心操作位置 | 栈顶 | 队头（删、查）、队尾（插、查） | 头部、尾部、中间（随机访问） |
| 迭代器支持 | 不支持 | 不支持 | 支持随机访问迭代器 |
| 核心成员函数 | push()、pop()、top() | push()、pop()、front()、back() | push_front/back()、pop_front/back()、[]、at() |
| 清空方式 | 循环 pop() | 循环 pop() | clear()（直接支持） |
| 时间复杂度（核心操作） | O(1) | O(1) | 双端操作 O(1)，随机访问 O(1) |
| 典型适用场景 | 括号匹配、函数调用栈 | 任务队列、BFS、排队模拟 | 滑动窗口、缓存队列、双端操作场景 |
对于 C++ 初学者而言，掌握这三个容器的核心用法，能灵活应对多数线性数据结构的应用场景，后续可结合更多实战案例，深化对 STL 容器的理解与运用。
微信公众号「极客日志」，在微信中扫描左侧二维码关注。展示文案：极客日志 zeeklog
使用加密算法（如AES、TripleDES、Rabbit或RC4）加密和解密文本明文。 在线工具，加密/解密文本在线工具，online
将字符串编码和解码为其 Base64 格式表示形式即可。 在线工具，Base64 字符串编码/解码在线工具，online
将字符串、文件或图像转换为其 Base64 表示形式。 在线工具，Base64 文件转换器在线工具，online
将 Markdown（GFM）转为 HTML 片段，浏览器内 marked 解析；与 HTML转Markdown 互为补充。 在线工具，Markdown转HTML在线工具，online
将 HTML 片段转为 GitHub Flavored Markdown，支持标题、列表、链接、代码块与表格等；浏览器内处理，可链接预填。 在线工具，HTML转Markdown在线工具，online
通过删除不必要的空白来缩小和压缩JSON。 在线工具，JSON 压缩在线工具，online