【C++修炼之路】C++容器：stack、queue、deque 基本用法详解

🏝️专栏： 【C++修炼之路】 🌅主页： f狐o狸x

“星星永远不会惧怕黑暗，因为越黑暗星星越闪耀”

目录

一、先理清三者的核心关系与基础认知

二、基础使用前提：头文件与命名空间

三、deque（双端队列）：双端高效操作的序列容器

3.1. deque的核心特性

3.2. deque的常用构造函数（4种高频方式）

3.3. deque的常用成员函数（核心操作）

（1）元素插入（双端+中间）

（2）元素删除（双端+中间）

（3）元素访问与修改（随机访问+双端访问）

（4）容器大小与状态管理

（5）迭代器遍历示例

四、stack（栈）：后进先出的容器适配器

4.1. stack的核心特性

4.2. stack的常用构造函数

3. stack的常用成员函数（核心操作）

五、queue（队列）：先进先出的容器适配器

5.1. queue的核心特性

5.2. queue的常用构造函数

5.3. queue的常用成员函数（核心操作）

六、常见误区与注意事项

七、实战案例：三者的典型应用

案例1：stack实现括号匹配（判断字符串中的括号是否成对有效）

案例2：queue实现简单消息队列（先进先出处理消息）

案例3：deque实现滑动窗口（输出数组中每个窗口的最大值，简化版）

八、三者核心特性对比表格

总结

在C++ STL标准模板库中，stack（栈）、queue（队列）、deque（双端队列）是三组高频使用的线性容器，其中stack和queue并非「原生序列容器」，而是基于容器适配器实现的特殊数据结构，且它们的默认底层容器正是deque。这三者各有独特的访问规则和适用场景，本文将从核心特性出发，逐步讲解它们的构造、常用操作及实战用法，适合C++初学者快速上手，同时兼顾知识的连贯性和实用性。

一、先理清三者的核心关系与基础认知

在正式学习用法前，先建立对这三个容器的整体认知，避免混淆核心概念：

简单比喻：

• deque像一个「两端都能进出的管道」；

• stack像一个「只有顶端能进出的瓶子」（后放进去的东西先拿出来）；

• queue像一个「排队买票的队伍」（先排队的人先买票，后排队的人后买票）。

二、基础使用前提：头文件与命名空间

使用这三个容器前，必须包含对应的头文件，若想简化代码，可引入std命名空间（否则需显式使用std::前缀）：

// 分别包含对应头文件，按需引入
#include <deque> // deque 头文件
#include <stack> // stack 头文件
#include <queue> // queue 头文件
using namespace std;

三、deque（双端队列）：双端高效操作的序列容器

deque是「double-ended queue」的缩写，作为原生序列容器，它弥补了vector（仅尾部高效）和list（不支持随机访问）的部分短板，具备独特的优势。

3.1. deque的核心特性

• 底层：分段连续内存，通过中控器维护各段内存的指针，兼顾连续内存的访问效率和链表的内存灵活性。

• 插入/删除：两端（头部、尾部）插入/删除效率极高，时间复杂度O(1)；中间插入/删除效率较低，时间复杂度O(n)（需移动元素）。

• 访问：支持随机访问（通过下标[]或at()），时间复杂度O(1)，区别于list的双向迭代器。

• 迭代器：支持随机访问迭代器（可进行++、–、+、-操作，如it+3），可正向、反向遍历。

• 适用场景：需要频繁在两端操作元素，且偶尔需要随机访问的场景（如滑动窗口、缓存队列）。

3.2. deque的常用构造函数（4种高频方式）

和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完全一致

3.3. deque的常用成员函数（核心操作）

deque的成员函数兼具vector和list的部分特性，核心操作可分为「增、删、查、改、容器管理」五类：

（1）元素插入（双端+中间）

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

（2）元素删除（双端+中间）

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();

（3）元素访问与修改（随机访问+双端访问）

deque支持两种访问方式，满足不同场景需求：

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

（4）容器大小与状态管理

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}

（5）迭代器遍历示例

#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（栈）：后进先出的容器适配器

stack是一种「适配器容器」，它不直接实现数据存储，而是封装了底层容器（默认deque），并提供专属的接口，强制限制只能在「栈顶」进行操作，符合后进先出的规则。

4.1. stack的核心特性

• 访问规则：仅允许在栈顶（容器的一端）进行插入、删除和访问操作，无法访问栈中间或栈底的元素。

• 底层容器：默认使用deque，也可指定vector或list作为底层容器（如stack<int, vector<int>> st;）。

• 无迭代器：不支持迭代器遍历，无法通过循环遍历所有元素（只能通过弹出栈顶元素的方式逐个获取）。

• 时间复杂度：栈顶的插入（push）、删除（pop）、访问（top）操作均为O(1)。

• 适用场景：需要后进先出逻辑的场景（如括号匹配、函数调用栈、表达式求值、逆序输出数据）。

4.2. stack的常用构造函数

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）

3. stack的常用成员函数（核心操作）

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;
}

输出结果：

注意：

五、queue（队列）：先进先出的容器适配器

queue同样是「适配器容器」，默认底层容器为deque，它强制限制「一端插入、另一端删除」，符合先进先出的规则，类似日常生活中的排队场景。

5.1. queue的核心特性

• 访问规则：队尾（back）插入元素，队头（front）删除元素，仅能访问队头和队尾元素，无法访问队列中间元素。

• 底层容器：默认使用deque，也可指定list作为底层容器（如queue<int, list<int>> q;，不推荐vector，因为vector头部删除效率低）。

• 无迭代器：不支持迭代器遍历，无法通过循环直接遍历所有元素（只能通过弹出队头元素的方式逐个获取）。

• 时间复杂度：队尾插入（push）、队头删除（pop）、队头/队尾访问均为O(1)。

• 适用场景：需要先进先出逻辑的场景（如任务队列、消息队列、排队模拟、广度优先搜索（BFS））。

5.2. queue的常用构造函数

和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）

5.3. queue的常用成员函数（核心操作）

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;
}

输出结果：

注意：

六、常见误区与注意事项

七、实战案例：三者的典型应用

案例1：stack实现括号匹配（判断字符串中的括号是否成对有效）

#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;
}

输出结果：

案例2：queue实现简单消息队列（先进先出处理消息）

#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;
}

输出结果：

案例3：deque实现滑动窗口（输出数组中每个窗口的最大值，简化版）

#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（双端队列）

总结

1. deque 是原生双端队列，支持双端高效操作和随机访问，是 stack、queue 的默认底层容器，适合需要两端操作且偶尔随机访问的场景。

2. stack 是后进先出适配器，仅支持栈顶操作，无迭代器，适合括号匹配、逆序输出等 LIFO 逻辑场景。

3. queue 是先进先出适配器，支持队尾入、队头出，无迭代器，适合任务队列、BFS 等 FIFO 逻辑场景。

4. 容器适配器（stack/queue）无 clear() 方法，需循环 pop() 清空，操作前务必用 empty() 判断是否为空，避免未定义行为。

对于C++初学者而言，掌握这三个容器的核心用法，能灵活应对多数线性数据结构的应用场景，后续可结合更多实战案例，深化对STL容器的理解与运用。