镝不咸最近在帮几个学弟学妹看数据结构实验报告的时候，发现十个里有七八个写顺序栈的同学，代码都能跑，但一问到“为什么这么设计”“析构函数能不能不写”“扩容时元素怎么搬”就答不上来。这其实挺可惜的——顺序栈是数据结构里最经典的入门ADT（抽象数据类型）之一，也是面试和笔试的高频基础题，如果只是照着教材敲一遍，收获会大打折扣。这篇博文我会用C++的类机制，从零到一实现一个完整的顺序栈核心ADT，把每一处设计决策背后的原因讲明白，同时把实验报告里容易丢分、考试里容易踩坑的点一并梳理出来。无论你是正在学数据结构的学生，还是想补一补C++面向对象基础的自学者，这篇内容都能直接照着写、照着用。
1. 整体设计思路与前置思考
1.1 为什么用C++类来封装，而不是直接写一堆函数
很多教材在讲栈的时候，用的是C语言版的结构体加全局函数，比如定义 struct Stack，再写 InitStack、Push、Pop、GetTop 这一套操作函数。这种方式能跑，但有个问题：数据和操作是分离的，数据结构和它配套的方法之间没有强绑定关系，一旦工程变大，很容易出现“谁都能改栈内部数据”的失控局面。
用C++类来封装，本质上是把“数据结构”真正提升为“抽象数据类型”。栈的用户只需要知道 push 和 pop 的语义，而不需要关心底层是用数组还是链表实现的。这正好对应了ADT的两层含义：数据对象的逻辑结构和定义在其上的一组操作，而类的私有成员正是逻辑结构的载体，公有接口正是操作的对外入口。课堂上老师强调的“封装、继承、多态”，在这里最直观的体现就是封装——把数组指针、栈顶指针、容量这些内部状态锁在 private 里，外部只能通过接口访问。
此外，从实际工程的角度看，C++类带来的最直接好处是自动初始化和自动清理。构造函数在对象创建时自动完成栈的初始化，析构函数在对象生命周期结束时自动释放堆内存。这一点在C语言里需要手动调用 InitStack 和 DestroyStack，漏一次就内存泄漏。类机制把这些变成了编译器强制执行的流程，对新手来说能减少一类非常隐蔽的内存错误。
1.2 顺序栈方案选型：数组底座的取舍与适用场景
栈作为一种“后进先出”的线性结构，底层存储方案无非两种：顺序存储（数组）和链式存储（链表）。这版我们用顺序结构，也就是用一段连续的内存单元存放栈元素，搭配一个栈顶指针（或者栈顶下标）。
选择顺序栈而不是链栈，核心原因在于性能和实现复杂度之间的平衡。数组的随机访问是O(1)，虽然栈只在栈顶操作，这个优势不像在队列里那么明显，但由于底层的cache局部性好，实际运行效率依然很能打。更重要的是，顺序栈的实现逻辑非常直观：一个一维数组、一个记录栈顶位置的整数、一套操作规则，几乎没有指针操作的复杂度，对新手建立“数据结构到底是什么”的认知非常有帮助。
顺序栈也有明显的短板，就是容量受限。静态数组在编译期就得定死大小，要么浪费空间要么不够用。这个问题的解法我们在文后会详细讲——动态扩容。在操作系统、编译器、浏览器这类底层场景里，栈空间通常是固定大小的；而在应用层写算法题、做表达式求值、括号匹配这类任务时，动态扩容的顺序栈几乎是默认选择。
1.3 内存布局的核心：栈顶指针的两种设计流派
顺序栈的实现细节里，最值得琢磨的一处是栈顶指针的含义。目前主流教材里有两种约定：
第一种是栈顶指针指向栈顶元素本身，初始时 top = -1，入栈时先 top++ 再赋值，出栈时先取元素再 top--。这种写法下，栈空条件为 top == -1，栈满条件为 top == capacity - 1。
第二种是栈顶指针指向栈顶元素的下一个位置，初始时 top = 0，入栈时先赋值再 top++，出栈时先 top-- 再取元素。这种写法下，栈空条件为 top == 0，栈满条件为 top == capacity。
两种流派各有拥趸，严蔚敏老师的教材和考研统考用的都是第一种。我个人推荐你用第一种 top = -1 的写法，因为它更符合人类直觉——“栈顶在哪，指针就指向哪”，调试时打印 top 一眼就能看出栈里存了几个元素。后面所有代码都按这个约定来写。
需要模型API调用？ 免费领10W Token，多模型网关一键接入 Claude、DeepSeek 等主流模型。
2. 核心类设计与关键成员解析
2.1 类模板与普通类：写死int还是泛型化
很多入门题目给的示例代码都是写死 int 类型，栈里只能存整数。但实际使用中，我们可能要用栈保存字符（比如括号匹配）、保存自定义结构体（比如迷宫求解的坐标点）、甚至保存其他容器对象。如果每换一种元素类型都复制粘贴一份代码，那就是灾难。
解决办法是用C++的类模板。类模板允许我们把元素类型作为参数传入，编译时期由编译器根据实际使用自动生成对应的具体类。定义方式是在类声明前加一行：
cpp复制template <typename T>
class SeqStack { ... };
使用的时候 SeqStack<int>、SeqStack<char> 就分别实例化出存整数和存字符的栈。模板的成本在于编译时间变长和代码可读性略微下降，但这在通用性面前完全可以接受。
如果只是想快速交作业、跑通实验，直接写死 int 也不是不行。但我还是建议至少把模板写上，因为这是实验报告里一个很好的“加分亮点”，说明你考虑到了代码复用和泛型化的工程思想。
2.2 成员变量设计：三个私有字段缺一不可
一个规范的自定义ADT顺序栈，核心私有成员只有三个：
T* data：指向堆区动态数组的指针，真正存储元素的内存区域。int top：栈顶下标，初始为-1，表示空栈。这个约定贯穿所有操作。int capacity：当前栈的最大容量，即数组总长度。
为什么动态数组要放在堆上而不是直接用定长数组？原因很简单：定长数组在栈上分配，大小编译期就得确定，无法实现动态扩容；堆上分配则可以借助 new [] 和 delete [] 在运行时灵活调整。当然，堆分配也有代价——需要手动管理内存生命周期，这正是构造函数和析构函数要承担的职责。
有些教材会再加一个 int size 表示栈内元素个数，但有了 top 其实没必要，size = top + 1 恒成立，多一个变量反而要在每个操作里维护同步，增加出错概率。保持成员最小化是类设计的一个重要原则。
2.3 构造函数与析构函数：谁分配，谁释放
构造函数负责初始化对象状态。我在实现中提供两种构造方式：默认构造函数使用一个合理的初始容量（比如16），带参构造函数让用户自定义初始容量。初始容量太小会导致频繁扩容，太大则浪费内存。16是个经验值，比较适合大多数入门场景。
析构函数负责回收堆内存，核心只有一行：
cpp复制~SeqStack() {
delete[] data;
}
很多新手会漏写析构函数，这时候如果栈对象是局部变量，一旦函数结束，data 指针指向的堆内存不会被自动释放，形成内存泄漏。虽然现代操作系统在进程退出时会回收全部内存，让这种泄漏看起来“没什么影响”，但在长期运行的服务器程序里，一次请求泄漏一点，积少成多就会把内存吃光。
3. 完整实现与代码逐段细读
3.1 开栈第一步：完整代码展示
下面给出一个带动态扩容、异常安全、满足现代C++规范的整体实现。这个版本比纯教学版多了一些工程化考虑，但每行都有实际用途，我会在后续小节逐一细读。
cpp复制#include <iostream>
#include <stdexcept>
template <typename T>
class SeqStack {
private:
T* data;
int top;
int capacity;
void resize() {
int newCapacity = capacity * 2;
T* newData = new T[newCapacity];
for (int i = 0; i <= top; ++i) {
newData[i] = data[i];
}
delete[] data;
data = newData;
capacity = newCapacity;
}
public:
explicit SeqStack(int initCapacity = 16)
: data(new T[initCapacity]), top(-1), capacity(initCapacity) {}
~SeqStack() {
delete[] data;
}
SeqStack(const SeqStack& other)
: data(new T[other.capacity]), top(other.top), capacity(other.capacity) {
for (int i = 0; i <= top; ++i) {
data[i] = other.data[i];
}
}
SeqStack& operator=(const SeqStack& other) {
if (this != &other) {
T* newData = new T[other.capacity];
for (int i = 0; i <= other.top; ++i) {
newData[i] = other.data[i];
}
delete[] data;
data = newData;
top = other.top;
capacity = other.capacity;
}
return *this;
}
void push(const T& value) {
if (top + 1 == capacity) {
resize();
}
data[++top] = value;
}
void pop() {
if (empty()) {
throw std::underflow_error("Stack underflow: pop from empty stack");
}
--top;
}
T& topValue() {
if (empty()) {
throw std::runtime_error("Stack is empty: no top element");
}
return data[top];
}
const T& topValue() const {
if (empty()) {
throw std::runtime_error("Stack is empty: no top element");
}
return data[top];
}
bool empty() const {
return top == -1;
}
int size() const {
return top + 1;
}
int getCapacity() const {
return capacity;
}
};
3.2 入栈出栈的细节：为什么先判满，再自增赋值
入栈操作 push 的核心就两行：
cpp复制if (top + 1 == capacity) {
resize();
}
data[++top] = value;
第一行判满的逻辑值得细说。因为初始 top = -1，所以栈满时的条件是 top == capacity - 1，写成 top + 1 == capacity 更直观，它的意思是“下一个要放的位置已经越界了”。这里没有用 >=，因为正常流程下 top 不可能超过 capacity - 1，一旦出现这种情况说明程序已经有bug，用 == 可以让问题更早暴露。
data[++top] = value 是经典的前置自增写法。它等价于两步：先把 top 加1，再把元素放入新位置。注意这里不能用 data[top++] = value，那样会先把元素放在旧栈顶位置，再把 top 加1，相当于栈顶始终被覆盖，逻辑完全错误。这个先后顺序是新手最容易写错的地方，也是考试中很喜欢挖坑的点。
出栈操作 pop 我刻意没有返回被弹出的元素，这点和教材略有不同。原因是C++标准库的 std::stack::pop 就是这样的语义——出栈和取栈顶分成两个操作，因为返回元素值往往伴随着一次不必要的拷贝，而且在元素类型是复杂对象时，返回值和弹出同时进行还容易引发异常安全问题。如果你确实需要拿到被弹的元素，先用 topValue() 取出，再 pop() 即可。
3.3 扩容机制：两倍扩容与元素搬移的代价
resize 是让顺序栈从“固定容量”进化为“可伸缩容量”的关键函数。当栈满时，我们申请一块是原来两倍大小的新数组，把旧元素逐一拷贝过去，然后释放旧内存。这个策略被称为倍增扩容。
为什么是两倍而不是“加固定大小”？这背后有一个摊还分析的思想。如果每次只多开一个元素的空间，那么连续插入n个元素的总体复杂度是O(n²)——因为每次插入都可能触发一次O(n)的搬移。而采用两倍扩容，虽然单次扩容的搬移成本还是O(n)，但n次插入里扩容次数只有log n次，摊还到每次插入，平均代价是O(1)。用大白话说：两倍扩容让“昂贵”的扩容操作发生得足够少，少到平摊下来几乎可以忽略。实际工程中，std::vector 也是采用类似的倍增策略。
搬移元素时，要注意从旧数组头到尾顺序拷贝，因为新旧数组在内存里是独立的，不会互相覆盖。如果你复用同一个数组做原地扩容，那就要考虑从尾部倒序拷贝，但那是另一个话题（比如数组双端队列的rehash），不在顺序栈的讨论范围内。
3.4 拷贝构造与赋值运算符：编译器的默认版是个坑
我在这版代码里额外实现了拷贝构造函数和拷贝赋值运算符，这可能超出了一些入门教材的范围，但从C++工程实践角度讲，这是必须的。
原因在于“浅拷贝”问题。如果类里有原始指针成员 data，编译器默认生成的拷贝构造函数会直接把 other.data 的地址复制给新对象，结果两个栈指向同一块堆内存。析构时，其中一个对象把内存释放了，另一个的 data 就变成悬空指针，后续任何操作都是未定义行为。这就是著名的“双重释放”（double free）问题。
深拷贝的实现思路也很清晰：新开一块等容量内存，逐个元素复制，最后让新对象的 top 和 capacity 等于原对象的。赋值运算符还多了一个自赋值判断 this != &other，以及先申请新内存再释放旧内存的顺序——后者保证了如果内存分配失败抛出异常，原对象的数据还是完好无损的。这个写法虽然比“先delete再new”多几行，但异常安全性好得多。
3.5 异常处理：栈空时到底该干什么
我在 pop 和 topValue 里都加入了栈空判断，并抛出标准异常。有些教材或者OJ代码会在栈空时直接 exit(0) 或者打印一句话，这在学习阶段能接受，但工程上是不可取的。
抛出异常的意义在于把错误信息传递给调用者，而不是让程序静默终止。比如你写一个表达式求值器，输入了一个非法表达式导致栈空却还执行 pop，如果程序直接退出，用户根本不知道发生了什么；而抛出异常后，上层可以捕获并给出“表达式错误”的友好提示。
我选择了 <stdexcept> 里的 std::underflow_error 和 std::runtime_error。前者语义上更精确——数据结构的pop操作在空栈上执行，就是下溢（underflow）。当然在实际项目中，你也可以定义自己的业务异常类，但初学阶段用标准异常完全足够。
4. 测试用例与实验报告组织方法
4.1 主函数测试：边界条件一个都不能少
写完ADT，必须验证它的正确性。我给出一套可以直接复制的测试主函数，覆盖了顺序栈的全部关键路径：空栈判断、入栈、取栈顶、出栈、扩容、深拷贝。
cpp复制int main() {
SeqStack<int> stack;
std::cout << "初始状态：" << std::endl;
std::cout << "栈空？" << (stack.empty() ? "是" : "否") << std::endl;
std::cout << "栈大小：" << stack.size() << std::endl;
std::cout << "初始容量：" << stack.getCapacity() << std::endl;
for (int i = 1; i <= 20; ++i) {
stack.push(i * 10);
}
std::cout << "\n压入20个元素后：" << std::endl;
std::cout << "栈大小：" << stack.size() << std::endl;
std::cout << "栈顶元素：" << stack.topValue() << std::endl;
std::cout << "容量已扩充到：" << stack.getCapacity() << std::endl;
while (!stack.empty()) {
stack.pop();
}
std::cout << "\n全部出栈后：" << std::endl;
std::cout << "栈空？" << (stack.empty() ? "是" : "否") << std::endl;
try {
stack.pop();
} catch (const std::underflow_error& e) {
std::cout << "\n捕获异常：" << e.what() << std::endl;
}
SeqStack<int> copyStack(stack);
copyStack.push(100);
std::cout << "\n拷贝测试：" << std::endl;
std::cout << "原栈大小：" << stack.size()
<< "，拷贝栈大小：" << copyStack.size() << std::endl;
std::cout << "拷贝栈栈顶：" << copyStack.topValue() << std::endl;
return 0;
}
测试结果应当显示：初始空栈、压入20个元素后容量从16扩到32、出栈后栈空、对空栈pop抛出异常、深拷贝后两个栈互不影响。
4.2 实验报告写法：这几点是拿分关键
很多同学的数据结构实验报告就是简单贴代码加运行截图，这样拿不到高分。一份好的实验报告，至少要包含这几块内容：
- 需求分析：这段要回答“这个程序要解决什么问题”。不要把需求写成“实现一个栈”，而要写成“实现一个基于顺序存储结构的栈ADT，支持初始化、入栈、出栈、取栈顶、判空、扩容等基本操作，并提供友好的异常处理机制”。
- 概要设计：画出类的UML图或者结构示意图，说明每个成员变量和成员函数的作用，这部分考察的是抽象建模能力。
- 详细设计：对核心函数的算法步骤用自然语言描述，比如
push的步骤是“判满->扩容->top自增->赋值”。这里顺带解释为什么top初始为-1、为什么扩容因子取2，都是加分项。 - 调试分析：写你在调试时遇到的问题，比如我写初版的时候把
data[++top]写成了data[top++]，导致每次入栈都覆盖同一个位置。这类“真实的坑”比任何虚话都有说服力。 - 运行结果与测试：贴测试用例、边界输入和对应输出，并说明每个测试用例覆盖了哪条路径。
还有一个贯穿全文的要点：代码规范。缩进统一、命名清晰（data 不叫 arr1，capacity 不叫 max），注释不是翻译代码而是解释意图。这些细节在实验报告评分里占的比重通常超出你的想象。
5. 常见问题与排查技巧实录
5.1 运行崩溃、输出乱码，多半是这六个问题
顺序栈代码量不大，但新手写出来之后依然会出现各种幺蛾子。我整理了高频问题集合，供你遇到问题时直接对照排查。
问题一：数组越界导致乱码。
如果 push 前忘了判满，或者判满条件写成了 top == capacity（我用的是 top + 1 == capacity），元素就会写到数组末尾之外。数组越界是未定义行为，通常表现为输出乱码、程序崩溃，或者更隐蔽的“过一会儿才崩”。排查方法是打印每次 push 前的 top 和 capacity，肉眼核对边界。
问题二：栈内数据全部是同一个值。
这几乎可以肯定是 data[++top] = value 写成了 data[top++] = value。前置自增先加后用，后置自增先用后加，顺序栈的核心操作全靠这一下。
问题三：程序退出时崩溃。
优先考虑浅拷贝导致的重复释放。如果没写拷贝构造函数，把一个栈对象赋值给另一个，两个对象的 data 指向同一块地址，析构时同一块内存被 delete[] 两次，直接double free。解决办法就是按3.4节实现深拷贝。
问题四：容量显示没变。
检查扩容函数里有没有更新 capacity 成员。只 new 了新数组、把 data 指向新数组，但忘了 capacity = newCapacity，那下次判满依然按旧容量判断，很快就会再次越界。
问题五：pop之后取栈顶还能取到旧值。
这不是bug而是正常现象。pop 只是把 top 减1，并没有清空数组里的元素，那个位置的值还在，只是逻辑上已经不属于栈了。如果你想确保数据不可见，可以 data[top] = T() 之后再 --top，但这会多一次赋值开销，一般工程里不做。
问题六：模板类编译报错，找不到实现。
C++模板的一个“坑”是编译模型和普通类不同。模板声明和定义必须放在同一个头文件（或者使用 #include "SeqStack.cpp" 的方式），不能像普通类那样 .h 放声明、.cpp 放实现再分开编译。很多新手在Visual Studio里建了 SeqStack.h 和 SeqStack.cpp，结果链接报错找不到 push 等函数，就是这个原因。我的建议是初学阶段全部写在同一个 .h 文件，实测最省事。
5.2 关于本地环境的编译与调试建议
有同学问我用哪个IDE写C++比较好。我的答案是：先别纠结，用你手头现有的就行。Visual Studio、Dev-C++、Code::Blocks、VS Code配MinGW都无所谓，语法标准尽量选C++11或以上，因为更早的标准对模板的支持和报错信息质量都差一些。如果是在VS Code里配的C/C++插件，记得在 tasks.json 里把编译参数加上 -std=c++11，不然某些写法会报奇怪的老标准错误。
调试方面，初学者不要一上来就用断点高手的技巧，先用最简单的“打印大法”。在关键节点输出 capacity、top、data[i]，你很快就能定位问题。尤其是 top 值的变化轨迹，几乎能解释入栈出栈的全部问题。用熟了以后，再尝试IDE里的监视窗口，观察 data 指针指向的内存区域，那种可视化程度比打日志更直观。
6. 顺序栈的应用场景与后续扩展方向
6.1 栈无处不在：从表达式求值到回溯算法
学一类数据结构，最忌讳的是“学完就忘”，因为不知道它到底有什么用。顺序栈最经典的应用场景，我列几个高频的，你看看能不能串起来。
- 括号匹配：遍历字符串，遇到左括号入栈，遇到右括号时和栈顶配对，成功则出栈，失败则报错。这个场景把栈的“后进先出”特性体现得淋漓尽致。
- 表达式求值：中缀表达式转后缀（逆波兰表达式），或者直接使用两个栈完成中缀求值，一个栈存操作数，一个栈存运算符。编译器解析算术表达式的底层就是这套机制。
- 函数调用栈：任何一个程序在运行时，函数的嵌套调用就是一场隐式的入栈出栈。局部变量的生存周期、递归调用的返回地址，全是在系统栈上完成的。
- 回溯与DFS：走迷宫时，走过的路径入栈，走向死路时逐步出栈回溯；深度优先搜索中，待访问节点集合本质上也相当于一个栈。Undo/Redo（撤销/重做）功能同样是通过两个栈实现的。
所以别看顺序栈代码简单，它是很多复杂算法和应用的地基。把这块搞扎实了，后面学递归、学树和图的遍历都会顺畅很多。
6.2 扩展思路：链表栈、双端栈、单调栈
如果你做完顺序栈之后觉得意犹未尽，我个人建议按下面这几个方向递进学习：
- 链表栈：把底层数组换成单链表，栈顶在链表头。好处是没有容量限制、不需要扩容搬移，坏处是每个节点要额外存一个指针，牺牲了cache局部性。这个练习可以帮助你对比顺序存储和链式存储的优劣。
- 双端栈：用一个数组同时存两个栈，一个从左边生长，一个从右边生长，只有当两个栈顶相遇时才真的满。这个设计能极大提升空间利用率，是很多教材的课后拓展题。
- 单调栈：栈内元素保持单调递增或递减。它是解决“下一个更大元素”“柱状图最大矩形”这类算法题的核心工具，面试出现频率极高。注意，单调栈一般不需要动态扩容，往往配合固定长度数组直接手写。
这些扩展方向在实验报告里可以作为“课程设计创新点”来写，在面试中则是区分“会写栈”和“懂栈”的分水岭。
6.3 从实验题到工程：这版ADT还能怎么改
最后聊点“理论上过”但初学者用不到、留着以后看的优化。如果你的程序里频繁压入和弹出大量元素，那么 push 里那个 resize 每次搬移全部元素的开销可能是性能瓶颈。一个工程化改进是引入移动语义（T&& 和 std::move），让元素在扩容搬移时优先“偷走”资源而不是逐个拷贝。另一个改进是把 resize 的倍增因子从2改成1.5，这一点在 std::vector 的实现上是有过实测讨论的——2倍扩容容易导致内存碎片和空间浪费，1.5倍在时间与空间之间更均衡。当然，对入门阶段和刷题场景来说，这些暂时不用管，但知道方向总是好的。
最后分享一点我自己的实操体会。初始版本我也和大多数人一样，全写在 main 函数里，几十行代码堆在一起跑通就完事。后来被实验室学长拉去review代码，挨了一顿批才开始学“先设计类、再动手写函数”的习惯。数据结构实验的重点真的不是“跑通”，而是“想清楚再写”。你用类封装ADT这个过程，训练的是把一个具体问题抽象成数据类型的能力，这种能力在以后写工程代码、做系统设计时比任何一道算法题都值钱。