内存、数据结构之栈和堆的区别？

川长思鸟来 2022-06-01 00:17 188阅读 0赞

网上有一篇很好的文章，我差不多直接搬运过来了。

> 来源：[http://www.cleey.com/blog/single/id/776.html][http_www.cleey.com_blog_single_id_776.html]

原文如下：

可能很多同学在这个概念上有些模糊，其实堆栈分为数据结构和内存的。数据结构的堆栈我想很多同学学习过，今天介绍下数据结构的堆栈，但是重点是内存的堆栈整理。

数据结构的栈和堆

首先在数据结构上要知道堆栈，尽管我们这么称呼它，但实际上堆栈是两种数据结构：堆和栈。

堆和栈都是一种数据项按序排列的数据结构。

**堆像一棵倒过来的树**

*  而堆就不同了，堆是一种经过排序的树形数据结构，每个结点都有一个值。
 *  通常我们所说的堆的数据结构，是指二叉堆。
 *  堆的特点是根结点的值最小（或最大），且根结点的两个子树也是一个堆。

由于堆的这个特性，常用来实现优先队列，堆的存取是随意，这就如同我们在图书馆的书架上取书，虽然书的摆放是有顺序的，但是我们想取任意一本时不必像栈一样，先取出前面所有的书，书架这种机制不同于箱子，我们可以直接取出我们想要的书。

内存分配中的栈和堆

先看百度百科中的内存堆栈介绍：

>  *  栈（操作系统）：由操作系统自动分配释放 ，存放函数的参数值，局部变量的值等。其操作方式类似于数据结构中的栈。
>  *  堆（操作系统）： 一般由程序员分配释放， 若程序员不释放，程序结束时可能由OS回收，分配方式倒是类似于链表。

堆栈缓存方式

>  *  栈使用的是一级缓存， 他们通常都是被调用时处于存储空间中，调用完毕立即释放。
>  *  堆则是存放在二级缓存中，生命周期由虚拟机的垃圾回收算法来决定（并不是一旦成为孤儿对象就能被回收）。所以调用这些对象的速度要相对来得低一些。

下面就说说C语言程序内存分配中的堆和栈，这里有必要把内存分配也提一下，大家不要嫌我啰嗦，一般情况下程序存放在Rom（只读内存，比如硬盘）或Flash中，运行时需要拷到RAM（随机存储器RAM）中执行，RAM会分别存储不同的信息，如下图所示：

![这里写图片描述][SouthEast]

内存中的栈区处于相对较高的地址以地址的增长方向为上的话，**栈地址是向下增长的。**

栈中分配局部变量空间，堆区是向上增长的用于分配程序员申请的内存空间。另外还有静态区是分配静态变量，全局变量空间的；只读区是分配常量和程序代码空间的；以及其他一些分区。

来看一个网上很流行的经典例子：

int a = 0; //全局初始化区 
    char *p1; //全局未初始化区 
    main() 
    { 
        int b; //栈 
        char s[] = "abc"; //栈 
        char *p2; //栈 
        char *p3 = "123456"; //123456\0在常量区，p3在栈上。 
        static int c =0； //全局（静态）初始化区 
        p1 = (char *)malloc(10); //堆 
        p2 = (char *)malloc(20);  //堆 
    }

**0.申请方式和回收方式不同**

不知道你是否有点明白了。

堆和栈的第一个区别就是申请方式不同：栈（英文名称是stack）是系统自动分配空间的，例如我们定义一个 char a；系统会自动在栈上为其开辟空间。而堆（英文名称是heap）则是程序员根据需要自己申请的空间，例如malloc（10）；开辟十个字节的空间。

由于栈上的空间是自动分配自动回收的，所以栈上的数据的生存周期只是在函数的运行过程中，运行后就释放掉，不可以再访问。而堆上的数据只要程序员不释放空间，就一直可以访问到，不过缺点是一旦忘记释放会造成内存泄露。还有其他的一些区别我认为网上的朋友总结的不错这里转述一下：

> 我备注：解释下内存泄露？百度百科 [内存泄露][Link 1]

**1.申请后系统的响应**

**栈**：只要栈的剩余空间大于所申请空间，系统将为程序提供内存，否则将报异常提示栈溢出。  
**堆**：首先应该知道操作系统有一个记录空闲内存地址的链表，当系统收到程序的申请时，会遍历该链表，寻找第一个空间大于所申请空间的堆结点，然后将该结点从空闲结点链表中删除，并将该结点的空间分配给程序，另外，对于大多数系统，会在这块内存空间中的首地址处记录本次分配的大小，这样，代码中的 delete语句才能正确的释放本内存空间。另外，由于找到的堆结点的大小不一定正好等于申请的大小，系统会自动的将多余的那部分重新放入空闲链表中。

也就是说**堆会在申请后还要做一些后续的工作这就会引出申请效率的问题**。

**2.申请效率的比较**

根据第0点和第1点可知。

**栈**：由系统自动分配，速度较快。但程序员是无法控制的。

**堆**：是由new分配的内存，一般速度比较慢，而且容易产生内存碎片不过用起来最方便。

**3.申请大小的限制**

**栈**：在Windows下栈是向低地址扩展的数据结构，是一块连续的内存的区域。这句话的意思是栈顶的地址和栈的最大容量是系统预先规定好的，在 WINDOWS下，栈的大小是2M（也有的说是1M，总之是一个编译时就确定的常数），如果申请的空间超过栈的剩余空间时，将提示overflow。因此，能从栈获得的空间较小。

**堆**：堆是向高地址扩展的数据结构，是不连续的内存区域。这是由于系统是用链表来存储的空闲内存地址的，自然是不连续的，而链表的遍历方向是由低地址向高地址。堆的大小受限于计算机系统中有效的虚拟内存。由此可见，堆获得的空间比较灵活，也比较大。

> 我备注：什么是虚拟内存？怕很多人不清楚什么是虚拟内存的概念，看下百度百科上的意思 [虚拟内存][Link 2]

**4.堆和栈中的存储内容**

**由于栈的大小有限，所以用子函数还是有物理意义的，而不仅仅是逻辑意义。**

**栈**： 在函数调用时，第一个进栈的是**主函数中函数调用后的下一条指令**（函数调用语句的下一条可执行语句）的地址，然后是函数的各个参数，在大多数的C编译器中，参数是由右往左入栈的，然后是**函数中的局部变量**。注意静态变量是不入栈的。  
当本次函数调用结束后，局部变量先出栈，然后是参数，最后栈顶指针指向最开始存的地址，也就是主函数中的下一条指令，程序由该点继续运行。

**堆**：一般是在堆的头部用一个字节存放堆的大小。堆中的具体内容有程序员安排。

**5.存取效率的比较**

char s1[] = "aaaaaaaaaaaaaaa"; 
    char *s2 = "bbbbbbbbbbbbbbbbb";

aaaaaaaaaaa是在运行时刻赋值的；放在栈中。  
而bbbbbbbbbbb是在编译时就确定的；放在堆中。  
但是，在以后的存取中，在栈上的数组比指针所指向的字符串(例如堆)快。

比如：

#include 
    void main() 
    { 
      char a = 1; 
      char c[] = "1234567890"; 
      char *p ="1234567890"; 
      a = c[1]; 
      a = p[1]; 
      return; 
    }

对应的汇编代码 :

10: a = c[1]; 
    00401067 8A 4D F1 mov clbyte ptr [ebp-0Fh] 
    0040106A 88 4D FC mov byte ptr [ebp-4]cl 
    11: a = p[1]; 
    0040106D 8B 55 EC mov edxdword ptr [ebp-14h] 
    00401070 8A 42 01 mov albyte ptr [edx+1] 
    00401073 88 45 FC mov byte ptr [ebp-4]al

**关于堆和栈区别的比喻**

堆和栈的区别可以引用一位前辈的比喻来看出：

*  使用栈就象我们去饭馆里吃饭，只管点菜（发出申请）、付钱、和吃（使用），吃饱了就走，不必理会切菜、洗菜等准备工作和洗碗、刷锅等扫尾工作，他的好处是快捷，但是自由度小。
 *  使用堆就象是自己动手做喜欢吃的菜肴，比较麻烦，但是比较符合自己的口味，而且自由度大。比喻很形象，说的很通俗易懂，不知道你是否有点收获。

网上还有篇文章分析的很好：[内存中的堆和栈到底是什么][Link 3]

--------------------

网上有篇文章关于「内存之栈和堆」的，我觉得贴在这可以结合起来一起看看：

> 来源：[什么是堆和栈，它们在哪儿？][Link 4]  
> 译者：独酌逸醉

原文如下：

**问题描述**（该问题来源 [ StackOverflow][StackOverflow]）

编程语言书籍中经常解释值类型被创建在栈上，引用类型被创建在堆上，但是并没有本质上解释这堆和栈是什么。我仅有高级语言编程经验，没有看过对此更清晰的解释。我的意思是我理解什么是栈，但是它们到底是什么，在哪儿呢（站在实际的计算机物理内存的角度上看）？

1.  在通常情况下由操作系统（OS）和语言的运行时（runtime）控制吗？
2.  它们的作用范围是什么？
3.  它们的大小由什么决定？
4.  哪个更快？

**答案一：**

栈是为执行线程留出的内存空间。当函数被调用的时候，栈顶为局部变量和一些 bookkeeping 数据预留块。当函数执行完毕，块就没有用了，可能在下次的函数调用的时候再被使用。栈通常用后进先出（LIFO）的方式预留空间；因此最近的保留块（reserved block）通常最先被释放。这么做可以使跟踪堆栈变的简单；从栈中释放块（free block）只不过是指针的偏移而已。

堆（heap）是为动态分配预留的内存空间。和栈不一样，从堆上分配和重新分配块没有固定模式；你可以在任何时候分配和释放它。这样使得跟踪哪部分堆已经被分配和被释放变的异常复杂；有许多定制的堆分配策略用来为不同的使用模式下调整堆的性能。

每一个线程都有一个栈，但是每一个应用程序通常都只有一个堆（尽管为不同类型分配内存使用多个堆的情况也是有的）。

直接回答你的问题： 1. 当线程创建的时候，操作系统（OS）为每一个系统级（system-level）的线程分配栈。通常情况下，操作系统通过调用语言的运行时（runtime）去为应用程序分配堆。 2. 栈附属于线程，因此当线程结束时栈被回收。堆通常通过运行时在应用程序启动时被分配，当应用程序（进程）退出时被回收。 3. 当线程被创建的时候，设置栈的大小。在应用程序启动的时候，设置堆的大小，但是可以在需要的时候扩展（分配器向操作系统申请更多的内存）。 4. 栈比堆要快，因为它存取模式使它可以轻松的分配和重新分配内存（指针/整型只是进行简单的递增或者递减运算），然而堆在分配和释放的时候有更多的复杂的 bookkeeping 参与。另外，在栈上的每个字节频繁的被复用也就意味着它可能映射到处理器缓存中，所以很快（译者注：局部性原理）。

**答案二：**

**Stack:**

1.  和堆一样存储在计算机 RAM 中。
2.  在栈上创建变量的时候会扩展，并且会自动回收。
3.  相比堆而言在栈上分配要快的多。
4.  用数据结构中的栈实现。
5.  存储局部数据，返回地址，用做参数传递。
6.  当用栈过多时可导致栈溢出（无穷次（大量的）的递归调用，或者大量的内存分配）。
7.  在栈上的数据可以直接访问（不是非要使用指针访问）。
8.  如果你在编译之前精确的知道你需要分配数据的大小并且不是太大的时候，可以使用栈。
9.  当你程序启动时决定栈的容量上限。

**Heap:**

1.  和栈一样存储在计算机RAM。
2.  在堆上的变量必须要手动释放，不存在作用域的问题。数据可用 delete, delete\[\] 或者 free 来释放。
3.  相比在栈上分配内存要慢。
4.  通过程序按需分配。
5.  大量的分配和释放可造成内存碎片。
6.  在 C++ 中，在堆上创建数的据使用指针访问，用 new 或者 malloc 分配内存。
7.  如果申请的缓冲区过大的话，可能申请失败。
8.  在运行期间你不知道会需要多大的数据或者你需要分配大量的内存的时候，建议你使用堆。
9.  可能造成内存泄露。

举例：

int foo()
    {
        char *pBuffer; //<--nothing allocated yet (excluding the pointer itself, which is allocated here on the stack).
        bool b = true; // Allocated on the stack.
        if(b)
        {
            //Create 500 bytes on the stack
            char buffer[500];
    
            //Create 500 bytes on the heap
            pBuffer = new char[500];
    
        }//<-- buffer is deallocated here, pBuffer is not
    }//<--- oops there's a memory leak, I should have called delete[] pBuffer;

**答案三：**

堆和栈是两种内存分配的两个统称。可能有很多种不同的实现方式，但是实现要符合几个基本的概念：

1.  对栈而言，栈中的新加数据项放在其他数据的顶部，移除时你也只能移除最顶部的数据（不能越位获取）。  
    ![这里写图片描述][SouthEast 1]
2.  对堆而言，数据项位置没有固定的顺序。你可以以任何顺序插入和删除，因为他们没有“顶部”数据这一概念。  
    ![这里写图片描述][SouthEast 2]

上面上个图片很好的描述了堆和栈分配内存的方式。

**在通常情况下由操作系统（OS）和语言的运行时（runtime）控制吗？**

如前所述，堆和栈是一个统称，可以有很多的实现方式。计算机程序通常有一个栈叫做[调用栈][Link 5]，用来存储当前函数调用相关的信息（比如：主调函数的地址，局部变量），因为函数调用之后需要返回给主调函数。栈通过扩展和收缩来承载信息。实际上，程序不是由运行时来控制的，它由编程语言、操作系统甚至是系统架构来决定。

堆是在任何内存中动态和随机分配的（内存的）统称；也就是无序的。内存通常由操作系统分配，通过应用程序调用 API 接口去实现分配。在管理动态分配内存上会有一些额外的开销，不过这由操作系统来处理。

**它们的作用范围是什么？**

调用栈是一个低层次的概念，就程序而言，它和“作用范围”没什么关系。如果你反汇编一些代码，你就会看到指针引用堆栈部分。就高级语言而言，语言有它自己的范围规则。一旦函数返回，函数中的局部变量会直接直接释放。你的编程语言就是依据这个工作的。

在堆中，也很难去定义。作用范围是由操作系统限定的，但是你的编程语言可能增加它自己的一些规则，去限定堆在应用程序中的范围。体系架构和操作系统是使用虚拟地址的，然后由处理器翻译到实际的物理地址中，还有页面错误等等。它们记录那个页面属于那个应用程序。不过你不用关心这些，因为你仅仅在你的编程语言中分配和释放内存，和一些错误检查（出现分配失败和释放失败的原因）。

**它们的大小由什么决定？**

依旧，依赖于语言，编译器，操作系统和架构。栈通常提前分配好了，因为栈必须是连续的内存块。语言的编译器或者操作系统决定它的大小。不要在栈上存储大块数据，这样可以保证有足够的空间不会溢出，除非出现了无限递归的情况（额，栈溢出了）或者其它不常见了编程决议。

堆是任何可以动态分配的内存的统称。这要看你怎么看待它了，它的大小是变动的。在现代处理器中和操作系统的工作方式是高度抽象的，因此你在正常情况下不需要担心它实际的大小，除非你必须要使用你还没有分配的内存或者已经释放了的内存。

**哪个更快一些？**

栈更快因为所有的空闲内存都是连续的，因此不需要对空闲内存块通过列表来维护。只是一个简单的指向当前栈顶的指针。编译器通常用一个专门的、快速的寄存器来实现。更重要的一点事是，随后的栈上操作通常集中在一个内存块的附近，这样的话有利于处理器的高速访问（译者注：局部性原理）。

**答案四：**

你问题的答案是依赖于实现的，根据不同的编译器和处理器架构而不同。下面简单的解释一下：

1.  栈和堆都是用来从底层操作系统中获取内存的。
2.  在多线程环境下每一个线程都可以有他自己完全的独立的栈，但是他们共享堆。并行存取被堆控制而不是栈。

**堆:**

1.  堆包含一个链表来维护已用和空闲的内存块。在堆上新分配（用 new 或者 malloc）内存是从空闲的内存块中找到一些满足要求的合适块。这个操作会更新堆中的块链表。这些元信息也存储在堆上，经常在每个块的头部一个很小区域。
2.  堆的增加新快通常从地地址向高地址扩展。因此你可以认为堆随着内存分配而不断的增加大小。如果申请的内存大小很小的话，通常从底层操作系统中得到比申请大小要多的内存。
3.  申请和释放许多小的块可能会产生如下状态：在已用块之间存在很多小的空闲块。进而申请大块内存失败，虽然空闲块的总和足够，但是空闲的小块是零散的，不能满足申请的大小，。这叫做“堆碎片”。
4.  当旁边有空闲块的已用块被释放时，新的空闲块可能会与相邻的空闲块合并为一个大的空闲块，这样可以有效的减少“堆碎片”的产生。

![这里写图片描述][SouthEast 3]

**栈:**

1.  栈经常与 sp 寄存器（译者注：”stack pointer”，了解汇编的朋友应该都知道）一起工作，最初 sp 指向栈顶（栈的高地址）。
2.  CPU 用 push 指令来将数据压栈，用 pop 指令来弹栈。当用 push 压栈时，sp 值减少（向低地址扩展）。当用 pop 弹栈时，sp 值增大。存储和获取数据都是 CPU 寄存器的值。
3.  当函数被调用时，CPU使用特定的指令把当前的 IP （译者注：“instruction pointer”，是一个寄存器，用来记录 CPU 指令的位置）压栈。即执行代码的地址。CPU 接下来将调用函数地址赋给 IP ，进行调用。当函数返回时，旧的 IP 被弹栈，CPU 继续去函数调用之前的代码。
4.  当进入函数时，sp 向下扩展，扩展到确保为函数的局部变量留足够大小的空间。如果函数中有一个 32-bit 的局部变量会在栈中留够四字节的空间。当函数返回时，sp 通过返回原来的位置来释放空间。
5.  如果函数有参数的话，在函数调用之前，会将参数压栈。函数中的代码通过 sp 的当前位置来定位参数并访问它们。
6.  函数嵌套调用和使用魔法一样，每一次新调用的函数都会分配函数参数，返回值地址、局部变量空间、嵌套调用的活动记录都要被压入栈中。函数返回时，按照正确方式的撤销。
7.  栈要受到内存块的限制，不断的函数嵌套/为局部变量分配太多的空间，可能会导致栈溢出。当栈中的内存区域都已经被使用完之后继续向下写（低地址），会触发一个 CPU 异常。这个异常接下会通过语言的运行时转成各种类型的栈溢出异常。（译者注：“不同语言的异常提示不同，因此通过语言运行时来转换”我想他表达的是这个含义）

![这里写图片描述][SouthEast 4]

**函数的分配可以用堆来代替栈吗？**

不可以的，函数的活动记录（即局部或者自动变量）被分配在栈上， 这样做不但存储了这些变量，而且可以用来嵌套函数的追踪。

堆的管理依赖于运行时环境，C 使用 malloc ，C++ 使用 new ，但是很多语言有垃圾回收机制。

栈是更低层次的特性与处理器架构紧密的结合到一起。当堆不够时可以扩展空间，这不难做到，因为可以有库函数可以调用。但是，扩展栈通常来说是不可能的，因为在栈溢出的时候，执行线程就被操作系统关闭了，这已经太晚了。

**译者注**

关于堆栈的这个帖子，对我来说，收获非常多。我之前看过一些资料，自己写代码的时候也常常思考。就这方面，也和祥子（我的大学舍友，现在北京邮电读研，技术牛人）探讨过多次了。但是终究是一个一个的知识点，这个帖子看完之后，豁然开朗，把知识点终于连接成了一个网。这种感觉，经历过的一定懂得，期间的兴奋不言而喻。

这个帖子跟帖者不少，我选了评分最高的四个。这四个之间也有一些是重复的观点。个人钟爱第四个回答者，我看的时候，瞬间高潮了，有木有？不过需要一些汇编语言、操作系统、计算机组成原理的的基础，知道那几个寄存器是干什么的，要知道计算机的流水线指令工作机制，保护/恢复现场等概念。三个回复者都涉及到了操作系统中虚拟内存；在比较速度的时候，大家一定要在脑中对“局部性原理”和计算机高速缓存有一个概念。

如果你把这篇文章看懂了，我相信你收获的不只是堆和栈，你会理解的更多！

兴奋之余，有几点还是要强调的，翻译没有逐字逐词翻译，大部分是通过我个人的知识积累和对回帖者的意图揣测而来的。请大家不要咬文嚼字，逐个推敲，我们的目的在于技术交流，不是么？达到这一目的就够了。

下面是一些不确定点：

1.  我没有听过 bookkeeping data 这种说法，故没有翻译。从上下文理解来看，可以想成是用来寄存器值？函数参数？返回地址？如果有了解具体含义的朋友，烦请告知。
2.  栈和堆栈是一回事，英文表达是 stack，堆是 heap。
3.  调用栈的概念，我是第一次听说，不太熟悉。大家可以去查查资料研究一下。

--------------------

***原文更新于 2018-01-15***

[http_www.cleey.com_blog_single_id_776.html]: http://www.cleey.com/blog/single/id/776.html
[SouthEast]: /images/20220601/cc3c73deee524f8eb9d2432b2c93208c.png
[Link 1]: https://baike.baidu.com/item/%E5%86%85%E5%AD%98%E6%B3%84%E6%BC%8F/6181425?fromtitle=%E5%86%85%E5%AD%98%E6%B3%84%E9%9C%B2&fromid=305116
[Link 2]: https://baike.baidu.com/item/%E8%99%9A%E6%8B%9F%E5%86%85%E5%AD%98
[Link 3]: https://www.jianshu.com/p/52b5a1879aa1
[Link 4]: http://blog.jobbole.com/75321/
[StackOverflow]: http://stackoverflow.com/questions/79923/what-and-where-are-the-stack-and-heap
[SouthEast 1]: /images/20220601/8ed921fb01714678b7961cb95ea7ff1a.png
[SouthEast 2]: /images/20220601/36e8bfd9f2a44b2db0f77619c122757e.png
[Link 5]: http://en.wikipedia.org/wiki/Call_stack
[SouthEast 3]: /images/20220601/9f2f5e1015ca4d3ea1addc0ecd2b9240.png
[SouthEast 4]: /images/20220601/af23117f1d9546afac24ab7c2b4fe40b.png