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

数据结构的栈和堆

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

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

栈就像装数据的桶或箱子

咱们先从你们比较熟悉的栈提及吧，它是一种具备后进先出性质的数据结构，也就是说后存放的先取，先存放的后取。

这就如同咱们要取出放在箱子里面底下的东西（放入的比较早的物体），咱们首先要移开压在它上面的物体（放入的比较晚的物体）。

堆像一棵倒过来的树

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

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

 

内存分配中的栈和堆

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

堆栈空间分配

栈（操做系统）：由操做系统自动分配释放 ，存放函数的参数值，局部变量的值等。其操做方式相似于数据结构中的栈。

堆（操做系统）： 通常由程序员分配释放， 若程序员不释放，程序结束时可能由OS回收，分配方式却是相似于链表。

堆栈缓存方式

栈使用的是一级缓存， 他们一般都是被调用时处于存储空间中，调用完毕当即释放。

堆则是存放在二级缓存中，生命周期由虚拟机的垃圾回收算法来决定（并非一旦成为孤儿对象就能被回收）。因此调用这些对象的速度要相对来得低一些。

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

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

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

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

main.cpp 

1. int a = 0; //全局初始化区

2. char *p1; //全局未初始化区

3. main()

4. {

5. int b; //栈

6. char s[] = "abc"; //栈

7. char *p2; //栈

8. char *p3 = "123456"; //123456\0在常量区，p3在栈上。

9. static int c =0； //全局（静态）初始化区

10. p1 = (char *)malloc(10); //堆

11. p2 = (char *)malloc(20); //堆

12. }

 

0.申请方式和回收方式不一样

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

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

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

1.申请后系统的响应

栈：只要栈的剩余空间大于所申请空间，系统将为程序提供内存，不然将报异常提示栈溢出。

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

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

2.申请效率的比较

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

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

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

3.申请大小的限制

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

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

4.堆和栈中的存储内容

因为栈的大小有限，因此用子函数仍是有物理意义的，而不只仅是逻辑意义。

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

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

5.存取效率的比较

<span stchar 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

关于堆和栈区别的比喻

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

使用栈就象咱们去饭馆里吃饭，只管点菜（发出申请）、付钱、和吃（使用），吃饱了就走，没必要理会切菜、洗菜等准备工做和洗碗、刷锅等扫尾工做，他的好处是快捷，可是自由度小。 

使用堆就象是本身动手作喜欢吃的菜肴，比较麻烦，可是比较符合本身的口味，并且自由度大。比喻很形象，说的很通俗易懂，不知道你是否有点收获。

 

问题描述

编程语言书籍中常常解释值类型被建立在栈上，引用类型被建立在堆上，可是并无本质上解释这堆和栈是什么。什么是栈，可是它们究竟是什么，在哪儿呢（站在实际的计算机物理内存的角度上看）？

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. 可能形成内存泄露。

举例：

C++

1 2 3 4 5 6 7 8 9 10 11 12 13 14

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.对栈而言，栈中的新加数据项放在其余数据的顶部，移除时你也只能移除最顶部的数据（不能越位获取）。 

2.对堆而言，数据项位置没有固定的顺序。你能够以任何顺序插入和删除，由于他们没有“顶部”数据这一律念。 

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

在一般状况下由操做系统（OS）和语言的运行时（runtime）控制吗？

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

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

它们的做用范围是什么？

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

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

它们的大小由什么决定？

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

堆是任何能够动态分配的内存的统称。这要看你怎么看待它了，它的大小是变更的。在现代处理器中和操做系统的工做方式是高度抽象的，所以你在正常状况下不须要担忧它实际的大小，除非你必需要使用你尚未分配的内存或者已经释放了的内存。

哪一个更快一些？

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

答案四

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

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

堆:

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

栈:

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 异常。这个异常接下会经过语言的运行时转成各类类型的栈溢出异常。（译者注：“不一样语言的异常提示不一样，所以经过语言运行时来转换”我想他表达的是这个含义）

 

*函数的分配能够用堆来代替栈吗？

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

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

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

参考：

http://www.cleey.com/blog/single/id/776.html

http://www.cnblogs.com/lln7777/archive/2012/03/14/2396164.html

http://blog.jobbole.com/75321/

https://stackoverflow.com/questions/79923/what-and-where-are-the-stack-and-heap