c语言堆栈问题

原文：http://blog.jrj.com.cn/4503073217,4648408a.html

c语言堆栈问题 5 

　　C语言程序编译的内存分配： 

　　1.栈区（stack） --编译器自动分配释放，主要存放函数的参数值，局部变量值等； 

　　2.堆区（heap） --由程序员分配释放； 

　　3.全局区或静态区 --存放全局变量和静态变量；程序结束时由系统释放，分为全局初始化区和全局未初始化区； 

　　4.字符常量区 --常量字符串放与此，程序结束时由系统释放； 

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

　　例： //main.c 

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

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

　　void main() 

　　{ 

　　int b; //栈 

　　char s[]="bb"; //栈 

　　char *p2; //栈 

　　char *p3="123"; //其中，“123\0”常量区，p3在栈区 

　　static int c=0; //全局区 

　　p1=(char*)malloc(10); //10个字节区域在堆区 

　　strcpy(p1,"123"); //"123\0"在常量区，编译器 可能 会优化为和p3的指向同一块区域 

　　｝ 

　　一个C程序占用的内存可分为以下几类： 

　　(一) 栈 

　　这是由编译器自动分配和释放的区域。主要存储函数的参数，函数的局部变量等。当一个函数开始执行时，该函数所需的实参，局部变量就推入栈中，该函数执行完毕后，之前进入栈中的参数和变量等也都出栈被释放掉。它的运行方式类似于数据结构中的栈。 

　　(二) 堆 

　　这是由程序员控制分配和释放的区域，在C里，用malloc()函数分配的空间就存在于堆上。在堆上分配的空间不像栈一样在某个函数执行完毕就自动释放，而是一直存在于整个程序的运行期间。当然，如果你不手动释放(free()函数)这些空间，在程序运行结束后系统也会将之自动释放。对于小程序来说可能感觉不到影响的存在，但对于大程序，例如一个大型游戏，就会遇到内存不够用的问题了 

　　(三) 全局区 

　　C里的全局变量和静态变量存储在全局区。它们有点像堆上的空间，也是持续存在于程序的整个运行期间，但不同的是，他们是由编译器自己控制分配和释放的。 

　　(四) 文字常量区 

　　例如char *c = “123456”；则”123456”为文字常量，存放于文字常量区。也由编译器控制分配和释放。 

　　(五) 程序代码区 

　　存放函数体的二进制代码。 

　　2． 例子(一) 

　　int a = 0; //全局区 

　　void main() 

　　{ 

　　int b; //栈 

　　char s[] = "abc"; //s在栈,"abc"在文字常量区 

　　char *p1,*p2; //栈 

　　char *p3 = "123456"; //"123456"在常量区，p3在栈上 

　　static int c =0; //全局区 

　　p1 = (char *)malloc(10); //p1在栈，分配的10字节在堆 

　　p2 = (char *)malloc(20); //p2在栈，分配的20字节在堆 

　　strcpy(p1, "123456"); //"123456"放在常量区 

　　//编译器可能将它与p3所指向的"123456"优化成一个地方。 

　　} 

　　3． 例子(二) 

　　//返回char型指针 

　　char *f() 

　　{ 

　　//s数组存放于栈上 

　　char s[4] = {'1','2','3','0'}; 

　　return s; //返回s数组的地址，但程序运行完s数组就被释放了 

　　} 

　　void main() 

　　{ 

　　char *s; 

　　s = f(); 

　　printf ("%s", s); //打印出来乱码。因为s所指向地址已经没有数据 

　　} 

　　还有就是函数调用时会在栈上有一系列的保留现场及传递参数的操作。 

　　栈的空间  大小 有限定，vc的缺省是2M。栈不够用的情况一般是程序中分配了大量数组和递归函数层次太深。有一点必须知道，当一个函数调用完返回后它会释放该函数中所有的栈空间。栈是由编译器自动管理的，不用你操心。 

　　堆是动态分配内存的，并且你可以分配使用很大的内存。但是用不好会产生内存泄漏。并且频繁地malloc和free会产生内存碎片（有点类似磁盘碎片），因为C分配动态内存时是寻找匹配的内存的。而用栈则不会产生碎片，在栈上存取数据比通过指针在堆上存取数据快些。一般大家说的堆栈和栈是一样的，就是栈(stack)，而说堆时才是堆heap.栈是先入后出的，一般是由高地址向低地址生长。 

　　堆(heap)和栈(stack)是C/C++编程不可避免会碰到的两个基本概念。首先，这两个概念都可以在讲数据结构的书中找到，他们都是基本的数据结构，虽然栈更为简单一些。在具体的C/C++编程框架中，这两个概念并不是并行的。对底层机器代码的研究可以揭示，栈是机器系统提供的数据结构，而堆则是C/C++函数库提供的。具体地说，现代计算机(串行执行机制)，都直接在代码底层支持栈的数据结构。这体现在，有专门的寄存器指向栈所在的地址，有专门的机器指令完成数据入栈出栈的操作。种机制的特点是效率高，支持的数据有限，一般是整数，指针，浮点数等系统直接支持的数据类型，并不直接支持其他的数据结构。因为栈的这种特点，对栈的使用在程序中是非常频繁的。对子程序的调用就是直接利用栈完成的。机器的call指令里隐含了把返回地址推入栈，然后跳转至子程序地址的操作，而子程序中的ret指令则隐含从堆栈中弹出返回地址并跳转之的操作。C/C++中的自动变量是直接利栈的例子，这也就是为什么当函数返回时，该函数的自动变量自动失效的原因。 

　　和栈不同，堆的数据结构并不是由系统(无论是机器系统还是操作系统)支持的，而是由函数库提供的。基本的malloc/realloc/free函数维护了一套内部的堆数据结构。当程序使用这些函数去获得新的内存空间时，这套函数首先试图从内部堆中寻找可用的内存空间，如果没有可以使用的内存空间，则试图利用系统调用来动态增加程序数据段的内存  大小 ，新分配得到的空间首先被组织进内部堆中去，然后再以适当的形式返回给调用者。当程序释放分配的内存空间时，这片内存空间被返回内部堆结构中，可能会被适当的处理(比如和其他空闲空间合并成更大的空闲空间)，以更适合下一次内存分配申请。这套复杂的分配机制实际上相当于一个内存分配的缓冲池(Cache)，使用这套机制有如下若干原因： 

　　1. 系统调用可能不支持任意  大小 的内存分配。有些系统的系统调用只支持固定  大小 及其倍数的内存请求(按页分配)；这样的话对于大量的小内存分类来说会造成浪费。 

　　2. 系统调用申请内存可能是代价昂贵的。系统调用可能涉及用户态和核心态的转换。 

　　3. 没有管理的内存分配在大量复杂内存的分配释放操作下很容易造成内存碎片 

　　堆和栈的对比 

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

　　引言：对于指针，正确的分配动态内存是十分重要的，本文将着重阐述动态内存分配函数malloc,calloc,realloc以及memset的用法。 

　　　　一、对于malloc,在终端输入 #:man malloc可以知道函数原型是： 

　　　　Void *calloc(size_t size) ,包含在库函数 stdlib.h中，作用是在内存的堆区分配一个  大小 为size的连续空间，如果分配内存成功，函数返回新分配内存的首地址，否则，返回NULL，注意：鉴于上述这点，一般在写程序需要判断分配内存是否成功，如下程序语句： 

　　　　int *p; 

　　　　p=(int *)malloc(sizeof(int)); 

　　　　if(p!=NULL) 

　　　　.................................//需要执行的语句 

　　　　else 

　　　　.........................//打印分配内存不成功出错信息 

　　　　通常造成内存分配失败的原因如下： 

　　　　1、 内存访问越界 

　　　　2、 所需连续的内存空间不足 

　　　　二、对于函数calloc用法大致与malloc相同，函数原型为： 

　　void *callo(size_t num,size_t size),作用是在内存中分配连续  大小 为num*size的空间，这一点在动态数组内存分配有所体现，返回值以及判断返回是否成功与上面相同，下面重点来讨论malloc与calloc区别： 

　　（2）calloc函数 

　　函数原型：void *calloc(unsigned n,unsigned size) 

　　功能：在内存的动态存储区中分配n个长度为size字节的连续空间。返回值为所分配存储区的起始地址，分配不成功则返回NULL。 

　　例如：char *p; 

　　p=(char *)calloc(2,20); 

　　【说明】表示分配2块  大小 为20个字节的连续存储空间并进行强制类型转换，p代表首地址。 

　　【注意】与malloc函数相比，calloc函数可以一次分配n块区域。？？？？？？ 

　　　　1、后者在返回指向内存的指针之前把它初始化为0。 

　　　　2、请求内存数量的方式不同。malloc的参数仅仅是需要分配的内存字节数；calloc的参数包括元素的数量和每个元素的字节数。 

　　　　为了说明第一点,请看如下程序： 

　　　　程序在第6行动态为指针p动态分配了内存, 经过gcc编译，运行结果如下： 

　　注意：6593第一行数据 

　　　　由图可以看出红色标记部分，并没有初始化为零，也就是说在这个单元存在随机数，这样程序在运行时可能会出错。将上面的程序用calloc来调用，程序如下： 

　　　　见上述程序第6行，用calloc来代替malloc分配内存单元，运行结果如下： 

　　注意：全为0 

　　　　可以看出在用calloc申请内存时将内存都初始化为0了。那么有没有用办法用malloc同时又将内存初始化为0呢？答案是有的，用memset可以实现这一功能将第一个程序做相应改动，程序如下： 

　　　　在第七行添加了语句注意：正确的应该是 

　　memset（p,0,100*sizeof(int)）,这条语句的意思是在内存单元p所指向的100个内存单元都赋值为0，相当与初始化内存。此时在运行此程序将不会再出现形如上述红色标记部分的结果。注意：当是0或-1是，输出结果是0和-1，其他得数输出时和自己给的值不一样，如1时输出16843009？？？？？？？？ 

　　　　三、对于realloc（），函数原型是*void realloc(void *ptr,size_t size),改变ptr所指内存区域的  大小 为size长度,如果重新分配成功则返回指向被分配内存的指针，否则返回空指针NULL。当内存不再使用时，应使用free()函数将内存块释放。有一点需要注意：当分配内存成功之后，应将原本的指针ptr=NULL,否则会形成野指针，可能造成系统崩溃。 

　　提示：不论是以上那种方式申请内存，在申请内存之后，最终都要用free释放空间，不然会造成内存泄漏。 

　　memest原型 (please type "man memset" in your shell) 

　　void *memset(void *s, int c, size_t n); 

　　memset:作用是在一段内存块中填充某个给定的值，它对较大的结构体或数组进行清零操作的一种最快方法。 

　　常见的三种错误 

　　第一: 搞反了c 和 n的位置. 

　　一定要记住 如果要把一个char a[20]清零, 一定是 memset(a, 0, 20) 

　　而不是 memset(a, 20, 0) 

　　第二: 过度使用memset, 我想这些程序员可能有某种心理阴影, 他们惧怕未经初始化的内存, 所以他们会写出这样的代码: 

　　char buffer[20]; 

　　memset(buffer, 0, sizeof((char)*20)); 

　　strcpy(buffer, "123"); 

　　这里的memset是多余的. 因为这块内存马上就被覆盖了, 清零没有意义. 

　　第三: 其实这个错误严格来讲不能算用错memset, 但是它经常在使用memset的场合出现 

　　int some_func(struct something *a){ 

　　… 

　　… 

　　memset(a, 0, sizeof(a)); 

　　… 

　　} 

　　问:为何要用memset置零?memset( &Address, 0, sizeof(Address))；经常看到这样的用法，其实不用的话，分配数据的时候，剩余的空间也会置零的。 

　　答:1.如果不清空，可能会在测试当中出现野值。 你做下面的试验看看结果() 

　　char buf[5]； 

　　CString str,str1； //memset(buf,0,sizeof(buf))； for(int i = 0；i<5；i++) { str.Format(“%d “,buf)； str1 +=str ； } TRACE(“%s\r\n“,str1) 

　　2.其实不然！特别是对于字符指针类型的，剩余的部分通常是不会为0的，不妨作一个试验，定义一个字符数组，并输入一串字符，如果不用memset实现清零，使用MessageBox显示出来就会有乱码（0表示NULL，如果有，就默认字符结束，不会输出后面的乱码） 

　　问: 

　　如下demo是可以的，能把数组中的元素值都设置成字符1， 

　　#include <iostream> 

　　#include <cstring> 

　　using namespace std; 

　　int main() 

　　{ 

　　char a[5]; 

　　memset(a,'1',5); 

　　for(int i = 0;i < 5;i++) 

　　cout<<a<<" "; 

　　system("pause"); 

　　return 0; 

　　} 

　　而，如下程序想吧数组中的元素值设置成1，却是不可行的 

　　#include <iostream> 

　　#include <cstring> 

　　using namespace std; 

　　int main() 

　　{ 

　　int a[5]; 

　　memset(a,1,5);//这里改成memset(a,1,5 *sizeof(int))也是不可以的 

　　for(int i = 0;i < 5;i++) 

　　cout<<a<<" "; 

　　system("pause"); 

　　return 0; 

　　} 

　　问题是： 

　　1，第一个程序为什么可以，而第二个不行， 

　　2，不想要用for，或是while循环来初始化int a[5];能做到吗？（有没有一个像memset（）这样的函数初始化） 

　　答: 

　　1.因为第一个程序的数组a是字符型的，字符型占据内存  大小 是1Byte，而memset函数也是以字节为单位进行赋值的，所以你输出没有问题。而第二个程序a是整型的，使用memset还是按字节赋值，这样赋值完以后，每个数组元素的值实际上是0x01010101即十进制的16843009。你看看你输出结果是否这样？ 

　　2.如果用memset(a,1,20); 

　　就是对a指向的内存的20个字节进行赋值，每个都用ASCII为1的字符去填充，转为二进制后，1就是00000001,占一个字节。一个INT元素是4字节，合一起就是1000000010000000100000001，就等于16843009，就完成了对一个INT元素的 

　　realloc 

　　原型：extern void *realloc(void *mem_address, unsigned int newsize); 

　　功能：改变mem_address所指内存区域的  大小 为newsize长度。 

　　说明：如果重新分配成功则返回指向被分配内存的指针，否则返回空指针NULL。 

　　当内存不再使用时，应使用free()函数将内存块释放。 

　　注意：这里原始内存中的数据还是保持不变的。 

　　举例： 

　　// realloc.c 

　　#include <syslib.h> 

　　#include <alloc.h> 

　　main() 

　　{ 

　　char *p; 

　　clrscr(); // clear screen 

　　p=(char *)malloc(100); 

　　if(p) 

　　printf("Memory Allocated at: %x",p); 

　　else 

　　printf("Not Enough Memory!\n"); 

　　getchar(); 

　　p=(char *)realloc(p,256); 

　　if(p) 

　　printf("Memory Reallocated at: %x",p); 

　　else 

　　printf("Not Enough Memory!\n"); 

　　free(p); 

　　getchar(); 

　　return 0; 

　　} 

　　详细说明及注意要点： 

　　1、如果有足够空间用于扩大mem_address指向的内存块，则分配额外内存，并返回mem_address 

　　这里说的是“扩大”，我们知道，realloc是从堆上分配内存的，当扩大一块内存空间时， realloc()试图直接从堆上现存的数据后面的那些字节中获得附加的字节，如果能够满足，自然天下太平。也就是说，如果原先的内存  大小 后面还有足够的空闲空间用来分配，加上原来的空间  大小 ＝ newsize。那么就ok。得到的是一块连续的内存。 

　　2、如果原先的内存  大小 后面没有足够的空闲空间用来分配，那么从堆中另外找一块newsize  大小 的内存。 

　　并把原来  大小 内存空间中的内容复制到newsize中。返回新的mem_address指针。（数据被移动了）。 

　　老块被放回堆上。 

　　例如： 

　　#include <malloc.h> 

　　char *p，*q; 

　　p = (char * ) malloc (10); 

　　q=p; 

　　p = (char * ) realloc (p,20); 

　　………………………… 

　　这段程序也许在编译器中没有办法通过，因为编译器可能会为我们消除一些隐患！在这里我们只是增加了一个记录原来内存地址的指针q，然后记录了原来的内存地址p，如果不幸的话，数据发生了移动，那么所记录的原来的内存地址q所指向的内存空间实际上已经放回到堆上了!这样一来，我们应该终于意识到问题的所在和可怕了吧！ 

　　3、返回情况 

　　返回的是一个void类型的指针，调用成功。（这就再你需要的时候进行强制类型转换） 

　　返回NULL，当需要扩展的  大小 （第二个参数）为0并且第一个参数不为NULL，此时原内存变成了“freed（游离）”的了。 

　　返回NULL，当没有足够的空间可供扩展的时候，此时，原内存空间的  大小 维持不变。 

　　4、特殊情况 

　　如果mem_address为null，则realloc()和malloc()类似。分配一个newsize的内存块，返回一个指向该内存块的指针。 

　　如果newsize  大小 为0，那么释放mem_address指向的内存，并返回null。 

　　如果没有足够可用的内存用来完成重新分配（扩大原来的内存块或者分配新的内存块），则返回null.而原来的内存块保持不变。