关于内存中堆和栈的知识和应用的总结

以前做的一个小项目最近经常不稳定，查了下日志大部分都是因为缓冲溢出而导致程序报错，于是乎在网上查找了一些关于内存使用的内容，收获颇丰。在此将前人的一些精华总结收录于此，加深印象。有不对或不足的地方请大家予以指正。

文章链接：http://blog.csdn.net/szchtx/article/details/7981401

　　　　　http://www.cppblog.com/oosky/archive/2006/01/21/2958.html

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

在汇编语言中，堆栈段定义了堆栈的所在区域，它开辟了一个比较特殊的存储区，并且以后进先出的方式来访问这一区域。如果在程序中要用到 额寄存器，但它们的内容却在将来还有用，这时就可以用PUSHA/PUSHAD指令把它们保存在堆栈中，然后再需要时再用POPA/POPAD指令恢复其原始内容。子程序结构的程序和中断程序中就经常会用到。图1是PUSHAD指令执行情况的例子：

上面的例子是所有寄存器进栈指令的执行情况。指令执行后SP <— SP—32。

在数据结构中，堆栈是两种数据结构：堆和栈。它们都是数据项按序排列的数据结构。

栈

栈是一种具有后进先出性质的数据结构，即最后存入的数据最先被取出。

有人将栈形象地比作装衣物的箱子，如果我们要取出放入箱子低下的东西（先存放的），首先要先已开它上面的东西（后存放的）。

堆

堆是一种经过排序的树形数据结构，其每个节点都有一个索引值。

通常我们所说的堆的数据结构，是指二叉堆。特点是根结点的值最小（或最大），且根结点的两个子树也是一个堆。有人将堆比作一颗倒过来的树。

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

程序内存分配过程：一般情况下程序存放在Rom（只读内存，比如硬盘）或Flash中，运行时需要拷到RAM（随机存储器RAM）中执行，RAM会分别存储不同的信息。

如下图（该图为从参考链接中的文章中拷贝而来）

一个由C/C++编译的程序占用的内存分为以下几个部分：
1、栈区（stack）： 由编译器自动分配释放 ，存放函数的参数值，局部变量的值等。其操作方式类似于数据结构中的栈。
2、堆区（heap）：一般由程序员分配释放， 若程序员不释放，程序结束时可能由OS回收 。注意它与数据结构中的堆是两回事，分配方式倒是类似于链表。
3、全局区（静态区）（static）：全局变量和静态变量的存储是放在一块的，初始化的全局变量和静态变量在一块区域， 未初始化的全局变量和未初始化的静态变量在相邻的另一块区域。程序结束后由系统释放。
4、文字常量区：常量字符串就是放在这里的。程序结束后由系统释放。
5、程序代码区：存放函数体的二进制代码。

下面是前人写的一个例子程序（具体作者不详），讲的很详细：

 1 //main.cpp
 2 int a = 0; 全局初始化区
 3 char *p1; 全局未初始化区
 4 main()
 5 {
 6 int b; 栈
 7 char s[] = "abc"; 栈
 8 char *p2; 栈
 9 char *p3 = "123456"; 123456\0在常量区，p3在栈上。
10 static int c =0； 全局（静态）初始化区
11 p1 = (char *)malloc(10);
12 p2 = (char *)malloc(20);
13 分配得来得10和20字节的区域就在堆区。
14 strcpy(p1, "123456"); 123456\0放在常量区，编译器可能会将它与p3所指向的"123456"优化成一个地方。
15 } 

1、申请、回收方式不同

栈（stack）：由系统自动分配。

例如，在函数中声明一个局部变量int a，系统会自动在栈中为其开辟空间。该数据在栈上的生存周期只是在函数的运行过程中，运行完之后便自动释放掉，不可以再访问。

堆（heap）：需要程序员自己申请，并指明大小。

在C中使用malloc函数，如:

p1 = (char *)malloc(10);

在C++中使用new运算符，如：

p2 = new char[10];

注：p1,p2本身在栈中。

堆上的数据只要程序员不释放空间，就一直可以访问到，不过缺点是一旦忘记释放会造成内存泄露。

2、申请后系统的响应

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

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

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

3、申请效率的比较

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

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

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

4、申请大小的限制

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

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

5、堆和栈中的存储内容

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

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

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

6、存取效率的比较

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

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

比如：

 1 #include
 2 void main()
 3 {
 4     char a = 1;
 5     char c[] = "1234567890";
 6     char *p ="1234567890";
 7     a = c[1];
 8     a = p[1];
 9     return;
10 } 

对应的汇编代码如下：

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

第一种在读取时直接就把字符串中的元素读到寄存器cl中，而第二种则要先把指针值读到edx中，在根据edx读取字符，显然慢了。

堆和栈的区别可以用如下的比喻来看出： 
使用栈就象我们去饭馆里吃饭，只管点菜（发出申请）、付钱、和吃（使用），吃饱了就走，不必理会切菜、洗菜等准备工作和洗碗、刷锅等扫尾工作，他的好处是快捷，但是自由度小。 
使用堆就象是自己动手做喜欢吃的菜肴，比较麻烦，但是比较符合自己的口味，而且自由度大。

先来看下面的代码：

 1 #include <stdio.h>
 2 #include <string.h>
 3
 4 void __stdcall func()
 5 {
 6 　　char lpBuff[8]="\0";
 7 　　strcat(lpBuff,"AAAAAAAAAAA");
 8　　 return;
 9 }
10
11 int main()
12 {
13 　　func();
14　　 return 0;
15 } 

编译后执行一下回怎么样？哈，“"0x00414141"指令引用的"0x00000000"内存。该内存不能为"read"。”，“非法操作”喽！"41"就是"A"的16进制的ASCII码了，那明显就是strcat这句出的问题了。"lpBuff"的大小只有8字节，算进结尾的\0，那strcat最多只能写入7个"A"，但程序实际写入了11个"A"外加1个\0。再来看看上面那幅图，多出来的4个字节正好覆盖了RET的所在的内存空间，导致函数返回到一个错误的内存地址，执行了错误的指令。如果能精心构造这个字符串，使它分成三部分，前一部份仅仅是填充的无意义数据以达到溢出的目的，接着是一个覆盖RET的数据，紧接着是一段shellcode，那只要着个RET地址能指向这段shellcode的第一个指令，那函数返回时就能执行shellcode了。但是软件的不同版本和不同的运行环境都可能影响这段shellcode在内存中的位置，那么要构造这个RET是十分困难的。一般都在RET和shellcode之间填充大量的NOP指令，使得exploit有更强的通用性。

├———————┤<—低端内存区域 
│ …… │ 
├———————┤<—由exploit填入数据的开始 
│ │ 
│ buffer │<—填入无用的数据 
│ │ 
├———————┤ 
│ RET │<—指向shellcode，或NOP指令的范围 
├———————┤ 
│ NOP │ 
│ …… │<—填入的NOP指令，是RET可指向的范围 
│ NOP │ 
├———————┤ 
│ │ 
│ shellcode │ 
│ │ 
├———————┤<—由exploit填入数据的结束 
│ …… │ 
├———————┤<—高端内存区域

windows下的动态数据除了可存放在栈中，还可以存放在堆中。了解C++的朋友都知道，C++可以使用new关键字来动态分配内存。来看下面的C++代码：

 1 #include <stdio.h>
 2 #include <iostream.h>
 3 #include <windows.h>
 4
 5 void func()
 6 {
 7     char *buffer=new char[128];
 8     char bufflocal[128];
 9     static char buffstatic[128];
10     printf("0x%08x\n",buffer); //打印堆中变量的内存地址
11     printf("0x%08x\n",bufflocal); //打印本地变量的内存地址
12     printf("0x%08x\n",buffstatic); //打印静态变量的内存地址
13 }
14
15 void main()
16 {
17     func();
18     return;
19 } 

程序执行结果为：

0x004107d0
0x0012ff04
0x004068c0 

可以发现用new关键字分配的内存即不在栈中，也不在静态数据区。VC编译器是通过windows下的“堆(heap)”来实现new关键字的内存动态分配。在讲“堆”之前，先来了解一下和“堆”有关的几个API函数：

HeapAlloc 在堆中申请内存空间
HeapCreate 创建一个新的堆对象
HeapDestroy 销毁一个堆对象
HeapFree 释放申请的内存
HeapWalk 枚举堆对象的所有内存块
GetProcessHeap 取得进程的默认堆对象
GetProcessHeaps 取得进程所有的堆对象
LocalAlloc
GlobalAlloc 

当进程初始化时，系统会自动为进程创建一个默认堆，这个堆默认所占内存的大小为1M。堆对象由系统进行管理，它在内存中以链式结构存在。通过下面的代码可以通过堆动态申请内存空间：

1 HANDLE hHeap=GetProcessHeap();
2 char *buff=HeapAlloc(hHeap,0,8); 

其中hHeap是堆对象的句柄，buff是指向申请的内存空间的地址。那这个hHeap究竟是什么呢？它的值有什么意义吗？看看下面这段代码吧：

 1 #pragma comment(linker,"/entry:main") //定义程序的入口
 2 #include <windows.h>
 3
 4 _CRTIMP int (__cdecl *printf)(const char *, ...); //定义STL函数printf
 5 /*---------------------------------------------------------------------------
 6 写到这里，我们顺便来复习一下前面所讲的知识：
 7 (*注)printf函数是C语言的标准函数库中函数，VC的标准函数库由msvcrt.dll模块实现。
 8 由函数定义可见，printf的参数个数是可变的，函数内部无法预先知道调用者压入的参数个数，函数只能通过分析第一个参数字符串的格式来获得压入参数的信息，由于这里参数的个数是动态的，所以必须由调用者来平衡堆栈，这里便使用了__cdecl调用规则。BTW，Windows系统的API函数基本上是__stdcall调用形式，只有一个API例外，那就是wsprintf，它使用__cdecl调用规则，同printf函数一样，这是由于它的参数个数是可变的缘故。
 9 ---------------------------------------------------------------------------*/
10 void main()
11 {
12 HANDLE hHeap=GetProcessHeap();
13 char *buff=HeapAlloc(hHeap,0,0x10);
14 char *buff2=HeapAlloc(hHeap,0,0x10);
15 HMODULE hMsvcrt=LoadLibrary("msvcrt.dll");
16 printf=(void *)GetProcAddress(hMsvcrt,"printf");
17 printf("0x%08x\n",hHeap);
18 printf("0x%08x\n",buff);
19 printf("0x%08x\n\n",buff2);
20 } 

执行结果为：

0x00130000
0x00133100
0x00133118 

hHeap的值怎么和那个buff的值那么接近呢？其实hHeap这个句柄就是指向HEAP首部的地址。在进程的用户区存着一个叫PEB(进程环境块)的结构，这个结构中存放着一些有关进程的重要信息，其中在PEB首地址偏移0x18处存放的ProcessHeap就是进程默认堆的地址，而偏移0x90处存放了指向进程所有堆的地址列表的指针。windows有很多API都使用进程的默认堆来存放动态数据，如windows 2000下的所有ANSI版本的函数都是在默认堆中申请内存来转换ANSI字符串到Unicode字符串的。对一个堆的访问是顺序进行的，同一时刻只能有一个线程访问堆中的数据，当多个线程同时有访问要求时，只能排队等待，这样便造成程序执行效率下降。

最后来说说内存中的数据对齐。所位数据对齐，是指数据所在的内存地址必须是该数据长度的整数倍，DWORD数据的内存起始地址能被4除尽，WORD数据的内存起始地址能被2除尽，x86 CPU能直接访问对齐的数据，当他试图访问一个未对齐的数据时，会在内部进行一系列的调整，这些调整对于程序来说是透明的，但是会降低运行速度，所以编译器在编译程序时会尽量保证数据对齐。同样一段代码，我们来看看用VC、Dev-C++和lcc三个不同编译器编译出来的程序的执行结果：

 1 #include <stdio.h>
 2
 3 int main()
 4 {
 5     int a;
 6     char b;
 7     int c;
 8     printf("0x%08x\n",&a);
 9     printf("0x%08x\n",&b);
10     printf("0x%08x\n",&c);
11     return 0;
12 } 

这是用VC编译后的执行结果：

0x0012ff7c
0x0012ff7b
0x0012ff80 

变量在内存中的顺序：b(1字节)-a(4字节)-c(4字节)。

这是用Dev-C++编译后的执行结果：

0x0022ff7c
0x0022ff7b
0x0022ff74 

变量在内存中的顺序：c(4字节)-中间相隔3字节-b(占1字节)-a(4字节)。

这是用lcc编译后的执行结果：

0x0012ff6c
0x0012ff6b
0x0012ff64 

变量在内存中的顺序：同上。

三个编译器都做到了数据对齐，但是后两个编译器显然没VC“聪明”，让一个char占了4字节，浪费内存哦。