堆和栈的区别

 

l         程序的内存分配

一个由C/C++编译的程序占用的内存分为以下几个部分：

1.       栈区（stack）：由编译器自动分配释放，存放函数的参数值、局部变量的值等。其操作方式类似于数据结构中的栈。

2.       堆区（heap）：一般由程序员分配释放，若程序员不释放，程序结束时可能由OS回收。需要注意的是这里的堆与数据结构中的堆是两回事，分配方式类似于链表。

3.       全局区（静态区，static）：全局变量和静态变量的存储是放在一起的，初始化的全局变量和静态变量在一块区域，未初始化的全局变量和未初始化的静态变量在相邻的另一块区域。程序结束后由系统释放。

4.       文字常量区：常量字符串就是放在这里，程序结束后由系统释放。

5.       程序代码区：存放函数体的二进制代码。

 

例子程序：

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

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

main()

{

       int b;                               // 栈

       char s[] = “abc”;             // 栈

       char *p2;                       // 栈

       char *p3 = “123456”;   // “123456/0”在常量区，p3在栈上

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

      

       // 这样分配得到的10和20字节的区域在堆区

       p1 = (char *)malloc(10);

       p2 = (char *)malloc(20);

      

       strcpy(p1, “123456”);    // “123456/0”放在常量区，编译器可能会将它与p3所指向的

   // “123456”优化成一个地方

}

 

l         堆和栈的理论知识

1.       申请方式

statck：由系统自动分配。例如，声明在函数中一个局部变量int b，系统自动在栈中为b开辟空间。

heap：需要程序员自己申请，并指明大小。如p1=(char *)malloc(10)或p2=(char *)new(10)。但是注意，p1、p2本身是在栈中的。

 

2.       申请后系统的响应

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

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

 

3.       申请大小的限制

栈：在Windows下，栈是向低地址扩展的数据结构，是一块连续的内存区域。这句话的意思是栈顶的地址和栈的最大容量是系统预先设定好的，如果申请的空间超过栈的剩余空间时，将提示overflow，因此能从栈获得的空间一般比较小。

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

 

4.       申请效率的比较

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

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

另外，在Windows下，最好的方式是用VirtualAlloc分配内存，他不是在堆上，也不是在栈上，而是直接在进程的地址空间中保留一块内存，虽然用起来最不方便，但是速度快，最灵活。

 

5.       堆和栈中的存储内容

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

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

 

6.       存取效率的比较

char s1[] = “aaa”;

char *s2 = “bbb”;

aaa是在运行时刻赋值的；bbb是在编译时就确定了的。但是在以后的存取中，在栈上的数组比指针所指向的字符串快。例如：

#include <iostream.h>

void main()

{

  char a = 1;

  char c[] = “123”;

  char *p = “123”;

  a = c[1];

  a = p[1];

  return;

}

对应的汇编代码是：

10: a = c[1];

00401067 8A 4D F1 mov cl,byte ptr [ebp-0Fh]

0040106A 88 4D FC mov byte ptr [ebp-4],cl

11: a = p[1];

0040106D 8B 55 EC mov edx,dword ptr [ebp-14h]

00401070 8A 42 01 mov al,byte ptr [edx+1]

00401073 88 45 FC mov byte ptr [ebp-4],al

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

 

7.       小结

堆和栈的区别可以用如下的比喻来看出：

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

使用堆就像是自己动手做喜欢吃的菜肴，比较麻烦，但是比较符合自己的口味，而且自由度大。

 

l         Windows进程中的内存结构

接触过编程就知道，高级语言可以通过变量名来访问内存中的数据。那么这些变量在内存中是如何存放的呢？程序又是如何使用这些变量呢？

首先，了解一下C的变量是如何在内存中分布的。C有全局变量（global）、局部变量（local）、静态变量（static）、寄存器变量（register）。每种变量都有不同的分配方式。看以下代码段：

#include <stdio.h>

int g1 = 0, g2 = 0, g3 = 0;

int main()

{

   static int s1 = 0, s2 = 0, s3 = 0;

   int v1 = 0, v2 = 0, v3 = 0;

 

   //打印出各个变量的内存地址

printf("0x%08x/n", &v1);         //打印各本地变量的内存地址

printf("0x%08x/n", &v2);

printf("0x%08x/n/n", &v3);

 

printf("0x%08x/n", &g1);         //打印各全局变量的内存地址

printf("0x%08x/n", &g2);

printf("0x%08x/n/n", &g3);

 

printf("0x%08x/n", &s1);         //打印各静态变量的内存地址

printf("0x%08x/n", &s2);

printf("0x%08x/n/n", &s3);

 

return 0;

}

 

执行结果：

0x0012ff78

0x0012ff7c

0x0012ff80

 

0x004068d0

0x004068d4

0x004068d8

 

0x004068dc

0x004068e0

0x004068e4

 

栈和堆是两种不同的动态数据区：栈是一种线性结构，堆是一种链式结构。

进程的每个线程都有自己私有的栈，所以每个线程虽然代码一样，但是局部变量的数据是互不干扰的。

├———————┤低端内存区域

│ …… │

├———————┤

│ 动态数据区 │

├———————┤

│ …… │

├———————┤

│ 代码区 │

├———————┤

│ 静态数据区 │

├———————┤

│ …… │

├———————┤高端内存区域

栈是一个先进后出的数据结构，栈顶地址总是小于等于栈顶基地址。

 

来了解一下函数调用的过程：Windows API的调用规则和ANSI C的函数调用规则是不一样的，前者由被调函数调整栈，后者由调用者调整栈。两者通过__stdcall和__cdecl区分。eg：

#include <stdio.h>

void __stdcall func(int param1, int param2, int param3)

{

  int var1=param1;

  int var2=param2;

  int var3=param3;

 

  // 打印出各个变量的内存地址

  printf("0x%08x/n", &param1);

  printf("0x%08x/n", &param2);

  printf("0x%08x/n/n", &param3);

  printf("0x%08x/n", &var1);

  printf("0x%08x/n", &var2);

  printf("0x%08x/n/n", &var3);

 

  return;

}

 

int main()

{

  func(1,2,3);

  return 0;

}

 

执行结果：

0x0012ff78

0x0012ff7c

0x0012ff80

 

0x0012ff68

0x0012ff6c

0x0012ff70

 

首先，三个参数以从右到左的次序压栈，先param1，再param2，最后param3；然后压入函数的返回地址RET，接着跳转到函数地址接着执行；再将栈顶（ESP）减去为局部变量分配内存的大小，；最后初始化本地变量的内存空间。由于__stdcall调用由被调函数调整栈，所以在函数返回前要恢复栈：先收回局部变量占用的内存，然后取出返回地址，填入EIP寄存器，回收之前压入参数占用的内存，继续执行调用者的代码。如下图：

├———————┤<—函数执行时的栈顶（ESP）、低端内存区域

│ …… │

├———————┤

│ var 1 │

├———————┤

│ var 2 │

├———————┤

│ var 3 │

├———————┤

│ RET │

├———————┤<—“__cdecl”函数返回后的栈顶（ESP）

│ parameter 1 │

├———————┤

│ parameter 2 │

├———————┤

│ parameter 3 │

├———————┤<—“__stdcall”函数返回后的栈顶（ESP）

│ …… │

├———————┤<—栈底（基地址 EBP）、高端内存区域

 

再例如下面的代码：

#include <stdio.h>

#include <string.h>

void __stdcall func()

{

char lpBuff[8]="/0";

strcat(lpBuff,"AAAAAAAAAAA");

return;

}

int main()

{

func();

return 0;

}

 

编译执行后报错：“0x00414141”指令引用的“0x00000000”内存，该内存不能为read。明显是strcat出问题了！“lpBuff”的大小只有8字节，算上‘/0’strcat只能写入7个A，但是程序实际写入了11个A和一个‘/0’。多出来的4个字节正好覆盖了RET所在的内存空间，导致函数返回了一个错误的内存地址，执行了错误的指令。

 

C++还可以使用new关键字来动态分配内存。eg：

#include <stdio.h>

#include <iostream.h>

#include <windows.h>

void func()

{

char *buffer = new char[128];

char bufflocal[128];

static char buffstatic[128];

printf("0x%08x/n", buffer);       // 打印堆中变量的内存地址

printf("0x%08x/n", bufflocal);   // 打印本地变量的内存地址

printf("0x%08x/n", buffstatic);  // 打印静态变量的内存地址

}

void main()

{

func();

return;

}

 

程序执行结果：

0x004107d0

0x0012ff04

0x004068c0

 

可以看出，new分配的内存不在栈中，也不在静态数据区。VC是通过Windows下的堆来实现new的内存动态分配。当进程初始化的时候，系统会自动为进程创建一个默认堆，这个堆默认所占内存的大小为1M。堆对象由系统进行管理，在内存中以链式结构存在。对堆的访问是顺序进行的，同一时刻只能有一个线程访问堆中的数据，当多个线程同时有访问要求时，只能排队等待，这样会造成程序执行效率下降。