五大内存分区

在看小甲鱼的C教学视频的时候，有这样一个程序。

[cpp]  view plain  copy

 print ?

1. #include <stdio.h>  
2. void  main()  
3. {  
4.       void copy_string( char *from, char *to );  
5.   
6.       char *a = "I am a teacher.";  
7.       char *b = "You are a student.";  
8.         
9.       printf("String a = %s\nString b = %s\n", a, b);  
10.       printf("copy string a to string b:\n");  
11.   
12.       copy_string(a, b);  
13.    
14.       printf("\nString a = %s\nString b = %s\n", a, b);  
15. }  
16.   
17. void  copy_string( char *from, char *to )  
18. {  
19.       for( ; *from != '\0'; from++,to++)  
20.       {  
21.             *to = *from;  
22.       }  
23.       *to = '\0';  
24. }  

目的是拷贝一个字符串，编译链接没有报错。但是在最后运行程序的时候出错了。

在程序中是使用指针存放字符串的。

进行调试的时候，出现下面的报错:

在小甲鱼老湿的提示下，查找了有关C/C++五大分区的知识

链接：

http://blog.163.com/timswing@126/blog/static/29887062200742641225586/

下面直接贴内容

   在C++中，内存分成5个区，他们分别是堆、栈、自由存储区、全局/静态存储区和常量存储区。

    栈，就是那些由编译器在需要的时候分配，在不需要的时候自动清楚的变量的存储区。里面的变量通常是局部变量、函数参数等。 

    堆，就是那些由new分配的内存块，他们的释放编译器不去管，由我们的应用程序去控制，一般一个new就要对应一个delete。如果程序员没有释放掉，那么在程序结束后，操作系统会自动回收。 

    自由存储区，就是那些由malloc等分配的内存块，他和堆是十分相似的，不过它是用free来结束自己的生命的。 

    全局/静态存储区，全局变量和静态变量被分配到同一块内存中，在以前的C语言中，全局变量又分为初始化的和未初始化的，在C++里面没有这个区分了，他们共同占用同一块内存区。 

    常量存储区，这是一块比较特殊的存储区，他们里面存放的是常量，不允许修改

一般认为在c中分为这几个存储区： 

    1. 栈 －－有编译器自动分配释放 

    2. 堆 －－ 一般由程序员分配释放，若程序员不释放，程序结束时可能由OS回收 

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

    4. 另外还有一个专门放常量的地方。程序结束释放 

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

比如： 

代码: 

[cpp]  view plain  copy

 print ?

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

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

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

    堆是动态分配内存的，并且你可以分配使用很大的内存。但是用不好会产生内存泄漏。并且频繁地malloc和free会产生内存碎片（有点类似磁盘碎片），因为c分配动态内存时是寻找匹配的内存的。而用栈则不会产生碎片。 

    在栈上存取数据比通过指针在堆上存取数据快些。 

一般大家说的堆栈和栈是一样的，就是栈(stack)，而说堆时才是堆heap. 栈是先入后出的，一般是由高地址向低地址生长。

再看之前的代码

[cpp]  view plain  copy

 print ?

1. #include <stdio.h>  
2.   
3. void  main()  
4. {  
5.       void copy_string( char *from, char *to );  
6.   
7.       char *a = "I am a teacher.";  
8.       char *b = "You are a student.";  
9.         
10.       printf("String a = %s\nString b = %s\n", a, b);  
11.       printf("copy string a to string b:\n");  
12.   
13.       copy_string(a, b);  
14.    
15.       printf("\nString a = %s\nString b = %s\n", a, b);  
16. }  
17.   
18. void  copy_string( char *from, char *to )  
19. {  
20.       for( ; *from != '\0'; from++,to++)  
21.       {  
22.             *to = *from;  
23.       }  
24.   
25.       *to = '\0';  
26. }  

程序中的”You are a student.”字符串在常量区，而使用指针存放字符串，b中只是存放了字符串在常量区中的地址，当调用copy_string函数的时候又引用了b这个参数，即试图将字符串”I am a teacher.”写入常量区。而常量区的这段内存是不可写的，所以在运行的时候出现了报错。

对这段代码的改进只许把b改为用数组来存放字符串（对a不必修改，因为程序中没有执行对a写入的操作）。

char *b = "You are a student.";

改为

char b[] = "You are a student.";