C/C++编译的程序占用的内存情况详细解析

你的名字 2022-08-08 11:47 20阅读 0赞

# [C/C++编译的程序占用的内存情况详细解析][C_C] #

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

1、栈区（stack）— **由[编译器][Link 1]自动分配释放 ，存放[函数][Link 2]的参数值，[局部变量][Link 3]的值等**。其操作方式类似于数据结构中的栈。  
 堆(heap)：由malloc,new等分配的空间的地址,地址由低向高增长（程序员释放）。

2、堆区（heap） — **一般由程序员分配释放， 若程序员不释放，程序结束时可能由OS回收**。注意它与数据结构中的堆是两回事，分配方式倒是类似于[链表][Link 4]。  
 栈(stack)：是自动分配变量,以及函数调用所使用的一些空间(所谓的局部变量),地址由高向低减少;

3、全局区（静态区）（static）— 全局变量和[静态变量][Link 5]的存储是放在一块的，**初始化的[全局变量][Link 6]和静态变量在一块区域， 未初始化的全局变量和未初始化的静态变量在相邻的另一块区域。程序结束后由系统释放**。-->分别是data区，bbs区

4、文字常量区 — 常量字符串就是放在这里的，程序结束后由系统释放 。-->coment区

5、程序代码区 — 存放函数体的二进制代码。-->code区

二、例子程序   
这是一个前辈写的，非常详细   
//main.cpp   
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);  
**分配** 得来得10和20字节的区域就在堆区。  
strcpy(p1, "123456"); 123456\\0放在常量区，编译器可能会将它与p3所指向的"123456"优化成一个地方。  
\}

在函数体中定义的变量通常是在栈上，用malloc, calloc, realloc等分配内存的函数分配得到的就是在堆上。在所有函数体外定义的是全局量，加了static修饰符后不管在哪里都存放在全局区（静态区）,在所有函数体外定义的static变量表示在该文件中有效，不能extern到别的文件用，在函数体内定义的static表示只在该函数体内有效。另外，函数中的 "adgfdf "这样的字符串存放在常量区。

还有就是函数调用时会在栈上有一系列的保留现场及传递参数的操作。栈的空间大小有限定，vc的缺省是2M。栈不够用的情况一般是程序中分配了大量数组和递归函数层次太深。有一点必须知道，当一个函数调用完返回后它会释放该函数中所有的栈空间。栈是由编译器自动管理的，不用你操心。堆是动态分配内存的，并且你可以分配使用很大的内存。但是用不好会产生内存泄漏。并且频繁地malloc和free会产生内存碎片（有点类似磁盘碎片），因为**c分配动态内存时是寻找匹配的内存的。而用栈则不会产生碎片。在栈上存取数据比通过指针在堆上存取数据快些**

**堆(heap)和栈(stack)是C/C++编程不可避免会碰到的两个基本概念。首先，这两个概念都可以在讲数据结构的书中找到，他们都是基本的数据结构，虽然栈更为简单一些。在具体的C/C++编程框架中，这两个概念并不是并行的。对底层机器代码的研究可以揭示，栈是机器系统提供的数据结构，而堆则是C/C++函数库提供的。具体地说，现代计算机(串行执行机制)，都直接在代码底层支持栈的数据结构。这体现在，有专门的寄存器指向栈所在的地址，有专门的机器指令完成数据入栈出栈的操作。这种机制的特点是效率高，支持的数据有限，一般是整数，指针，浮点数等系统直接支持的数据类型，并不直接支持其他的数据结构。因为栈的这种特点，对栈的使用在程序中是非常频繁的。对子程序的调用就是直接利用栈完成的。机器的call指令里隐含了把返回地址推入栈，然后跳转至子程序地址的操作，而子程序中的ret指令则隐含从堆栈中弹出返回地址并跳转之的操作。C/C++中的自动变量是直接利用栈的例子，这也就是为什么当函数返回时，该函数的自动变量自动失效的原因。  
  
和栈不同，堆的数据结构并不是由系统(无论是机器系统还是操作系统)支持的，而是由函数库提供的。基本的malloc/realloc/free函数维护了一套内部的堆数据结构。当程序使用这些函数去获得新的内存空间时，这套函数首先试图从内部堆中寻找可用的内存空间，如果没有可以使用的内存空间，则试图利用系统调用来动态增加程序数据段的内存大小，新分配得到的空间首先被组织进内部堆中去，然后再以适当的形式返回给调用者。当程序释放分配的内存空间时，这片内存空间被返回内部堆结构中，可能会被适当的处理(比如和其他空闲空间合并成更大的空闲空间)，以更适合下一次内存分配申请。这套复杂的分配机制实际上相当于一个内存分配的缓冲池(Cache)，使用这套机制有如下若干原因：  
1. 系统调用可能不支持任意大小的内存分配。有些系统的系统调用只支持固定大小及其倍数的内存请求(按页分配)；这样的话对于大量的小内存分类来说会造成浪费。  
2. 系统调用申请内存可能是代价昂贵的。系统调用可能涉及用户态和核心态的转换。   
3. 没有管理的内存分配在大量复杂内存的分配释放操作下很容易造成内存碎片。**

三、堆和栈的理论知识   
2.1申请 方式   
stack:   
由系统自动**分配** 。 例如，声明在函数中一个局部变量 int b; 系统自动在栈中为b开辟空间

heap:   
需要程序员自己申请，并指明大小，在c中malloc函数   
如p1 = (char \*)malloc(10);   
在**C++** 中用new运算符   
如p2 = (char \*)malloc(10);   
但是注意 p1、p2本身是在栈中的。   
2.2   
申请后系统的响应   
栈：只要栈的剩余空间大于所申请空间，系统将为程序提供**内存** ，否则将报异常提示栈溢出。  
堆：首先应该知道操作系统有一个记录空闲**内存** 地址的链表，当系统 收到程序的申请时，会遍历该链表，寻找第一个空间大于所申请空间的堆结点，然后将该结点从空闲结点链表中删除，并将该结点的空间**分配** 给程序，另外，对于大多数系统，**会在这块内存 空间中的首地址处记录 本次分配 的大小**，这样，代码中的delete语句才能正确的释放本**内存** 空间。另外，由于找到的堆结点的大小不一定正好等于申请的大小，系统会自动的将多余的那部分重新放入空闲链表 中。  
2.3申请大小的限制   
**栈：在Windows下,栈是向低地址扩展的数据结构，是一块连续的内存 的区域**。这句话的意思是栈顶的地址和栈的最大容量是系统预先规定好的，在WINDOWS下，栈的大小是 2M（也有的说是1M，总之是**一个编译时就确定的常数**），如果申请的空间超过栈的剩余空间时，将提示overflow。因此，能从栈获得的空间较小。  
**堆：堆是向高地址扩展的数据结构，是不连续的内存区域。**这是由于**系统是用链表来存储的空闲内存地址的，自然是不连续的，而链表的遍历方向是由低地址向高地址。堆的大小受限于计算机系统中有效的虚拟内存 。由此可见，堆获得的空间比较灵活，也比较大。**  
2.4申请效率的比较：   
栈由系统自动**分配** ，速度较快。但程序员是无法控制的。  
堆是由 new**分配** 的**内存** ，一般速度比较慢，而且容易产生**内存** 碎片,不过用起来最方便.  
另外，在 WINDOWS下，最好的方式是用VirtualAlloc**分配 内存** ，他不是在堆，也不是在栈是直接在进程的地址空间中保留一快**内存** ，虽然用起来最不方便。但是速度快，也最灵活。  
2.5堆和栈中的存储内容   
栈： 在函数调用时，第一个进栈的是主函数中后的下一条指令（函数调用语句的下一条可执行语句）的地址，然后是函数的各个参数，在大多数的C编译器中，参数是由 右往左入栈的，然后是函数中的局部变量。**注意静态变量是不入栈的。**  
当本次函数 调用结束后，**局部变量先出栈，然后是参数，最后栈顶指针 指向最开始存的地址**，也就是主函 数中的下一条指令，程序由该点继续运行。  
**堆：一般是在 堆的头部用一个字节存放堆的大小。**堆中的具体内容有程序员安排。  
2.6存取 效率的比较   
char s1\[\] = "aaaaaaaaaaaaaaa";   
char \*s2 = "bbbbbbbbbbbbbbbbb";   
aaaaaaaaaaa 是在运行时刻赋值的；   
而 bbbbbbbbbbb是在编译时就确定的；   
但是，**在以后 的存取中，在栈上的数组 比指针 所指向的字符 串(例如堆)快。**  
比如：   
＃i nclude   
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 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读取**字符** ， 显然慢了。  
2.7小结：   
堆和栈的区别可以用如下的比喻来看出：   
**使用栈就象我们去饭馆里吃饭，只管点菜（发出申请）、付钱、和吃（使 用），吃饱了就走，不必理会切菜、洗菜等准备工作和洗碗、刷锅等扫尾工作，他的好处是快捷，但自由度小。  
使用堆就象是自己动手做喜欢吃的菜肴，比较麻烦，但是比较符合自己的 口味，而且自由度大。**

2.8 对比

从以上知识可知，**栈是系统提供的功能，特点是快速高效，缺点是有限制，数据不灵活；而栈是函数库提供的功能，特点是灵活方便，数据适应面广泛，但是效率有一定降低。**栈是系统数据结构，对于进程/线程是唯一的；堆是函数库内部数据结构，不一定唯一。不同堆分的内存无法互相操作。栈空间分静态分配和动态分配两种。静态分配是编译器完成的，比如自动变量(auto)的分配。动态分配由alloca函数完成。栈的动态分配无需释放(是自动)，也就没有释放函数。为可移植的程序起见，栈的动态分配操作是不被鼓励的！堆空间的分配总是动态的，虽然程序结束时所有的数据空间都会被释放回系统，但是精确的申请内存/释放内存匹配是良好程序的基本要素。

操作系统方面的堆和栈，如上面说的那些，不多说了。还有就是数据结构方面的堆和栈，这些都是不同的概念。这里的堆实际上指的就是（满足堆性质的）优先队列的一种数据结构，第1个元素有最高的优先权；栈实际上就是满足先进后出的性质的数学或数据结构。虽然堆栈，堆栈的说法是连起来叫，但是他们还是有很大区别的，连着叫只是由于历史的原因。

**堆和栈的生长方向恰好相反**，  
|--------------| 低地址   
| 堆 |   
|--------------|   
| | |   
| I |   
| |   
| ^ |   
| 栈 | 高地址   
\-----------------   
所以计算机中的堆和栈经常时放一块讲的   
  
一般不是必要就不要动态创建，最讨厌把new出来的东西当局部变量用，用万了马上delete 的做法.   
理由   
**1.栈分配比堆快，只需要一条指令就呢给配所有的局部变量   
2.栈不会出现内存碎片   
3.栈对象好管理**   
  
当然，某些情况下也要那么写,比如   
1.对象很大   
2.对象需要在某个特定的时刻构造或析够   
3.类只允许对象动态创建,比如VCL的大多数类   
当然，必须用堆对象时也不能躲避

堆内存和栈内存各有什么作用？**堆：顺序随意 栈：先进后出**

\----------------------------------------------------------------------------------------------------------------------  
为什么说在堆上**分配 内存** 比在栈上**分配 内存** 慢？堆空间的开辟需要用系统函数，栈上直接修改**指针**  
堆空间的**管理**需 要系统记帐，栈上的空间可以由编译器管理或是保存在某个处理器寄存器中。   
堆空间的释放需要系统管理，栈上的释放可以直接丢弃。堆空间需要通过栈上的**指针** 间接引用，所以访问会慢  
记得在apue2上面看到关于线程中有这样一段话,大致意思是,一个 线程有自己的堆栈,可以在堆栈上**分配 内存** ,比如说一个结构体,如果这个线程调用了pthread\_exit()返回这个结构体**指针** 的时候之后要特别的小心,因为很有可能这个结构体里面的成员值发生改变,这个可以理解,因为同一个进程所 有线程的资源是共享的,当这个线程退出之后那部分以前用过的堆栈很可能被其它线程占用,但同时又说如果malloc就不会出现这样的问题,  
比如，在栈上分一个int，只要esp-4就可以了，   
在堆上系统要记录被**分配 内存** 的信息，以便释放   
－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－   
**内存 分配** 方式有三种：   
  
 1.从静态存储区域**分配** 。**内存** 在程序编译的时候就已经**分配** 好，这块**内存** 在程序的整个运行期间都存在。例如全局变 量，static变量。   
  
 2.在栈上创建。在执行函数时，函数内局部变量的存储**单元** 都可以在栈上创建，函数执行结束时这些存储**单元** 自动被 释放。栈**内存 分配** 运算内置于处理器的指令集中，效率很 高，但是**分配** 的**内存** 容量有限。   
  
 3.从堆上**分配** ，亦称动态**内存 分配** 。程序在运行的时候用malloc或new申请任意多少的**内存** ，程 序员自己负责在何时用free或delete释放**内存** 。动态**内存** 的生存期由我们决定，使用非常灵活，但问题也最多。  
－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－   
一般所说的堆栈（stack)往往是指栈，先进后出， 它是一块**内存** 区。用以存放程序的局部变量，临时变量，函数的参数，返回地址等。在这块区域中的变量的**分配** 和释放由系统自动进行。不需要用户的参与。   
 而在堆(heap,先进先出) 上的空间则是由用户进行**分配** ，并由用 户负责释放。  
===================================================================================

[C_C]: http://blog.csdn.net/ghevinn/article/details/8484750
[Link 1]: http://baike.baidu.com/view/487018.htm
[Link 2]: http://baike.baidu.com/view/15061.htm
[Link 3]: http://baike.baidu.com/view/552847.htm
[Link 4]: http://baike.baidu.com/view/549479.htm
[Link 5]: http://baike.baidu.com/view/675642.htm
[Link 6]: http://baike.baidu.com/view/261041.htm