第42课 - 内存操作经典问题分析二

1、常见内存错误 

            结构体成员指针未初始化 

            结构体成员指针未分配足够的内存 

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

            内存操作越界 

2、实例分析 

常见内存错误     42-1.c     42-2.c 

42-1.c

1. #include <stdio.h>  
2. #include <malloc.h>  
3.   
4. void test(int* p, int size)  
5. {  
6.     int i = 0;  
7.       
8.     for(i=0; i<size; i++)  
9.     {  
10.         printf("%d\n", p[i]);  
11.     }  
12.       
13.     free(p);  
14. }  
15.   
16. void func(unsigned int size)  
17. {  
18.     int* p = (int*)malloc(size * sizeof(int));  
19.     int i = 0;  
20.       
21.     if( size % 2 != 0 )  
22.     {  
23.         return;   
24.     }  
25.       
26.     for(i=0; i<size; i++)  
27.     {  
28.         p[i] = i;  
29.         printf("%d\n", p[i]);  
30.     }  
31.       
32.     free(p);  
33. }  
34.   
35. int main()  
36. {  
37.     int* p = (int*)malloc(5 * sizeof(int));  
38.       
39.     test(p, 5);  
40.       
41.     free(p);   
42.       
43.     func(9);  
44.     func(10);  
45.          
46.     return 0;  
47. }  

        错误1：在test函数free(p)

        原因：在哪个函数申请的空间，应在那个函数释放

        解决：//test（）中的free（p）

        错误2：在func函数产生内存泄漏

        原因：若size为奇数，直接返回，未释放p

42-2.c

1. #include <stdio.h>  
2. #include <malloc.h>  
3.   
4. struct Demo  
5. {  
6.     char* p;  
7. };  
8.   
9. int main()  
10. {  
11.     struct Demo d1;  
12.     struct Demo d2;  
13.       
14.     char i = 0;  
15.       
16.     for(i='a'; i<'z'; i++)  
17.     {  
18.         d1.p[i] = 0;   
19.     }  
20.       
21.     d2.p = (char*)calloc(5, sizeof(char));  
22.       
23.     printf("%s\n", d2.p);  
24.       
25.     for(i='a'; i<'z'; i++)  
26.     {  
27.         d2.p[i] = i;   
28.     }  
29.       
30.     free(d2.p);  
31.       
32.     return 0;  
33. }  

                    

3、内存操作的交通规则 

            动态内存申请之后，应该立即检查指针 

            值是否为NULL , 防止使用NULL指针。

            

        

        free指针之后必须立即赋值为NULL。 

        

       

         任何与内存操作相关的函数都必须带长度信息。

        

        malloc操作和free操作必须匹配， 防止内存泄露和多次释放。

       

4、小结 

        内存错误的本质源于指针保存的地址为非法值 

                - 指针变量未初始化，保存随机值 

                - 指针运算导致内存越界 

        内存泄漏源于malloc和free不匹配 

            －当malloc次数多于free时，产生内存泄漏 

            －当malloc次数少于free时，程序可能崩溃