堆(heap)和栈(stack)是C/C++编程不可避免会碰到的两个基本概念。
在具体的C/C++编程框架中，这两个概念并不是并行的。对底层机器代码的研究可以揭示，栈是机器系统提供的数据结构，而堆则是C/C++函数库提供的。
现代串行执行机制计算机，都直接在代码底层支持栈的数据结构。这体现在，有专门的寄存器指向栈所在的地址，有专门的机器指令完成数据入栈出栈的操作。这种机制的特点是效率高，支持的数据有限，一般是整数，指针，浮点数等系统直接支持的数据类型，并不直接支持其他的数据结构。因为栈的这种特点，对栈的使用在程序中是非常频繁的。对子程序的调用就是直接利用栈完成的。机器的call指令里隐含了把返回地址推入栈，然后跳转至子程序地址的操作，而子程序中的 ret指令则隐含从堆栈中弹出返回地址并跳转之的操作。C/C++中的自动变量是直接利用栈的例子，这也就是为什么当函数返回时，该函数的自动变量自动失效的原因(因为堆栈恢复了调用前的状态)。
堆的数据结构并不是由机器系统或是操作系统支持的，而是由函数库提供的。
基本的malloc/realloc/free函数维护了一套内部的堆数据结构。当程序使用这些函数去获得新的内存空间时，这套函数首先试图从内部堆中寻找可用的内存空间，如果没有可以使用的内存空间，则试图利用系统调用来动态增加程序数据段的内存大小，新分配得到的空间首先被组织进内部堆中去，然后再以适当的形式返回给调用者。当程序释放分配的内存空间时，这片内存空间被返回内部堆结构中，可能会被适当的处理(比如和其他空闲空间合并成更大的空闲空间)，以更适合下一次内存分配申请。这套复杂的分配机制实际上相当于一个内存分配的缓冲池(Cache)。
使用这套机制有如下若干原因：
1.系统调用可能不支持任意大小的内存分配。有些系统的系统调用只支持固定大小及其倍数的内存请求(按页分配)；这样的话对于大量的小内存分类来说会造成浪费。
2.系统调用申请内存可能是代价昂贵的。系统调用可能涉及用户态和核心态的转换。
3.没有管理的内存分配在大量复杂内存的分配释放操作下很容易造成内存碎片。
堆和栈的对比如下：
（1）栈是系统提供的功能，特点是快速高效，缺点是有限制，数据不灵活；堆是函数库提供的功能，特点是灵活方便，数据适应面广泛，但是效率有一定降低。
（2）栈是系统数据结构，对于进程/线程是唯一的；堆是函数库内部数据结构，不一定唯一。不同堆分配的内存逻辑上无法互相操作。
（3）栈空间分静态分配和动态分配两种。静态分配由编译器完成的，如自动变量(auto)分配。动态分配由alloca函数完成。栈的动态分配无需释放(是自动的)，也就没有释放函数。为可移植的程序起见，栈的动态分配操作是不被鼓励的。堆空间的分配总是动态的，虽然程序结束时所有的数据空间都会被释放回系统，但是精确的申请内存/释放内存匹配是良好程序的基本要素。
这条短短的一句话就包含了堆与栈，用new，我们分配了一块堆内存，指针p分配的是一块栈内存；所以这句话的意思就是：在栈内存中存放了一个指向一块堆内存的指针p。在程序会先确定在堆中分配内存的大小，然后调用operator new分配内存，然后返回这块内存的首地址，放入栈中，他在VC6下的汇编代码如下：
00401028
push 14h
0040102A
call
operator new
(
00401060
)
0040102F add esp
,
4
00401032
mov dword ptr [ebp-
8
]
,
eax
00401035
mov eax
,
dword ptr [ebp-
8
]
00401038
mov dword ptr [ebp-
4
]
,
eax
堆和栈究竟有什么区别？
主要的区别由以下几点：
1 管理方式：对于栈来讲，是由编译器自动管理，无需我们手工控制；对于堆来说，释放工作由程序员控制，容易产生memory leak。
2 空间大小：一般来讲在32位系统下，堆内存可以达到4G的空间，从这个角度来看堆内存几乎是没有什么限制的。但是对于栈来讲，一般都是有一定的空间大小的，我们可以修改：
打开工程，依次操作菜单如下：Project->Setting->Link，在Category中选中Output，然后在Reserve中设定堆栈的值
注意：reserve最小值为4Byte；commit是保留在虚拟内存的页文件里，它设置较大会使栈开辟较大的值，可能增加内存开销和启动时间
3 碎片问题：对于堆来讲，频繁的new/delete势必会造成内存空间的不连续，从而造成大量的碎片，使程序效率降低。对于栈来讲，则不会存在这个问题，因为栈是先进后出的队列，他们是一一对应，以至于永远都不可能有一个内存块从栈中间弹出.
4 生长方向：对于堆，生长方向是向上，也就是向着内存地址增加的方向；对于栈，它的生长方向是向下的，是向着内存地址减小的方向增长 。
5 分配方式：堆都是动态分配的，没有静态分配的堆。栈有2种分配方式：静态分配和动态分配。静态分配是编译器完成的，比如局部变量的分配 动态分配由alloca函数进行分配。栈的动态分配和堆是不同的，他的动态分配是由编译器进行释放，无需我们手工实现。
6 分配效率：栈是机器系统提供的数据结构，计算机会在底层对栈提供支持：分配专门的寄存器存放栈的地址，压栈出栈都有专门的指令执行，这就决定了栈的效率比较高。堆则是C/C++函数库提供的，它的机制是很复杂的，例如为了分配一块内存，库函数会按照一定的算法在堆内存中搜索可用的足够大小的空间，如果没有足够大小的空间（可能是由于内存碎片太多），就有可能调用系统功能去增加程序数据段的内存空间，这样就有机会分到足够大小的内存，然后进行返回。显然，堆的效率比栈要低得多。
所以，堆和栈相比，由于大量new/delete的使用，容易造成大量的内存碎片；由于没有专门的系统支持，效率很低；由于可能引发用户态和核心态的切换，内存的申请，代价变得更加昂贵。所以栈在程序中是应用最广泛的，就算是函数的调用也利用栈去完成，函数调用过程中的参数，返回地址，EBP和局部变量都采用栈的方式存放。所以，我们推荐大家尽量用栈，而不是用堆。
但是由于和堆相比不是那么灵活，有时候分配大量的内存空间，还是用堆好一些。
无论是堆还是栈，都要防止越界现象的发生（除非你是故意使其越界），因为越界的结果要么是程序崩溃，要么是摧毁程序的堆、栈结构，产生意想不到的结果,就算是在你的程序运行过程中，没有发生上面的问题，你还是要小心，说不定什么时候就崩掉，那时候debug可是相当困难的.
最后，举一个综合的例子：
这是一个前辈写的，非常详细：
在栈上分配的内存系统会自动地为其释放，例如在函数结束时，局部变量将不复存在，就是系统自动清除栈内存的结果。但堆中分配的内存则不然：一切由你负责，即使你退出了new表达式的所处的函数或者作用域，那块内存还处于被使用状态而不能再利用。好处就是如果你想在不同模块中共享内存，那么这一点正合你意，坏处是如果你不打算再利用这块内存又忘了把它释放掉，那么它就会霸占你宝贵的内存资源直到你的程序退出为止。
栈是机器系统提供的数据结构，计算机会在底层对栈提供支持：分配专门的寄存器存放栈的地址，压栈出栈都有专门的指令执行，这就决定了栈的效率比较高。堆则是C/C++函数库提供的，它的机制是很复杂的，例如为了分配一块内存，库函数会按照一定的算法（具体的算法可以参考数据结构/操作系统）在堆内存中搜索可用的足够大小的空间，如果没有足够大小的空间（可能是由于内存碎片太多），就有可能调用系统功能去增加程序数据段的内存空间，这样就有机会分到足够大小的内存，然后进行返回。显然，堆的效率比栈要低得多。
C/C++中，所有的方法调用都是通过栈来进行的,所有的局部变量,形式参数都是从栈中分配内存空间的。实际上也不是什么分配,只是从栈顶向上用就行,就好像工厂中的传送带(conveyor belt)一样,Stack Pointer会自动指引你到放东西的位置,你所要做的只是把东西放下来就行.退出函数的时候，修改栈指针就可以把栈中的内容销毁.这样的模式速度最快, 当然要用来运行程序了.需要注意的是,在分配的时候,比如为一个即将要调用的程序模块分配数据区时,应事先知道这个数据区的大小,也就说是虽然分配是在程序运行时进行的,但是分配的大小多少是确定的,不变的,而这个"大小多少"是在编译时确定的,不是在运行时.
看看LINUX内核源代码的存储管理部分，就知道操作系统是如何管理内存资源的。每个进程都有独立的地址空间，不过这只是虚地址，这也是我们通常所看到的地址，所以我们现在写程序时不会像早期的程序员担心内存不够用，对于LINUX用户进程最大可用3G的地址空间，另外的1G留给内核。这里讨论的堆或栈都是在虚拟地址空间上，各个进程都有自己独立堆、栈空间，否则，就象楼上一些哥们说的，一个进程飞了，那所有进程都得死。
至于堆和栈哪个更快，从两方面来考虑：1.分配和释放，堆在分配和释放时都要调用函数（MALLOC,FREE)，比如分配时会到堆空间去寻找足够大小的空间（因为多次分配释放后会造成空洞），这些都会花费一定的时间，具体可以看看MALLOC和FREE的源代码，他们做了很多额外的工作，而栈却不需要这些。2.访问时间，访问堆的一个具体单元，需要两次访问内存，第一次得取得指针，第二次才是真正得数据，而栈只需访问一次。另外，堆的内容被操作系统交换到外存的概率比栈大，栈一般是不会被交换出去的。
综上所述，站在操作系统以上的层面来看，栈的效率比堆高，对于应用程序员，这些都是透明的，操作系统做了很多我们看不到的东西。 <script class="javascript" src="http://www.dreamprojections.com/syntaxhighlighter/Tests/Scripts/shCore.js"></script> <script class="javascript" src="http://www.dreamprojections.com/syntaxhighlighter/Tests/Scripts/shBrushCpp.js"></script> <script class="javascript"> dp.SyntaxHighlighter.HighlightAll('code'); </script>
在具体的C/C++编程框架中，这两个概念并不是并行的。对底层机器代码的研究可以揭示，栈是机器系统提供的数据结构，而堆则是C/C++函数库提供的。
现代串行执行机制计算机，都直接在代码底层支持栈的数据结构。这体现在，有专门的寄存器指向栈所在的地址，有专门的机器指令完成数据入栈出栈的操作。这种机制的特点是效率高，支持的数据有限，一般是整数，指针，浮点数等系统直接支持的数据类型，并不直接支持其他的数据结构。因为栈的这种特点，对栈的使用在程序中是非常频繁的。对子程序的调用就是直接利用栈完成的。机器的call指令里隐含了把返回地址推入栈，然后跳转至子程序地址的操作，而子程序中的 ret指令则隐含从堆栈中弹出返回地址并跳转之的操作。C/C++中的自动变量是直接利用栈的例子，这也就是为什么当函数返回时，该函数的自动变量自动失效的原因(因为堆栈恢复了调用前的状态)。
堆的数据结构并不是由机器系统或是操作系统支持的，而是由函数库提供的。
基本的malloc/realloc/free函数维护了一套内部的堆数据结构。当程序使用这些函数去获得新的内存空间时，这套函数首先试图从内部堆中寻找可用的内存空间，如果没有可以使用的内存空间，则试图利用系统调用来动态增加程序数据段的内存大小，新分配得到的空间首先被组织进内部堆中去，然后再以适当的形式返回给调用者。当程序释放分配的内存空间时，这片内存空间被返回内部堆结构中，可能会被适当的处理(比如和其他空闲空间合并成更大的空闲空间)，以更适合下一次内存分配申请。这套复杂的分配机制实际上相当于一个内存分配的缓冲池(Cache)。
使用这套机制有如下若干原因：
1.系统调用可能不支持任意大小的内存分配。有些系统的系统调用只支持固定大小及其倍数的内存请求(按页分配)；这样的话对于大量的小内存分类来说会造成浪费。
2.系统调用申请内存可能是代价昂贵的。系统调用可能涉及用户态和核心态的转换。
3.没有管理的内存分配在大量复杂内存的分配释放操作下很容易造成内存碎片。
堆和栈的对比如下：
（1）栈是系统提供的功能，特点是快速高效，缺点是有限制，数据不灵活；堆是函数库提供的功能，特点是灵活方便，数据适应面广泛，但是效率有一定降低。
（2）栈是系统数据结构，对于进程/线程是唯一的；堆是函数库内部数据结构，不一定唯一。不同堆分配的内存逻辑上无法互相操作。
（3）栈空间分静态分配和动态分配两种。静态分配由编译器完成的，如自动变量(auto)分配。动态分配由alloca函数完成。栈的动态分配无需释放(是自动的)，也就没有释放函数。为可移植的程序起见，栈的动态分配操作是不被鼓励的。堆空间的分配总是动态的，虽然程序结束时所有的数据空间都会被释放回系统，但是精确的申请内存/释放内存匹配是良好程序的基本要素。
void
f()
{
int * p = new int [ 5 ];
}
{
int * p = new int [ 5 ];
}
这条短短的一句话就包含了堆与栈，用new，我们分配了一块堆内存，指针p分配的是一块栈内存；所以这句话的意思就是：在栈内存中存放了一个指向一块堆内存的指针p。在程序会先确定在堆中分配内存的大小，然后调用operator new分配内存，然后返回这块内存的首地址，放入栈中，他在VC6下的汇编代码如下：
00401028
push 14h 0040102A
call
operator new
(
00401060
)
0040102F add esp
,
4
00401032
mov dword ptr [ebp-
8
]
,
eax
00401035
mov eax
,
dword ptr [ebp-
8
]
00401038
mov dword ptr [ebp-
4
]
,
eax
堆和栈究竟有什么区别？
主要的区别由以下几点：
1 管理方式：对于栈来讲，是由编译器自动管理，无需我们手工控制；对于堆来说，释放工作由程序员控制，容易产生memory leak。
2 空间大小：一般来讲在32位系统下，堆内存可以达到4G的空间，从这个角度来看堆内存几乎是没有什么限制的。但是对于栈来讲，一般都是有一定的空间大小的，我们可以修改：
打开工程，依次操作菜单如下：Project->Setting->Link，在Category中选中Output，然后在Reserve中设定堆栈的值
注意：reserve最小值为4Byte；commit是保留在虚拟内存的页文件里，它设置较大会使栈开辟较大的值，可能增加内存开销和启动时间
3 碎片问题：对于堆来讲，频繁的new/delete势必会造成内存空间的不连续，从而造成大量的碎片，使程序效率降低。对于栈来讲，则不会存在这个问题，因为栈是先进后出的队列，他们是一一对应，以至于永远都不可能有一个内存块从栈中间弹出.
4 生长方向：对于堆，生长方向是向上，也就是向着内存地址增加的方向；对于栈，它的生长方向是向下的，是向着内存地址减小的方向增长 。
5 分配方式：堆都是动态分配的，没有静态分配的堆。栈有2种分配方式：静态分配和动态分配。静态分配是编译器完成的，比如局部变量的分配 动态分配由alloca函数进行分配。栈的动态分配和堆是不同的，他的动态分配是由编译器进行释放，无需我们手工实现。
6 分配效率：栈是机器系统提供的数据结构，计算机会在底层对栈提供支持：分配专门的寄存器存放栈的地址，压栈出栈都有专门的指令执行，这就决定了栈的效率比较高。堆则是C/C++函数库提供的，它的机制是很复杂的，例如为了分配一块内存，库函数会按照一定的算法在堆内存中搜索可用的足够大小的空间，如果没有足够大小的空间（可能是由于内存碎片太多），就有可能调用系统功能去增加程序数据段的内存空间，这样就有机会分到足够大小的内存，然后进行返回。显然，堆的效率比栈要低得多。
所以，堆和栈相比，由于大量new/delete的使用，容易造成大量的内存碎片；由于没有专门的系统支持，效率很低；由于可能引发用户态和核心态的切换，内存的申请，代价变得更加昂贵。所以栈在程序中是应用最广泛的，就算是函数的调用也利用栈去完成，函数调用过程中的参数，返回地址，EBP和局部变量都采用栈的方式存放。所以，我们推荐大家尽量用栈，而不是用堆。
但是由于和堆相比不是那么灵活，有时候分配大量的内存空间，还是用堆好一些。
无论是堆还是栈，都要防止越界现象的发生（除非你是故意使其越界），因为越界的结果要么是程序崩溃，要么是摧毁程序的堆、栈结构，产生意想不到的结果,就算是在你的程序运行过程中，没有发生上面的问题，你还是要小心，说不定什么时候就崩掉，那时候debug可是相当困难的.
最后，举一个综合的例子：
这是一个前辈写的，非常详细：
//
main.cpp
int a = 0 ; 全局初始化区
char * p1; 全局未初始化区
main()
{
int b; // 栈
char s[] = " abc " ; // 栈
char * p2; // 栈
char * p3 = " 123456 " ; // 123456�在常量区，p3在栈上。
static int c = 0 ； // 全局（静态）初始化区
p1 = ( char * )malloc( 10 );
p2 = ( char * )malloc( 20 );
// 分配得来得10和20字节的区域就在堆区。
strcpy(p1, " 123456 " ); // 123456�放在常量区，编译器可能会将它与p3所指向的"123456"优化成一个地方。
}
int a = 0 ; 全局初始化区
char * p1; 全局未初始化区
main()
{
int b; // 栈
char s[] = " abc " ; // 栈
char * p2; // 栈
char * p3 = " 123456 " ; // 123456�在常量区，p3在栈上。
static int c = 0 ； // 全局（静态）初始化区
p1 = ( char * )malloc( 10 );
p2 = ( char * )malloc( 20 );
// 分配得来得10和20字节的区域就在堆区。
strcpy(p1, " 123456 " ); // 123456�放在常量区，编译器可能会将它与p3所指向的"123456"优化成一个地方。
}
在栈上分配的内存系统会自动地为其释放，例如在函数结束时，局部变量将不复存在，就是系统自动清除栈内存的结果。但堆中分配的内存则不然：一切由你负责，即使你退出了new表达式的所处的函数或者作用域，那块内存还处于被使用状态而不能再利用。好处就是如果你想在不同模块中共享内存，那么这一点正合你意，坏处是如果你不打算再利用这块内存又忘了把它释放掉，那么它就会霸占你宝贵的内存资源直到你的程序退出为止。
栈是机器系统提供的数据结构，计算机会在底层对栈提供支持：分配专门的寄存器存放栈的地址，压栈出栈都有专门的指令执行，这就决定了栈的效率比较高。堆则是C/C++函数库提供的，它的机制是很复杂的，例如为了分配一块内存，库函数会按照一定的算法（具体的算法可以参考数据结构/操作系统）在堆内存中搜索可用的足够大小的空间，如果没有足够大小的空间（可能是由于内存碎片太多），就有可能调用系统功能去增加程序数据段的内存空间，这样就有机会分到足够大小的内存，然后进行返回。显然，堆的效率比栈要低得多。
C/C++中，所有的方法调用都是通过栈来进行的,所有的局部变量,形式参数都是从栈中分配内存空间的。实际上也不是什么分配,只是从栈顶向上用就行,就好像工厂中的传送带(conveyor belt)一样,Stack Pointer会自动指引你到放东西的位置,你所要做的只是把东西放下来就行.退出函数的时候，修改栈指针就可以把栈中的内容销毁.这样的模式速度最快, 当然要用来运行程序了.需要注意的是,在分配的时候,比如为一个即将要调用的程序模块分配数据区时,应事先知道这个数据区的大小,也就说是虽然分配是在程序运行时进行的,但是分配的大小多少是确定的,不变的,而这个"大小多少"是在编译时确定的,不是在运行时.
看看LINUX内核源代码的存储管理部分，就知道操作系统是如何管理内存资源的。每个进程都有独立的地址空间，不过这只是虚地址，这也是我们通常所看到的地址，所以我们现在写程序时不会像早期的程序员担心内存不够用，对于LINUX用户进程最大可用3G的地址空间，另外的1G留给内核。这里讨论的堆或栈都是在虚拟地址空间上，各个进程都有自己独立堆、栈空间，否则，就象楼上一些哥们说的，一个进程飞了，那所有进程都得死。
至于堆和栈哪个更快，从两方面来考虑：1.分配和释放，堆在分配和释放时都要调用函数（MALLOC,FREE)，比如分配时会到堆空间去寻找足够大小的空间（因为多次分配释放后会造成空洞），这些都会花费一定的时间，具体可以看看MALLOC和FREE的源代码，他们做了很多额外的工作，而栈却不需要这些。2.访问时间，访问堆的一个具体单元，需要两次访问内存，第一次得取得指针，第二次才是真正得数据，而栈只需访问一次。另外，堆的内容被操作系统交换到外存的概率比栈大，栈一般是不会被交换出去的。
综上所述，站在操作系统以上的层面来看，栈的效率比堆高，对于应用程序员，这些都是透明的，操作系统做了很多我们看不到的东西。 <script class="javascript" src="http://www.dreamprojections.com/syntaxhighlighter/Tests/Scripts/shCore.js"></script> <script class="javascript" src="http://www.dreamprojections.com/syntaxhighlighter/Tests/Scripts/shBrushCpp.js"></script> <script class="javascript"> dp.SyntaxHighlighter.HighlightAll('code'); </script>
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
