和菜鸟一起学c之函数中堆栈及运行内存情况

       总是听说编译的时候什么堆啊，栈啊之类的。以前学数据结构的时候用过，栈比较常用，像搜索类的算法题都是要用到栈的。还有表达式计算也是。至于堆的话，排序的时候用的比较多。关于这方面，网上已经讲了很多了，下面把我看到比较好的，总结下。

       一般我们编译的C代码中在内存中分下面几个区：

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

　　2、堆区（heap）：一般由程序员分配释放， 若程序员不释放，程序结束时可能由OS回收 。注意它与数据结构中的堆是两回事，分配方式倒是类似于链表。比如malloc, free。

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

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

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

 

还是看个例子，加深下印象吧：

    int a = 0;                               //全局初始化区
　　char*p1;                                 //全局未初始化区
　　int 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);          //堆
　　       return 0；
}

 

堆和栈的理论知识如下：

1.申请方式

　　stack:

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

　　heap:

　　需要程序员自己申请，并指明大小，在c中malloc函数

　　如p1 = (char*)malloc(10);

　　在C++中用new运算符

　　如p2 = newchar[20];//(char *)malloc(10);

　　但是注意p1、p2本身是在栈中的。

　　2.申请后系统的响应

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

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

　　3.申请大小的限制

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

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

　　4.申请效率的比较

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

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

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

　　5.堆和栈中的存储内容

　　栈： 在函数调用时，第一个进栈的是主函数中函数调用后的下一条指令（函数调用语句的下一条可执行语句）的地址，然后是函数的各个参数，在大多数的C编译器中，参数是由右往左入栈的，然后是函数中的局部变量。注意静态变量是不入栈的。

　　当本次函数调用结束后，局部变量先出栈，然后是参数，最后栈顶指针指向最开始存的地址，也就是主函数中的下一条指令，程序由该点继续运行。

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

　　6.存取效率的比较

　　

　　char s1[] ="aaaaaaaaaaaaaaa";

　　char *s2 ="bbbbbbbbbbbbbbbbb";

　　aaaaaaaaaaa是在运行时刻赋值的；

　　而bbbbbbbbbbb是在编译时就确定的；

　　但是，在以后的存取中，在栈上的数组比指针所指向的字符串(例如堆)快。

　　比如：

　　int main()
　　{
　　       char a = 1;
　　       char c[] = "1234567890";
　　       char *p ="1234567890";
　　       a = c[1];
　　       a = p[1];
　　       return 0;
　　}

　　对应的汇编代码

　

　  10: a =c[1];
　　00401067 8A4D F1 mov cl,byte ptr [ebp-0Fh]
　　0040106A 884D FC mov byte ptr [ebp-4],cl
　　11: a =p[1];
　　0040106D 8B55 EC mov edx,dword ptr [ebp-14h]
　　00401070 8A42 01 mov al,byte ptr [edx+1]
　　00401073 8845 FC mov byte ptr [ebp-4],al

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

7.小结：

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

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

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

 

堆栈是一种存储部件，即数据的写入跟读出不需要提供地址，而是根据写入的顺序决定读出的顺序

 

 

 

一个位于磁盘中的可执行程序是如何被执行的.

 

(1) 程序被执行时, 操作系统将可执行模块拷贝到内存的程序映像(program image)中去.

(2) 正在执行的程序实例被称为进程: 当操作系统向内核数据结构中添加了适当的信息, 并为运行程序代码分配了必要的资源之后, 程序就变成了进程. 这里所说的资源就包括分配给进程的地址空间和至少一个被称为线程(thread)的控制流.上面只是大而化之地介绍了程序是如何转化为进程的, 这里关注的是内存程序映像. 在第(1)步中, 操作系统将可执行模块由硬盘拷贝到内存的程序映像中, 程序映像的一般布局如下:

 

从低地址到高地址依次为下列段:

 

1.代码段（Code or Text）：代码段由程序中的机器码组成。在C语言中，程序语句进行编译后，形成机器代码。在执行程序的过程中，CPU的程序计数器指向代码段的每一条代码，并由处理器依次运行。

2.只读数据段（RO data）：只读数据段是程序使用的一些不会被更改的数据，使用这些数方式类似查表式的操作，由于这些变量不需要更改，因此只需要放置在只读存储器中即可。

3.已初始化读写数据段(RW data)：已初始化数据是在程序中声明，并且具有初值的变量，这些变量需要占用存储器的空间，在程序执行时它们需要位于可读写的内存区域内，并具有初值，以供程序运行时读写。

4.未初始化读写数据段(BSS)：未初始化读写据是在程序中声明，但是没有初始化的变量，这些变量在程序运行之前不需要占用存储器的空间。

5.堆(heap)：堆内存只在程序运行时出现，一般由程序员分配和释放。在具有操作系统的情况下，如果程序员没释放，操作系统可以在程序结束后回收内存。

6.栈(stack)：栈内存只在程序运行时出现，在函数内部使用的变量，函数的参数以及返回值将使用栈空间，栈空间由编译器自动分配和释放。

另外, 在高地址还储存了命令行参数及环境变量。

 

下面看看一个简单的例子吧还是：

const char ro[ ] = {"this is read onlydata"};                  //只读数据区 
static char rw_1[ ] ={"this is globalread write data"};        //已初始化读写数据段 
char BSS_1[ 100];                                              //未初始化数据段 
const char *ptrconst ="constantdata";                          //字符串放在只读取数据段 
int main() 
{ 
      short b;                                                 //在栈上，占用2个字节 
      char a[100];                                             //在栈上开辟100个字节，工的值是其首地址 
      char s[ ]="abcdefg";                                     //s在栈上，占用4个字节 
                                                               //"abcdefg"本身放置在只读数据存储区，占8个字节 
      char *p1;                                                //p1在栈上，占用4个字节               
      char *p2="123456";                                       //p2 在栈上，p2指向的内容不能改， 
                                                               //“123456”在只读数据区      
 
      static char rw_2[ ]={"this is local read write data"};   //局部已初始化读写数据段 
      static char BSS_2[100];                                  //局部未初始化数据段 
      static int c = 0;                                        //全局（静态）初始化区 
       p1=(char *)malloc(10 * sizeof(char ) );                 //分配内存区域在堆区 
       strcpy(p1,"xxxx");                                      //“XXXX”放在只读数据区，占5个字节 
      free(p1);                                                //使用free释放p1所指向的内存 
    
  return 0; 
}
 

基于上面的例子和理论知识，相信对于我们写的代码放在内存的那里，应该一目了然了。