《C语言深度刨析》整理--内存管理

 

一、内存的存储区

1.、栈（堆栈）区、堆区、静态区等

（1）、栈区（堆栈）（stack）：由编译器自动分配释放 ，存放函数参数值，局部变量等。栈上的内容只在函数的范围内存在，当函数运行结束，这些内容也会自动被毁.其特点是：效率高，但空间大小有限

（2）、堆区（heap） ：一般由程序员分配释放 ， 由malloc 系列函数或new 操作符分配的内存。其生命周期由free 或delete 决定。在没有释放之前一直存在，直到程序结束，其特点是：使用灵活，空间比较大，但容易出错

（3）、全局区（静态区）：保存自动全局变量和static 变量（包括static 全局和局部变量），静态区的内容在总个程序的生命周期内都存在，由编译器在编译的时候分配

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

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

 二、c语言内存管理五条原则

     【规则1】用malloc或new申请内存之后，应该立即检查指针值是否为NULL。防止使用指针值为NULL的内存。 

 

（很有可能申请连续一块内存失败）

     

【规则2】不要忘记为数组和动态内存赋初值。防止将未被初始化的内存作为右值使用。 

     【规则3】避免数组或指针的下标越界，特别要当心发生“多1”或者“少1”操作。 

     【规则4】动态内存的申请与释放必须配对，防止内存泄漏。 （比如malloc和free，new和delete）

     【规则5】用free或delete释放了内存之后，立即将指针设置为NULL，防止产生“野指针”。

三、常见的内存错误

       1. 未给指针赋值，指针指向非法的值

       （1）

view plain print ?

1. #include "stdio.h"  
2. #include "string.h"  
3. struct node  
4. {  
5.     char *name;  
6.     int number;  
7. }nNode,*pNode;  
8. int main()  
9. {  
10.     strcpy(nNode.name,"Jimy");  
11.     pNode->number = 99;  
12.     return 0;  
13. }  

         解析：

         错误一：未给结构体申请内存空间，结构体指针pNode 指向非法内存导致程序异常

        错误二：未给结构体中指向char 类型的指针name 分配内存，name指向非法内存导致程序异常

     （2） 比较隐蔽指针未申请内存空间，指针指向非法的内存    

view plain print ?

1.     #include "stdio.h"  
2.     #include "string.h"  
3.     #include "stdlib.h"  
4.   
5.     struct node  
6.     {  
7.         char *name;  
8.         int number;  
9.     }nNode, *pNode;  
10.   
11.     int main()  
12.     {  
13. pNode = (struct node *)malloc(sizeof(struct node));  
14.         strcpy(nNode.name, "Jimy");  
15. pNode->number = 99;  
16.   
17. free(pNode);  
18. return 0;  
19.     }  

         解析：

         表面看来程序为struct node 分配了内存，但是结构体中的指针char *name 未分配内存，指针name 的指向仍然是非法的
  

     2. 没有分配总够的内存 

view plain print ?

1. #include "stdio.h"  
2. #include "string.h"  
3. #include "stdlib.h"  
4.   
5. struct node  
6. {  
7.     char *name;  
8.     int number;  
9. }nNode,*pNode;  
10.   
11. int main()  
12. {  
13.     <span style="color:#3333ff;"><strong>pNode = (struct node *)malloc(sizeof(struct node*));</strong></span>  
14.   
15.     strcpy(nNode.name,"Jimy");  
16.     pNode->number = 99;  
17.   
18.     free(pNode);  
19.     return 0;  
20. }  

    解析：

    （1）. 误将内存申请的大小 由sizeof(struct node)变成 sizeof(struct node *) 只申请了四个字节的内存大

    （2）. 指针那么也未申请内存地址

  3. 为指针分配的内存太小

view plain print ?

1. char *p1 = “abcdefg”;  
2. char *p2 = (char *)malloc(sizeof(char)*strlen(p1));  

view plain print ?

1. strcpy(p2,p1);  

       解析：

       指针p1所占的内存大小是 8，而为p2 申请的内存是 7个

      解决：

      char *p2  =  (char *)malloc(sizeof(char)*strlen(p1) + 1*sizeof(char));  

    4. 内存分配成功，但并未初始化

       （1） 指针的初始化

             初始化为有效的值： char *p = (char *)malloc(sizeof(char));

             初始化为NULL ：       char *p = NULL;

          注：一般第二种比较常用，第二种写法也可以用来debug的时候检测assert调试；

       （2） 数组的初始化

             定义的时候初始化：  int  number[20]  = {0};

             定义后初始化：        memset(a, 0, sizeof(number);

     5. 内存越界

         这种情况比较常见于，访问数组的时候，循环变量控制的越界

        比如：  

view plain print ?

1. int a[10] = {0};  
2. for (i = 0; i <= 10; i++)  
3. {  
4.    a[i] = i;  
5. }  

        解析：

         数组变量越界了。数组循环变量的边界取值的原则一般是从0开始，采用半开半闭的结构，这样程序的可读性强

      6. 指针已经释放但是仍然被其他的代码调用

           通常有三种情况：

          第一种：free（p）之后，继续通过p 指针来访问内存。解决的办法就是给p 置NULL。

          第二种：函数返回栈内存。这是初学者最容易犯的错误。比如在函数内部定义了一个数组，却用return 语句返回指向该数组的指针。         

          第三种：内存使用太复杂，弄不清到底哪块内存被释放，哪块没有被释放。解决的办法是重新设计程序，改善对象之间的调用关系。