realloc引发的惨案

0x55AA

帮别人调试个程序，程序的功能主要涉及动态数组，实现动态数组元素的添加，删除，查找，显示功能。但是在执行添加功能的时候，连续执行三次添加的时候就会出现问题，让人感到非常的莫名其妙。

涉及到的函数如下所示：

1. void adddata(int * arr, int * len)
   
2. {
   
3.         int n;
   
4.         int * add;
   
5.         int cnt =0, t1;
   
6.         printf("please enter the amount of element you want to add;\n");
   
7.         scanf("%d", &n);
   
8.         add = (int *)malloc(sizeof(int) * n);
   
9.         inputdata(add, n); //把用户要添加的数据加入一个新的数组。
   
10.         t1 = *len; //下面循环有用，当用户输入的数都大于任何数的时候用的
    
11.         *len = *len + n ; //重新定义下数组长度，根据用户要扩充的大小。
    
12.         realloc(arr, sizeof(int)*(*len));
    
13.        
    
14.         for (i=0; i<n; ++i)                                                                // i 循环是 循环要添加的数
    
15.         {
    
16.                 for (j=0; j<t1+i; ++j)                                                        // j循环 是循环原数组
    
17.                 {
    
18.                         if ( add[i] < arr[j])
    
19.                         {
    
20.                                 for (k=j; k <= t1+i; ++k)
    
21.                                 {
    
22.                                                 t = arr[k];
    
23.                                                 arr[k] = add[i];
    
24.                                                 add[i] = t;
    
25.                                 }
    
26.                                 cnt = 1;
    
27.                                 break;
    
28.                         }
    
29.                         cnt = 0;
    
30.                 }
    
31.                 if ( 0 == cnt)
    
32.                         arr[t1+i]=add[i];
    
33. 
    
34.         }
    
35.         resultdata(arr, *len);
    
36.         switch_choice (arr, * len);
    
37. }

复制代码

从这里可以看到这段程序的缺点：
<1>全局变量的滥用，不过这里没有造成错误
<2>realloc函数不适用返回值，后面会知道这是罪魁祸首
<3>malloc的add没有在函数结束的时候释放
1 针对函数的缺点，我们一一侦破，先是在函数的结尾加上对add的释放

1. if(add != NULL)
   
2. {
   
3.         free(add);
   
4.         add = NULL;
   
5. }

复制代码

但是第一次释放add就会出现下面的问题，执行调试，发现是在free的时候出现了问题，也就是free竟然失败了。

2 然后再加上对realloc函数的修改

1. void *realloc(void *memblock, size_t size );

复制代码

Realloc函数会针对不同的情况执行不同的行为，如果realloc函数执行成功，那么函数会返回新的内存空间的首地址，并且free掉之前 的内存空间，并且之前的内存内容复制到新的内存中；如果开辟失败，那么之前的内存空间不会被释放，realloc函数返回NULL。所以在增加内存的时候，万万不可使用一直使用原来的全局指针，原因就是它可能已经被free掉，而新的指针指向发生了变化。
同时如果继续使用原来的全局指针，就可能发生数组的越界，越界就会破坏堆，最终连其它的跟操作内存的函数执行都会出现问题。
现在把void adddata(int *arr, int *len)中的realloc函数修改成如下：

1. tmp = (int*)realloc(arr, sizeof(int)*(*len));
   
2. 
   
3. if( tmp != NULL)
   
4. {
   
5.         arr = tmp;
   
6.         tmp = NULL;
   
7. }
   
8. else
   
9. {
   
10.         printf("realloc memory failed\n");
    
11.         exit(1);
    
12. }

复制代码

然后测试，一切OK，这说明了罪魁祸首的确是realloc函数的错误使用，realloc不会保证新内存的首地址还是原来的，它很可能发生变化。

3 针对realloc函数错误调用后，发生数组越界会造成free失败的验证
测试代码如下所示：

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. 
   
4. void main()
   
5. {       
   
6.         int n = 3;
   
7.         int na;
   
8.         int i;
   
9.         int *p2;
   
10.         int *p = (int*)malloc(sizeof(int)*n);
    
11.         int *p3 = ( int*)malloc(sizeof(int)*3 );
    
12.         p3[0] = 11;
    
13.         p3[1] = 22;
    
14.         p3[2] = 33;
    
15.         for(i=0;i<n;i++)
    
16.         {
    
17.                 p[i] = i;
    
18.         }
    
19.         for(i=0;i<n;i++)
    
20.                 printf("%d\n",p[i]);
    
21.         printf("input mount of number to add:");
    
22.         scanf("%d",&na);
    
23.         p2 = (int*)realloc( p,sizeof(int)*(n+na) );
    
24.         for(i=n;i<n+na;i++)
    
25.         {
    
26.                 p2[i] = i;
    
27.         }
    
28.         p[n+na+ 10] = 0;        // out range of p
    
29.         for(i=0;i<n+na;i++)
    
30.                 printf("%d\n",p2[i]);
    
31.         printf("now can see\n");
    
32.         for(i=0;i<n;i++)
    
33.                 printf("%d\n",p[i]);
    
34. 
    
35.         if( p3 != NULL)        //failed because of p's outof range
    
36.         {
    
37.                 free(p3);
    
38.                 p3 = NULL;
    
39.         }
    
40. }

复制代码

执行结果：

这个就说明了一切问题，p的越界造成了无辜的p3跟着遭殃，p3到最后都不能进行释放。

附录（修改后的完整的功能程序）：

1. # include <stdio.h>
   
2. #include <stdlib.h>
   
3. 
   
4. void inputdata( int * arr, int len);
   
5. void arrangeinorder( int * arr, int len);
   
6. void resultdata(int*, int);
   
7. void switch_choice(int * , int );
   
8. void finddata( int * arr, int len);
   
9. void deletedata(int * arr, int * len);
   
10. void adddata(int * arr, int * len);
    
11. 
    
12. int main (void)
    
13. {       
    
14.         int *arr;
    
15.         int len;
    
16.        
    
17.         printf ("enter the amount of data that you will input: ");
    
18.         scanf("%d", &len);
    
19. 
    
20.         arr = (int *) malloc( sizeof(int) * len);
    
21.         inputdata(arr, len);                         //单独测试可用（用来输入数组）
    
22.         arrangeinorder(arr, len);                 // 单独测试可用（把数组进行排序，从小到大）
    
23.         switch_choice (arr, len);
    
24.         free(arr);
    
25. 
    
26.         return 0;
    
27. }
    
28. 
    
29. void inputdata( int * arr, int len)
    
30. {
    
31.         int i;
    
32.         printf("please enter your data ;\n");
    
33.         for (i=0; i<len; ++i)
    
34.         {
    
35.                 printf("%d-->  ", i+1);
    
36.                 scanf("%d", &arr[i]);
    
37.         }
    
38. }
    
39. 
    
40. void arrangeinorder( int * arr, int len)
    
41. {
    
42.         int i,j,t;
    
43.         for (i=0; i<len; ++i)
    
44.         {
    
45.                 for (j=i+1; j<len; ++j)
    
46.                 {
    
47.                         if (arr[i] > arr[j])
    
48.                         {
    
49.                                 t = arr[i];
    
50.                                 arr[i] = arr[j];
    
51.                                 arr[j] = t;
    
52.                         }
    
53.                 }
    
54. 
    
55.         }
    
56.         resultdata(arr, len);
    
57. }
    
58. 
    
59. void finddata( int * arr, int len)
    
60. {
    
61.         int n,i;
    
62.         int t = 0;
    
63.         printf("please enter the number you want to find\n");
    
64.         scanf("%d", &n);
    
65. 
    
66.         for (i=0; i<len; ++i)
    
67.         {
    
68.                 if (n == arr[i])
    
69.                 {
    
70.                         printf ("the number %d, is located in the %d th\n", n,i+1);
    
71.                         t=1;
    
72.                 }
    
73.         }
    
74. 
    
75.         if (t != 1 )
    
76.                 printf("number %d is not in this array.\n", n);
    
77. 
    
78. }
    
79. 
    
80. void deletedata(int * arr, int * len)
    
81. {
    
82.         int n,i,j;
    
83.         int cnt =0;
    
84.         printf("please enter the number you want to delete from this array;\n");
    
85.         scanf ("%d", &n);
    
86. 
    
87.         for (i=0; i<*len; ++i)
    
88.         {
    
89.                 while(n == arr[i])
    
90.                 {
    
91.                         for (j=i; j<*len; ++j)
    
92.                                 arr[j] = arr[j+1];
    
93.                         cnt++;   //to count amount of number had been delete from array.
    
94.                 }
    
95.         }
    
96.         *len = *len - cnt;
    
97.         arr = (int*)realloc(arr, sizeof(int)*(*len));
    
98.         if( arr == NULL )
    
99.         {
    
100.                 printf("realloc memory failed\n");
     
101.                 exit(1);
     
102.         }
     
103. 
     
104.         resultdata(arr, *len);
     
105.         switch_choice (arr, * len);
     
106. }
     
107. 
     
108. void adddata(int * arr, int * len)
     
109. {
     
110.         int n,i,j,k,t1;
     
111.         int *add,*tmp;
     
112.         int cnt =0;
     
113.         int t = 0;
     
114. 
     
115.         printf("please enter the amount of element you want to add;\n");
     
116.         scanf("%d", &n);
     
117. 
     
118.         add = (int *)malloc(sizeof(int) * n);
     
119. 
     
120.         inputdata(add, n); //把用户要添加的数据加入一个新的数组。
     
121.         t1 = *len; //下面循环有用，当用户输入的数都大于任何数的时候用的
     
122. 
     
123.         *len = *len + n ; //重新定义下数组长度，根据用户要扩充的大小。
     
124.         //realloc(arr, sizeof(int)*(*len));
     
125.         tmp = (int*)realloc(arr, sizeof(int)*(*len));
     
126. 
     
127.         if( tmp != NULL)
     
128.         {
     
129.                 arr = tmp;
     
130.                 tmp = NULL;
     
131.         }
     
132.         else
     
133.         {
     
134.                 printf("realloc memory failed\n");
     
135.                 exit(1);
     
136.         }
     
137. 
     
138.         for (i=0; i<n; ++i)                                                                // i 循环是 循环要添加的数
     
139.         {
     
140.                 for (j=0; j<t1+i; ++j)                                                        // j循环 是循环原数组
     
141.                 {
     
142.                         if ( add[i] < arr[j])
     
143.                         {
     
144.                                 for (k=j; k <= t1+i; ++k)
     
145.                                 {
     
146.                                                 t = arr[k];
     
147.                                                 arr[k] = add[i];
     
148.                                                 add[i] = t;
     
149.                                 }
     
150.                                 cnt = 1;
     
151.                                 break;
     
152.                                
     
153.                         }
     
154.                         cnt = 0;
     
155.                 }
     
156.                 if ( 0 == cnt)
     
157.                         arr[t1+i]=add[i];
     
158. 
     
159.         }
     
160.         if (add != NULL)
     
161.         {
     
162.                 free(add);
     
163.                 add = NULL;
     
164.         }
     
165. 
     
166.         resultdata(arr, *len);
     
167.         switch_choice (arr, * len);
     
168. }
     
169. 
     
170. void resultdata( int * arr, int len)
     
171. {
     
172.         int i;
     
173.         printf("new array has been show below\n");
     
174.         for ( i=0 ; i <len ; ++i)
     
175.         {
     
176.                 printf("%d-->  ", i+1);
     
177.                 printf("%2d \n", arr[i]);
     
178.         }
     
179. }
     
180. 
     
181. 
     
182. 
     
183. void switch_choice(int * arr, int len)
     
184. {
     
185.         int n;
     
186. 
     
187.         printf("type number to choose the function you are going to use:\n");
     
188.         printf("1. activate number search.\n");
     
189.         printf("2. delete number from this array. \n");
     
190.         printf("3. add new numbers to this array. \n");
     
191.         printf("4. exit this program. \n");
     
192. 
     
193.         scanf("%d", &n);
     
194. 
     
195.         switch (n)
     
196.         {
     
197.         case 1:
     
198.                 finddata (arr, len);
     
199.                 break;
     
200.         case 2:
     
201.                 deletedata (arr, &len);
     
202.                 break;
     
203.         case 3:
     
204.                 adddata ( arr, &len);
     
205.                 break;
     
206.         case 4:
     
207.                 return;
     
208.                 break;
     
209.         }
     
210. }

复制代码

元始天尊

这篇文章写的挺有意义，核心是realloc如何被误用的
另外对于动态数组，还是用stl或类stl实现为好，否则每次进行realloc效率也不高

0xAA55

元始天尊 发表于 2014-12-30 09:06
这篇文章写的挺有意义，核心是realloc如何被误用的
另外对于动态数组，还是用stl或类stl实现为好，否则每次 ...

realloc和stl本来就是不同语言的东西

FFFFFFFE

这个要支持一下啊{:soso__4607844064215092132_3:}