C++ 中的栈（Stack）数据结构与堆的区别与内存布局（Stack vs Heap）
一、栈的基本概念
1. 定义
栈（Stack） 是一种 后进先出（LIFO, Last-In-First-Out） 的线性数据结构。
就像一摞盘子，后放的盘子在最上面，最先被取出。
二、C++ 中的栈实现方式
C++ 中主要有两种方式实现栈：
1. STL 容器适配器 std::stack
#include <stack>
std::stack<int> s;
这是标准库中最常用的实现。
2. 自定义数组或链表实现
可以自己用 vector 或 linked list 实现栈逻辑，常见于算法题或底层系统开发。
三、STL std::stack 概述
1. 定义
std::stack 是一个容器适配器 (container adapter)，它在内部使用其他容器（如 deque, vector, list）来存储元素。
2. 默认实现
template <class T, class Container = std::deque<T>>
class stack;
即默认底层容器是 std::deque<T>。
3. 特性
- 后进先出（LIFO）
- 不支持随机访问
- 只暴露 栈顶操作接口
四、常用成员函数详解
| 成员函数 | 功能 | 示例 |
|---|---|---|
push() | 入栈 | s.push(10); |
pop() | 出栈（删除栈顶元素） | s.pop(); |
top() | 访问栈顶元素 | int x = s.top(); |
empty() | 判断是否为空 | if (s.empty()) |
size() | 返回元素个数 | s.size(); |
emplace() | 原地构造并入栈 | s.emplace(3, 4); |
swap() | 交换两个栈的内容 | s1.swap(s2); |
五、示例代码
#include <iostream>
#include <stack>
using namespace std;int main() {stack<int> s;// 入栈s.push(10);s.push(20);s.push(30);cout << "Stack top: " << s.top() << endl; // 输出 30// 出栈s.pop();cout << "After pop, top: " << s.top() << endl; // 输出 20cout << "Stack size: " << s.size() << endl;// 清空while (!s.empty()) {cout << "Popped: " << s.top() << endl;s.pop();}
}
输出：
Stack top: 30
After pop, top: 20
Stack size: 2
Popped: 20
Popped: 10
六、底层原理分析
1. 适配器模式
std::stack 并不是一个独立的数据结构，而是对底层容器的封装：
template<class T, class Container = deque<T>>
class stack {
protected:Container c;
public:bool empty() const { return c.empty(); }size_t size() const { return c.size(); }T& top() { return c.back(); }void push(const T& value) { c.push_back(value); }void pop() { c.pop_back(); }
};
2. 底层容器类型选择
| 容器类型 | 优点 | 缺点 |
|---|---|---|
deque | 双端操作高效（默认） | 占用稍多内存 |
vector | 连续内存、快速访问 | 出栈扩容代价较高 |
list | 插入删除快 | 内存碎片多、访问慢 |
七、内存与性能分析
| 操作 | 时间复杂度 | 说明 |
|---|---|---|
push | O(1)* | 平均常数时间（vector 可能扩容） |
pop | O(1) | 删除尾部元素 |
top | O(1) | 直接访问尾部 |
empty / size | O(1) | 成员变量直接返回 |
八、应用场景
-
表达式求值
- 中缀转后缀、逆波兰表达式计算
-
括号匹配
- 判断括号是否成对出现
-
函数调用栈
- 系统内部维护函数调用与返回
-
回溯算法
- DFS 深度优先搜索
-
撤销（Undo）/恢复（Redo）操作
九、自定义栈实现
使用数组实现：
#include <iostream>
using namespace std;template<typename T, size_t N>
class Stack {T data[N];int topIndex = -1;public:void push(const T& value) {if (topIndex >= N - 1) throw overflow_error("Stack overflow");data[++topIndex] = value;}void pop() {if (topIndex < 0) throw underflow_error("Stack underflow");--topIndex;}T top() const {if (topIndex < 0) throw underflow_error("Empty stack");return data[topIndex];}bool empty() const { return topIndex < 0; }size_t size() const { return topIndex + 1; }
};
十、系统层面理解：调用栈（Call Stack）
除了 STL 数据结构，栈还是系统内存的一部分。
| 类型 | 区域 | 功能 |
|---|---|---|
| 栈区 (Stack) | 由编译器自动分配 | 存储局部变量、函数参数、返回地址 |
| 堆区 (Heap) | 由程序员手动分配 | 存储动态对象（new / malloc） |
函数调用时，系统自动使用**调用栈（call stack）**来保存返回地址和局部变量。
十一、堆栈的区别与内存布局（Stack vs Heap）
1、基本概念
| 名称 | 中文 | 作用 | 分配方式 |
|---|---|---|---|
| Stack | 栈 | 管理函数调用、局部变量、返回地址等 | 由系统自动分配 / 释放 |
| Heap | 堆 | 动态内存存储，由程序员控制 | 由程序员手动分配 / 释放（new/delete 或 malloc/free） |
2、从内存布局看区别
以典型的 C/C++ 程序在 Linux 内存布局为例（自低地址到高地址）：
+---------------------------+ 高地址
| 栈 Stack | 函数调用栈、局部变量
| ↓（向下增长） |
+---------------------------+
| 堆 Heap | new / malloc 动态分配（向上增长）
+---------------------------+
| BSS 段 | 未初始化的全局/静态变量
+---------------------------+
| 数据段 Data | 已初始化的全局/静态变量
+---------------------------+
| 代码段 Text | 程序指令、常量
+---------------------------+低地址
特点：
- 栈向下增长（地址递减）
- 堆向上增长（地址递增）
- 二者中间的空间为系统保留的内存或动态共享库区
3、分配与释放机制
| 比较项 | 栈 Stack | 堆 Heap |
|---|---|---|
| 分配方式 | 编译器自动分配 | 程序员手动分配 |
| 释放方式 | 离开作用域自动释放 | 需要显式释放（delete/free） |
| 分配时间 | 编译期或运行时由编译器管理 | 运行时动态分配 |
| 分配效率 | 快（简单移动栈顶指针） | 慢（涉及操作系统堆管理） |
| 内存碎片 | 不会产生碎片 | 易产生碎片 |
| 空间大小 | 一般较小（几 MB） | 受系统总内存限制（可达 GB） |
| 异常风险 | 栈溢出（Stack Overflow） | 内存泄漏（Memory Leak） |
| 典型使用 | 局部变量、函数参数 | 动态数组、对象、容器（如 vector） |
4、实例分析
栈分配示例：
void func() {int a = 10; // 分配在栈上double b = 3.14;
}
函数调用时，编译器为 a 和 b 分配栈空间；
函数返回时，这部分内存自动释放。
堆分配示例：
void func() {int* p = new int(10); // 分配在堆上delete p; // 手动释放
}
new调用堆管理器（malloc 系统调用）分配空间delete调用堆释放函数（free）- 如果忘记
delete，就会造成 内存泄漏
5、内存使用示意图
#include <iostream>
using namespace std;int g = 0; // 全局变量 → 数据段int main() {int a = 1; // 栈变量int* p = new int(2); // 堆变量static int s = 3; // 静态变量 → 数据段cout << "stack a: " << &a << endl;cout << "heap p: " << p << endl;cout << "static s: " << &s << endl;cout << "global g: " << &g << endl;delete p;
}
输出示例（地址大致关系）：
stack a: 0x7ffeeff8
heap p: 0x600010
static s: 0x60104c
global g: 0x601040
可见：
- 栈区地址较高
- 堆区地址较低
- 全局/静态变量在固定的 Data 段
- 程序代码在 Text 段中
6、性能与风险比较
| 特性 | 栈 Stack | 堆 Heap |
|---|---|---|
| 性能 | 快，连续内存，一次性分配 | 慢，需查找空闲块、更新堆结构 |
| 安全性 | 自动释放，易管理 | 容易泄漏、悬垂指针 |
| 可变性 | 空间有限 | 可动态扩展 |
| 典型错误 | Stack Overflow | Memory Leak / Use-after-free |
7、C++ 中的内存管理建议
-
优先使用栈对象
-
自动管理生命周期，不会泄漏。
-
如：
std::string s = "hello"; // 栈上管理，内部堆分配自动释放
-
-
动态分配时使用智能指针
- 避免手动
delete。
#include <memory> auto p = std::make_shared<int>(42); - 避免手动
-
不要返回局部变量地址
int* foo() {int x = 10;return &x; // 栈变量函数返回后已销毁 } -
避免频繁分配/释放堆内存
- 建议使用内存池（memory pool）或对象池优化。
8、栈溢出与堆溢出
栈溢出 (Stack Overflow)
原因：函数递归过深或局部数组太大。
void recurse() { recurse(); } // 无限递归 → Stack Overflow
堆溢出 (Heap Overflow)
原因：动态内存越界写入。
int* p = new int[2];
p[5] = 10; // 越界写入 → Heap Corruption
9、程序运行生命周期内存演化图
程序加载时：┌──────────────────────┐│ 代码段（text） │ ← 程序指令│ 数据段（data + bss） │ ← 全局/静态变量│ 堆（heap） │ ← new/malloc 动态分配│ ...（空闲空间）... ││ 栈（stack） │ ← 函数调用栈帧└──────────────────────┘
- 程序执行时，栈不断增长/收缩；
- 堆在运行中动态申请/释放；
- 数据段和代码段在整个程序生命周期中固定存在。
10、总结对比表
| 特征 | 栈 (Stack) | 堆 (Heap) |
|---|---|---|
| 分配方式 | 系统自动 | 程序员控制 |
| 生命周期 | 函数结束自动释放 | 必须手动释放 |
| 地址增长方向 | 向下（高→低） | 向上（低→高） |
| 管理开销 | 小 | 大 |
| 空间大小 | 较小（默认几 MB） | 较大（受内存限制） |
| 容易出错类型 | 栈溢出 | 内存泄漏、野指针 |
| 推荐用法 | 局部变量、临时对象 | 大对象、动态容器、跨函数数据 |
“栈快且短，堆大但慢；栈自动管，堆需自担。”