C/C++上二维数组的两种动态分配内存方法

最近在看一个程序的源代码的时候了解到了二维数组的动态分配空间以及释放的方法，在此记录。

一、二维数据的内存空间动态分配

方法一：

[cpp] view plaincopy

1. void malloc2D_1(int **&a)  
2. {  
3.     a = new int*[xDim];  
4.     for(int i=0;i<xDim;i++)       
5.         a[i] = new int[yDim];  
6.     assert(a!=NULL);  
7. }  
8.   
9. int main()  
10. {  
11.     int **arr = NULL;  
12.     malloc2D_1(arr);  
13. }  

首先arr是一个二级指针，为arr分配xDim空间，每一维都是一个指向数组的指针，且每个数组内部的地址空间是连续的，但是数组之间的地址空间没有连续性。

这种分配方法在内存中的布局如下：

方法二：

[cpp] view plaincopy

1. void malloc2D_2(int **&a)   
2. {  
3.     a = (int **)malloc( xDim * sizeof(int *) );  
4.     a[0] = (int *)malloc( xDim * yDim * sizeof(int) );  
5.     for(int i=1;i<xDim;i++)  
6.     {  
7.         a[i] = a[i-1] + yDim;          
8.     }  
9.     assert(a!=NULL);  
10. }  
11.   
12. int main()  
13. {  
14.     int **arr = NULL;  
15.     malloc2D_2(arr);  
16. }  

这种方法相当于动态分配了一个一维的连续的空间，然后让相应的数组指针指向某些固定的位置达到调用的目的。

这种分配方法在内存中的布局如下：

二、二维数据的内存空间释放

对于第一种分配方式需要一个一个释放，对第二种方式只要分配两个指针即可。

[cpp] view plaincopy

1. void free2D_1(int **a)  
2. {  
3.     for(int i=0;i<xDim;i++)           
4.         free(a[i]);  
5. }  
6.   
7. void free2D_2(int **a)  
8. {  
9.     free(a[0]);  
10.     free(a);  
11. }  

三、完整代码

[cpp] view plaincopy

1. #include<iostream>  
2.   
3. using namespace std;  
4.   
5. const int xDim = 10;  
6. const int yDim = 8;  
7.   
8. //分配空间方式一   
9. void malloc2D_1(int **&a)  
10. {  
11.     a = new int*[xDim];  
12.     for(int i=0;i<xDim;i++)       
13.         a[i] = new int[yDim];  
14.     assert(a!=NULL);  
15. }  
16. //分配空间方式二   
17. void malloc2D_2(int **&a)   
18. {  
19.     a = (int **)malloc( xDim * sizeof(int *) );  
20.     a[0] = (int *)malloc( xDim * yDim * sizeof(int) );  
21.     for(int i=1;i<xDim;i++)  
22.     {  
23.         a[i] = a[i-1] + yDim;          
24.     }  
25.     assert(a!=NULL);  
26. }  
27.   
28. void assign_value(int **a,int val)  
29. {  
30.     for(int i=0;i<xDim;i++)       
31.     {  
32.         for(int j=0;j<yDim;j++)          
33.         {  
34.             a[i][j] = val;     
35.             cout<<a[i][j]<<" ";       
36.         }  
37.         cout<<endl;  
38.     }  
39.     cout<<endl;  
40. }  
41. //释放空间方式一   
42. void free2D_1(int **a)  
43. {  
44.     for(int i=0;i<xDim;i++)           
45.         free(a[i]);  
46. }  
47. //释放空间方式二   
48. void free2D_2(int **a)  
49. {  
50.     free(a[0]);  
51.     free(a);  
52. }  
53.   
54. int main()  
55. {  
56.     int **arr1 = NULL;  
57.     int **arr2 = NULL;  
58.       
59.     malloc2D_1(arr1);  
60.     malloc2D_2(arr2);  
61.       
62.     assign_value(arr1,1);  
63.     assign_value(arr2,2);  
64.       
65.     free2D_1(arr1);  
66.     free2D_2(arr2);  
67.       
68.     system("pause");  
69.     return 0;  
70. }  

Author：忆之独秀

Email：[e-mail]

注明出处：http://blog.csdn.net/lavorange/article/details/42879605