LIFO与FIFO
LIFO代表后进先出。如图所示，放入堆栈中的最后一个项目是从堆栈中取出的第一个项目。
用菜类比（在第一个修订版中）描述的是队列或FIFO，先进先出。
两者之间的主要区别在于，LIFO /堆栈从同一端压入（插入）和弹出（取出），而FIFO /队列从相对端压入（插入）。
// Both:
Push(a)
-> [a]
Push(b)
-> [a, b]
Push(c)
-> [a, b, c]
// Stack // Queue
Pop() Pop()
-> [a, b] -> [b, c]
堆栈指针
让我们看一下堆栈底层的情况。这是一些内存，每个盒子是一个地址：
...[ ][ ][ ][ ]... char* sp;
^- Stack Pointer (SP)
并且有一个指向当前空堆栈底部的堆栈指针（堆栈是向上增长还是向下增长与此处无关紧要，因此我们将忽略它，但是当然，在现实世界中，确实会确定要添加哪个操作） ，并从SP中减去）。
因此，让我们a, b, and c再次推动。左侧的图形，中间的“高级”操作，右侧的C-ish伪代码：
...[a][ ][ ][ ]... Push('a') *sp = 'a';
^- SP
...[a][ ][ ][ ]... ++sp;
^- SP
...[a][b][ ][ ]... Push('b') *sp = 'b';
^- SP
...[a][b][ ][ ]... ++sp;
^- SP
...[a][b][c][ ]... Push('c') *sp = 'c';
^- SP
...[a][b][c][ ]... ++sp;
^- SP
如您所见，每次我们push将参数插入到堆栈指针当前指向的位置，并调整堆栈指针以指向下一个位置。
现在弹出：
...[a][b][c][ ]... Pop() --sp;
^- SP
...[a][b][c][ ]... return *sp; // returns 'c'
^- SP
...[a][b][c][ ]... Pop() --sp;
^- SP
...[a][b][c][ ]... return *sp; // returns 'b'
^- SP
Pop与的相反push，它调整堆栈指针以指向先前的位置，并删除那里的项目（通常将其返回给任何人pop）。
您可能已经注意到了，b并且c仍在内存中。我只想向您保证这些不是错别字。我们将很快返回。
没有堆栈指针的生活
让我们看看如果没有堆栈指针会发生什么。从再次推送开始：
...[ ][ ][ ][ ]...
...[ ][ ][ ][ ]... Push(a) ? = 'a';
嗯，嗯……如果我们没有堆栈指针，那么我们就无法将某些内容移到它所指向的地址。也许我们可以使用一个指向底部而不是顶部的指针。
...[ ][ ][ ][ ]... char* bp; // "base pointer"
^- bp bp = malloc(...);
...[a][ ][ ][ ]... Push(a) *bp = 'a';
^- bp
// No stack pointer, so no need to update it.
...[b][ ][ ][ ]... Push(b) *bp = 'b';
^- bp
哦哦 由于我们无法更改堆栈基数的固定值，因此我们只需要a通过压b入相同的位置来覆盖堆栈的固定值即可。
好吧，为什么我们不跟踪自己被推了多少次。而且，我们还需要跟踪弹出的时间。
...[ ][ ][ ][ ]... char* bp; // "base pointer"
^- bp bp = malloc(...);
int count = 0;
...[a][ ][ ][ ]... Push(a) bp[count] = 'a';
^- bp
...[a][ ][ ][ ]... ++count;
^- bp
...[a][b][ ][ ]... Push(a) bp[count] = 'b';
^- bp
...[a][b][ ][ ]... ++count;
^- bp
...[a][b][ ][ ]... Pop() --count;
^- bp
...[a][b][ ][ ]... return bp[count]; //returns b
^- bp
很好，它可以工作，但是它实际上与以前非常相似，只是*pointer它比pointer[offset]（不需要额外的算术）便宜，更不用说键入更少了。这对我来说似乎是一种损失。
让我们再试一次。代替使用Pascal字符串样式查找基于数组的集合的末尾（跟踪集合中有多少项），让我们尝试C字符串样式（从头到尾扫描）：
...[ ][ ][ ][ ]... char* bp; // "base pointer"
^- bp bp = malloc(...);
...[ ][ ][ ][ ]... Push(a) char* top = bp;
^- bp, top
while(*top != 0) { ++top; }
...[ ][ ][ ][a]... *top = 'a';
^- bp ^- top
...[ ][ ][ ][ ]... Pop() char* top = bp;
^- bp, top
while(*top != 0) { ++top; }
...[ ][ ][ ][a]... --top;
^- bp ^- top return *top; // returns '('
您可能已经在这里猜到了问题。未初始化的内存不能保证为0。因此，当我们寻找要放置的顶部时a，最终将跳过一堆未使用的内存位置，这些位置中有随机垃圾。同样，当我们扫描到顶部时，最终跳过的a距离远远超过了刚刚推入的位置，直到我们最终找到恰好是的另一个内存位置0，然后移回并返回了之前的随机垃圾。
修复起来很容易，我们只需要添加操作Push并Pop确保始终将栈顶更新为0，并用终止符初始化栈即可。当然，这也意味着我们不能0在堆栈中有一个（或任何我们选择为终止符的值）作为实际值。
最重要的是，我们还将O（1）运算更改为O（n）运算。
TL; DR
堆栈指针跟踪发生所有动作的堆栈顶部。有很多方法可以摆脱它（bp[count]并且top本质上仍然是堆栈指针），但是与简单地拥有堆栈指针相比，它们最终都变得更加复杂和缓慢。而且，不知道堆栈顶部在哪里意味着您无法使用堆栈。
注意：指向x86中运行时堆栈“底部”的堆栈指针可能是一个误解，与整个运行时堆栈倒置有关。换句话说，堆栈的底部位于高位存储器地址，而堆栈的顶端向下生长到较低的存储器地址。堆栈指针确实指向发生所有操作的堆栈尖端，只是该尖端的内存地址比堆栈基数低。