C++ Stack与Queue全解：从容器适配器到单调栈算法

很多人学C++的时候，Stack和Queue这两个容器常常被当成"入门玩具"——用一下push、pop就扔到一边去了。但等你真正开始刷题、做项目、看开源代码的时候，会发现这两个看似简单的容器几乎无处不在：函数调用栈、表达式求值、BFS搜索、消息队列、单调栈优化……热搜词里"单调栈算法c++""c++八股文""c++面试题"常年霸榜，而它们背后最底层的骨架，恰恰就是Stack和Queue。

这篇文章我打算换一个角度来写，不单纯罗列API。我会把这两个容器从基础接口到底层机制、从经典使用场景到实战解题思路完整串一遍，最后再附上我在实际调试和面试中反复遇到的坑。无论你是刚学C++的初学者，还是正在准备面试的求职者，这篇文章都能给你一份可以直接落地的参考。

1. 先搞清楚Stack和Queue到底解决了什么问题

1.1 两种截然相反的"秩序"

先说一个我经常在带新人时问的问题：为什么要单独设计Stack和Queue这样的容器，直接用vector或者list不好吗？

答案在于"约束"本身。vector给你的是一种完全自由的顺序存储，你想从哪读就从哪读，想在哪插就在哪插。但在真实的计算场景里，有些数据关系天生就是受限的：

• Stack（栈）：后进先出，LIFO（Last In First Out）。你最后放进去的东西，会最先被拿走。就像一摞盘子，你总是拿最上面那个；浏览器后退按钮，你总是回到最近一次访问的页面。

• Queue（队列）：先进先出，FIFO（First In First Out）。你先放进去的东西，会最先被处理。就像排队买奶茶，先来的先服务；打印机任务列表，先提交的文档先打印。

这种"约束"正是它们的价值所在。当你把一个数据放上Stack的时候，你其实是在向阅读代码的人传递一个明确信号：这里需要的就是后进先出的语义。反过来，如果所有地方都用vector然后手动管理索引，代码的可读性会大打折扣，而且边界条件极其容易出错。

1.2 C++ STL里它们到底长什么样

在C++标准模板库（STL）中，Stack和Queue都是容器适配器（container adapter）。这个概念很多人没意识到，实际上非常关键：

cpp复制template<class T, class Container = std::deque<T>>
class stack;

template<class T, class Container = std::deque<T>>
class queue;

"适配器"意味着它们并不自己存储数据，而是对底层容器（默认是deque，双端队列）进行了一层接口封装。Stack对外只暴露push、pop、top这些符合栈语义的操作，屏蔽掉底层容器的其他能力。你在外面看不到begin、end这类迭代器方法，因为栈本身就不该允许你随意遍历。

默认底层是deque而不是vector，这一点也值得提一下：

• deque支持在头部和尾部都能以常数时间插入删除，正好满足栈只需要在一端操作、队列需要在两端操作的需求
• deque没有像vector那样要求元素连续存储，因此不会因为扩容而搬运已有元素，push操作很少出现迭代器失效的情况

这也是为什么你在做算法题的时候可以直接无脑用std::stack和std::queue，因为它们在这两个容器的默认选型上，已经帮你做了性能和安全性的权衡。

2. Stack基础操作与两个容易理解错的地方

2.1 一张表看懂Stack所有核心接口

Stack的接口非常少，少到几乎不可能记不住：

一个最基础的用法示例：

cpp复制#include <iostream>
#include <stack>

int main() {
    std::stack<int> st;
    
    st.push(10);
    st.push(20);
    st.push(30);
    
    std::cout << "栈顶元素: " << st.top() << std::endl;   // 30
    std::cout << "栈的大小: " << st.size() << std::endl;  // 3
    
    st.pop();  // 弹出30
    std::cout << "弹出后栈顶: " << st.top() << std::endl; // 20
    
    while (!st.empty()) {
        std::cout << st.top() << " ";
        st.pop();
    }
    // 输出: 20 10
    return 0;
}

2.2 三个让我和同事都栽过的理解误区

误区一：认为pop()会返回被弹出的元素。

这是Stack使用中最经典的错误。很多从Java或Python转过来的开发者会下意识写int x = st.pop();，但C++的pop()返回类型是void，弹出的元素在函数内部就被丢弃了。正确写法是先用top()取到值，再pop()：

cpp复制int value = st.top();
st.pop();

为什么C++要这样设计？根本原因在于异常安全。pop()在C++98时代就已经存在，如果设计成返回元素值，那么在"返回"的过程中拷贝构造可能抛出异常，而此时元素已经从栈中移除，调用方手中既没有值、栈也已经被修改，数据就丢了。所以标准库刻意把"读取"和"删除"拆成两个独立步骤，让你明确知道自己在干什么。

误区二：在空栈上调用top()或pop()不会崩。

很多人写代码时觉得"反正我push过了，应该不会空"。但在实际循环处理数据时，栈是否为空往往取决于输入数据的匹配情况。一旦在空栈上调用top()或pop()，这是未定义行为（Undefined Behavior）——在大多数实现下程序会直接崩溃，或者更隐蔽地，返回一个野值让你后续逻辑全部错乱。

cpp复制std::stack<int> st;
// st为空
int x = st.top(); // 未定义行为！可能崩溃，可能返回随机值

安全做法是每次top()之前先判空，或者用短路判断：

cpp复制if (!st.empty()) {
    int x = st.top();
    st.pop();
}

误区三：Stack不能遍历这件事，很多人直到面试时才发现自己没想过。

Stack接口没有begin()和end()，这意味着你不能用范围for循环去遍历它。有些人在需要"看一眼栈里所有元素"的时候会犯难。常见变通办法有：

• 用一个临时栈，边遍历边弹出，最后再恢复
• 直接把数据放到std::vector里，用push_back和pop_back手动模拟栈，需要遍历时就访问vector

第二种方式在工程里其实很常见，尤其是当你需要调试栈内容时。std::vector完全可以当栈用，只是语义上不如std::stack清晰。

2.3 给Stack换底层容器：什么时候需要这么做

Stack的模板第二个参数允许你指定底层容器为std::vector、std::deque或std::list，只要容器支持push_back、pop_back、back这些操作。什么时候值得换？

• 使用vector：如果你需要频繁访问栈内任意位置的元素（比如调试或算法需要），vector支持随机访问，deque虽然也支持但缓存局部性不如vector。另外vector相比deque内存占用更小、遍历更快。
• 使用list：如果栈中元素很大、拷贝成本高，list的节点分配方式可能更灵活。但实际上因为list的额外指针开销，大部分场景反而不如deque。

我自己在算法题里用得最多的反而是vector模拟栈，原因很简单：算法题里常常需要同时兼顾"栈的push/pop"和"对栈内元素的随机访问"，比如单调栈的某些变体题目，用std::stack反而还要多开一个数组来记录下标。

cpp复制// 用vector模拟栈，兼顾随机访问
std::vector<int> st;
st.push_back(1);
st.push_back(2);
int back = st.back();
st.pop_back();
for (int i = 0; i < st.size(); ++i) {
    std::cout << st[i] << " ";  // 可以随机访问
}

3. Queue基础操作与FIFO的底层秘密

3.1 Queue接口与Stack的对比

Queue的接口和Stack非常对称，但在取值入口上有个重要差别：

为什么Queue要同时提供front()和back()？因为在FIFO模型中，"读取数据"和"新增数据"发生在两个不同的端。当你需要知道下一个要处理的任务是啥，看front()；当你需要知道新任务排在哪个位置，看back()。

3.2 底层容器是什么？为什么不是单链表

Queue默认底层同样是deque。但如果你深究一步会发现，deque比list和vector更适合做队列：

• vector在头部删除元素是O(n)的，必须把所有元素往前搬移，根本不适合做FIFO队列
• list虽然头部插入删除是O(1)，但每个节点需要额外存储前后指针，内存开销大、缓存性能差
• deque采用分块连续存储结构，头部和尾部操作都是O(1)，且访问元素时缓存局部性优于list

一个底层机制的小知识：deque的逻辑结构是连续地址空间的分段映射，它维护一个中控器（map）来管理各个缓冲区块。当队头元素出队时，deque只移动头部指针到下一个位置，不搬移已有元素。这也是为什么Queue用deque作为默认底层容器非常合适。

3.3 Queue的遍历陷阱和清空方式

和Stack一样，Queue也不提供迭代器。更关键的是，Queue连可以"看一眼队头但不删除"的top()都没有，只有front()。你想遍历一个Queue的所有元素，标准做法就是不断出队：

cpp复制std::queue<int> q;
q.push(1);
q.push(2);
q.push(3);

while (!q.empty()) {
    std::cout << q.front() << " ";
    q.pop();
}
// 输出: 1 2 3

清空Queue没有clear()方法，常见做法是用一个空的队列对象去swap：

cpp复制std::queue<int> q;
// ... 向q中push了很多数据
std::queue<int> empty;
q.swap(empty);

注意，Stack同样没有clear()，也是用swap的方式清空。

4. 单调栈：Stack在算法题中最有价值的实战形态

如果说Stack在日常开发里只是一个普通工具，那么在算法领域，单调栈几乎是把Stack价值榨干的一种设计思路。热搜词里"单调栈算法c++"经常出现，面试题也爱考，所以我单独用一整节来拆解它。

4.1 单调栈到底是干什么的

先看一个非常经典的问题——下一个更大元素：

给定数组[2, 1, 4, 3, 8]，求每个元素右边第一个比它大的元素。

暴力做法很简单：两层循环，对每个元素向后扫描。时间复杂度O(n²)。但如果数组有10万个元素，这个复杂度就要命了。

单调栈的思路是：维护一个栈内元素单调递减的栈（从栈底到栈顶依次递减），遍历数组元素时：

• 如果当前元素小于等于栈顶元素，直接入栈
• 如果当前元素大于栈顶元素，说明当前元素就是栈顶元素右边第一个比它大的数，可以反复弹出栈顶并记录答案

cpp复制#include <iostream>
#include <vector>
#include <stack>

std::vector<int> nextGreaterElement(const std::vector<int>& nums) {
    int n = nums.size();
    std::vector<int> result(n, -1);
    std::stack<int> st; // 栈中存下标
    
    for (int i = 0; i < n; ++i) {
        while (!st.empty() && nums[i] > nums[st.top()]) {
            result[st.top()] = nums[i];  // nums[i] 是栈顶元素右边第一个更大的
            st.pop();
        }
        st.push(i);
    }
    return result;
}

int main() {
    std::vector<int> nums = {2, 1, 4, 3, 8};
    auto res = nextGreaterElement(nums);
    for (int x : res) {
        std::cout << x << " "; // 输出: 4 4 8 8 -1
    }
    return 0;
}

关键点：栈里存的是下标而不是元素值。为什么要存下标？因为结果数组需要按下标填入，而且比较元素大小时可以通过下标访问原数组。很多初学者存值，结果后来发现需要知道位置信息，又得回去改。

4.2 单调栈的时间复杂度为什么是O(n)

可能有人会疑惑：代码里明明是for循环套着while循环，怎么就不是O(n²)呢？

关键在于：每个元素最多入栈一次、出栈一次。while循环里弹出的每个元素，都是之前入过栈的。所以总弹出次数不超过总入栈次数，整体是O(n)。这个"每个元素只会被处理常数次"的观察，是单调栈效率的本质来源。

4.3 单调栈的模板可以套到很多题

下一个更大元素、每日温度、接雨水、柱状图中最大的矩形，本质都是同一套模板的不同变体。这里给一个通用模板：

cpp复制for (int i = 0; i < n; ++i) {
    while (!st.empty() && 破坏单调性的条件(nums[i], nums[st.top()])) {
        // 此时 nums[i] 对栈顶元素有特殊意义
        st.pop();
    }
    st.push(i);
}

核心是你需要想清楚：何时弹出栈顶、弹出时栈顶的答案是什么。一旦想明白这个问题，代码几乎就是照抄模板。

5. Queue的经典应用：BFS搜索与消息队列场景

5.1 树的层序遍历：BFS的天然数据结构

队列最常见的算法应用是广度优先搜索（BFS）。为什么BFS必须用队列？因为BFS要求"先发现的节点先扩展"——这正好是FIFO的语义。如果换成Stack（DFS），那就会变成"后发现的节点先扩展"。

一个典型的二叉树层序遍历：

cpp复制#include <iostream>
#include <queue>
#include <vector>

struct TreeNode {
    int val;
    TreeNode* left;
    TreeNode* right;
    TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
};

std::vector<std::vector<int>> levelOrder(TreeNode* root) {
    std::vector<std::vector<int>> result;
    if (root == nullptr) return result;
    
    std::queue<TreeNode*> q;
    q.push(root);
    
    while (!q.empty()) {
        int levelSize = q.size();
        std::vector<int> level;
        
        for (int i = 0; i < levelSize; ++i) {
            TreeNode* node = q.front();
            q.pop();
            level.push_back(node->val);
            
            if (node->left) q.push(node->left);
            if (node->right) q.push(node->right);
        }
        result.push_back(level);
    }
    return result;
}

这里有个小细节值得注意：在while循环里，我提前用int levelSize = q.size()记录了当前层的节点数。如果不这么做，而是直接在for循环里判断i < q.size()，那么随着子节点不断入队，q.size()会变化，当前层的节点数就错乱了。这个细节在BFS写层序遍历时非常容易踩坑。

5.2 生产者和消费者模型：Queue在工程中的典型角色

不管是在线程池、消息中间件还是异步任务调度里，Queue都是核心的数据结构。但这里必须强调一个重要事实：std::queue不是线程安全的。

多线程环境下，如果两个线程同时调用push()或者一个push()一个pop()，会产生数据竞争，导致未定义行为。你需要加锁或者使用线程安全队列。

一个最基础的生产者消费者示例：

cpp复制#include <iostream>
#include <queue>
#include <thread>
#include <mutex>
#include <condition_variable>

std::queue<int> tasks;
std::mutex mtx;
std::condition_variable cv;

void producer(int id) {
    for (int i = 0; i < 5; ++i) {
        {
            std::lock_guard<std::mutex> lock(mtx);
            tasks.push(id * 100 + i);
            std::cout << "生产者" << id << " 生产了 " << tasks.back() << std::endl;
        }
        cv.notify_one();
        std::this_thread::sleep_for(std::chrono::milliseconds(50));
    }
}

void consumer(int id) {
    while (true) {
        std::unique_lock<std::mutex> lock(mtx);
        cv.wait(lock, []{ return !tasks.empty(); });
        
        int task = tasks.front();
        tasks.pop();
        lock.unlock();
        
        if (task == -1) break;  // 终止信号
        std::cout << "消费者" << id << " 处理了 " << task << std::endl;
        std::this_thread::sleep_for(std::chrono::milliseconds(100));
    }
}

这个例子里的三个关键点是：

• cv.wait必须配合unique_lock，因为wait内部需要临时解锁让其他线程进入临界区
• cv.wait的第二个参数是谓词，用来防止假唤醒（spurious wakeup）
• 锁的粒度要尽量小，不要在锁内做耗时操作

如果你在面试中能把这个简单的生产者消费者模型讲清楚，说明你对多线程同步的理解已经超过大多数候选人了。

5.3 双端队列deque：Stack和Queue的"合体进阶"

最后提一个常被忽略但很实用的容器：std::deque。它同时支持在头部和尾部进行O(1)的插入删除，相当于Stack和Queue的能力合体版。

cpp复制std::deque<int> dq;
dq.push_back(1);    // 尾部入
dq.push_front(2);   // 头部入
int back_val = dq.back();   // 1
int front_val = dq.front(); // 2
dq.pop_back();
dq.pop_front();

双端队列在算法里最常见的应用是单调队列，典型题目如"滑动窗口最大值"。这类题目要求维护一个窗口内的最大值，且窗口在向右滑动。普通实现每次重新扫描窗口，复杂度O(nk)；单调队列通过维护一个递减的双端队列，可以做到整体O(n)。

6. 从LeetCode到竞赛：五道层层递进的实战习题

6.1 题一：有效括号匹配（入门）

给定一个只包含(, ), {, }, [, ]的字符串，判断括号是否有效。

思路：遇到左括号就入栈，遇到右括号就检查栈顶是否匹配。如果遍历结束后栈为空，则所有括号都匹配上了。

cpp复制#include <iostream>
#include <stack>
#include <unordered_map>

bool isValid(const std::string& s) {
    std::stack<char> st;
    std::unordered_map<char, char> pairs = {
        {')', '('},
        {']', '['},
        {'}', '{'}
    };
    
    for (char c : s) {
        if (c == '(' || c == '[' || c == '{') {
            st.push(c);
        } else {
            if (st.empty() || st.top() != pairs[c]) {
                return false;
            }
            st.pop();
        }
    }
    return st.empty();
}

这道题的价值在于：它训练了你对"匹配最近一个左括号"的直觉——而"最近一个"正好是Stack的语义。当你下意识觉得"这里需要保存历史信息，而且是最近的历史优先"时，就应该想到Stack。

6.2 题二：最小栈（经典）

设计一个支持push、pop、top操作，并能在常数时间内检索到最小元素的栈。

思路：使用两个栈，一个正常存数据，一个存当前栈内的最小值。入栈时，新元素和最小栈的栈顶比较，把较小者入最小栈。

cpp复制class MinStack {
private:
    std::stack<int> data;
    std::stack<int> minValues;
    
public:
    void push(int val) {
        data.push(val);
        if (minValues.empty() || val <= minValues.top()) {
            minValues.push(val);
        } else {
            minValues.push(minValues.top());
        }
    }
    
    void pop() {
        data.pop();
        minValues.pop();
    }
    
    int top() const {
        return data.top();
    }
    
    int getMin() const {
        return minValues.top();
    }
};

关键点在于push时val <= minValues.top()用的是小于等于而不是小于。如果只用小于，当有多个相同最小值时，pop掉一个最小值后最小栈就会丢失这个值。这个细节在面试中经常被考察。

6.3 题三：用队列实现栈（换一种结构重新思考）

这道题反过来考你：只用队列的push、pop、front操作实现一个栈的push、pop、top。

思路：每次push直接把元素放到队尾，然后旋转队列，使得新元素到达队头。

cpp复制#include <queue>

class StackWithQueue {
private:
    std::queue<int> q;
    
public:
    void push(int x) {
        q.push(x);
        for (int i = 0; i < q.size() - 1; ++i) {
            q.push(q.front());
            q.pop();
        }
    }
    
    void pop() {
        q.pop();
    }
    
    int top() {
        return q.front();
    }
    
    bool empty() {
        return q.empty();
    }
};

这类题的训练价值不在于实际工程中会这么用（不会），而在于帮你理解Stack和Queue在数据结构形态上的本质区别，以及如何通过"操作组合"来转换数据结构的行为。

6.4 题四：滑动窗口最大值（单调队列进阶）

给定数组nums和窗口大小k，窗口每次向右滑动一位，返回每个窗口的最大值。

这道题是BFS层序遍历之外的另一个Queue实战高频题。但它用的是deque，而不是queue。核心思路：维护一个双端队列，队列里的元素值单调递减，队头永远是当前窗口最大值。

cpp复制#include <iostream>
#include <vector>
#include <deque>

std::vector<int> maxSlidingWindow(const std::vector<int>& nums, int k) {
    std::vector<int> result;
    std::deque<int> dq;  // 存下标，队头是当前窗口最大值的下标
    
    for (int i = 0; i < nums.size(); ++i) {
        // 移除窗口外的元素
        while (!dq.empty() && dq.front() <= i - k) {
            dq.pop_front();
        }
        // 从队尾移除所有小于当前元素的
        while (!dq.empty() && nums[dq.back()] < nums[i]) {
            dq.pop_back();
        }
        dq.push_back(i);
        // 从窗口形成后开始记录结果
        if (i >= k - 1) {
            result.push_back(nums[dq.front()]);
        }
    }
    return result;
}

两个while循环各自负责一件事：第一个保证队头元素还在窗口内，第二个保证队列的单调递减性。理解这两条规则后，这类题基本就是默写。

6.5 题五：柱状图中最大的矩形（单调栈应用）

给定n个非负整数表示柱状图中各柱子的高度，每个柱子宽度为1，求该柱状图中能勾勒出的最大矩形面积。

这是一道经典的单调栈压轴题，也是"下一个更大元素"模板的变体。核心思路：对每个柱子，找到它左右两边第一个比它矮的柱子，那么以该柱子高度为高的最大矩形宽度就确定了。

cpp复制int largestRectangleArea(const std::vector<int>& heights) {
    std::stack<int> st;
    int maxArea = 0;
    int n = heights.size();
    
    for (int i = 0; i <= n; ++i) {
        int currentHeight = (i == n) ? 0 : heights[i];
        while (!st.empty() && heights[st.top()] >= currentHeight) {
            int height = heights[st.top()];
            st.pop();
            int width = st.empty() ? i : i - st.top() - 1;
            maxArea = std::max(maxArea, height * width);
        }
        st.push(i);
    }
    return maxArea;
}

这里的i == n时把高度设为0，是为了在遍历结束后强制把所有栈内元素弹出并计算面积。这是模板题里很常见的一种收尾技巧。

7. Stack与Queue调试中常见的五个"隐蔽坑"

7.1 空容器上调用front/back/top不一定会立刻崩溃

我在实际项目中遇到过一种情况：队列在某个瞬间变空了，但代码逻辑上认为它不可能空。q.front()返回了一个随机地址上的"垃圾对象"，程序没崩，还拿这个垃圾值继续跑了很久，最终在一个完全不相干的地方报错，排查起来非常痛苦。

正确习惯是：所有front()、back()、top()调用前都加上判空检查。不要相信"这里逻辑上不可能空"这种话——输入数据的奇偶性、并发线程的调度顺序，都可能打破你的逻辑假设。

7.2 误用swap后迭代器失效

std::stack和std::queue的swap方法是O(1)的，但交换后底层容器也交换了。如果你在交换前保存了某个元素的引用或指针，交换后它们仍然指向旧容器中的数据。这本身不难理解，但有时候代码写多了就容易忽略。尤其在做算法题时，如果你在循环里使用了auto& ref = st.top()然后又对栈做了push操作，这个引用可能就失效了——因为deque在扩容时可能重新分配内存块。

经验法则：持有容器内部元素的引用时，不要动态修改容器结构。如果需要保留元素的值，拷贝一份；如果只需要索引，直接保存下标。

7.3 Stack和Queue的size()返回类型是size_t而不是int

一个小坑但很常见：std::stack<int>::size_type是无符号整数类型。如果你写：

cpp复制for (int i = 0; i < st.size(); ++i) {
    // do something
}

编译器会提示有符号/无符号比较警告。更危险的是，如果st.size()返回0，而i是int类型并且之前被减到了-1，这个循环可能会变成死循环或者执行出乎意料的次数。写代码时尽量统一用size_t来接收size()的返回值。

7.4 在容器适配器上使用auto遍历会编译失败

Stack和Queue不提供迭代器，所以for (auto x : st)这种写法是编译不过的。如果你真的需要遍历栈里的每个元素：

cpp复制std::stack<int> temp;
while (!st.empty()) {
    int value = st.top();
    st.pop();
    // 处理value
    temp.push(value);
}
// 最后把temp倒回st
while (!temp.empty()) {
    st.push(temp.top());
    temp.pop();
}

这个方法的时间复杂度O(n)、空间复杂度O(n)，遍历的同时破坏了原栈顺序，最后又恢复了。虽然效率不太高，但胜在安全清晰。

7.5 用sizeof去测容器大小是行不通的

有初学者会写sizeof(std::stack<int>)来"计算栈里有多少字节"，这完全不对。sizeof返回的是栈对象本身（即适配器对象加底层容器对象）所占的字节数，和栈里实际存储的数据量没有任何关系。如果你需要查看栈内存占用，正确做法是遍历一遍累加元素大小，或者使用st.size() * sizeof(T)来估算。

8. 把Stack和Queue用好的底层思维

写到这里，基础操作、经典场景和实战习题都覆盖到了。最后我想从更大的视角聊一下：为什么很多人学了Stack和Queue，做算法题时还是想不到用它们？

以我自己的经验看，关键在于你是否建立了"数据结构即视角"的思维模型。看到题目里"最近""回溯""撤销""递归改迭�代"这些词，第一反应是Stack；看到"层次""分批""先后顺序""公平调度"这些词，第一反应是Queue。一旦形成这种条件反射，你解算法题的速度会明显提升，看开源代码时也会更有感觉。

还有一个练习方法建议给初学者：下次刷题时，先别看标签，自己拿一道题来分析"这个问题处理的数据具有什么顺序特征"。如果数据像"一摞盘子"，优先想Stack；如果像"一条排队通道"，优先想Queue。这个分类训练做上十几道题，你会发现Stack和Queue再也不是需要刻意去记的工具，而变成了一种很自然的思考方式。

如果你想进一步深入，可以继续看看deque、优先队列（std::priority_queue）以及C++11之后新增的std::stack和std::queue在移动语义下的表现。容器适配器本身不复杂，但把它们的边界行为摸清楚、把"什么时候该用、什么时候不该用"想透，你才算真正把这些基础容器内化成了自己的武器。