C++数组（一维、二维、三维）的动态分配new、初始化memset和释放delete

本是古典何须时尚 2022-05-25 07:15 527阅读 0赞

【原文】http://blog.csdn.net/shanzhizi/article/details/7835752

数组的动态分配、初始化和释放经常用到，这里总结一下，尤其是二维数组

# 一维数组 #

一维数组的动态分配，初始化和撤销都好说，几乎每一本C++教材都会做出详细的说明。具体如下：  
动态分配： int \*array=new int \[n\]；  
初始化：memset(array,0,n\*sizeof(array));       (也可以利用一个for循环对其赋值初始化)  
撤销：delete \[\] array;

# 二维数组 #

下面来说二维数组的。

动态分配：  
二维数组(n行m列)利用new来进行动态分配实际上相当于对n个m元数组进行动态分配，只不过我们不能一味的按照动态分配一维数组的方法来进行这项操作。MSVC目前还没有这般的人性化，具体应该这样做：

\[cpp\]  [view plain][]   [copy][view plain]

1.  **int** \*\*array;  
2.  array=**new** **int** \*\[10\];  
3.  **for**(**int** i=0;i<10;i++)  
4.     array\[i\]=**new** **int** \[5\];

上面的操作完成了一个10行5列的二维数组array\[10\]\[5\]的动态分配,可以看到我们先动态分配了一个10单元的数组的指针的指针的首地址给\*\*array，然后再对其每个首地址进行遍历，同时完成一个5单元的数组的动态分分配，并把首地址给\*array\[i\]，从而最终完成了二维数组array\[10\]\[5\]的动态分配。我们可以依此类推得到三维以至多维的数组的动态分配方法。

初始化：  
如果把一维数组初始化办法照搬过来就会发现对于动态分配的二维数组并不适用。这就要理解到memset这个函数三个参数的含义。MSDNhttp://blog.csdn.net/shanzhizi对memset的描述如下：

Sets buffers to a specified character.  
void \*memset( void \*dest, int c, size\_t count );

可见memset只能作用于一个一维数组void \*dest，因此最好的办法就是和二维数组的动态分配结合起来，new一个，memset一个。我的理解是memset只作用于一块连续的内存空间，而动态开辟的空间不一定是连续的，所以具体写法如下：

\[cpp\]  [view plain][]   [copy][view plain]

1.  **int** \*\*array;  
2.  array=**new** **int** \*\[10\];  
3.  **for**(**int** i=0;i<10;i++)  
4.  \{  
5.      array\[i\]=**new** **int** \[5\];  
6.      memset(array\[i\],0,5\***sizeof**(**int**)); //注意这里是array\[i\]  
7.  \}

可以看到这里的memset的第三个参数有了变化。  
撤销：

\[cpp\]  [view plain][]   [copy][view plain]

1.  **for** (**int** i = 0; i < 10; i ++)  
2.  \{  
3.       **delete**\[\] array\[i\];  
4.  \}  
5.  **delete** \[\] array；

# 三维数组 #

类似于二维数组，用一个例子说明：

\[cpp\]  [view plain][]   [copy][view plain]

1.  \#include <stdio.h>  
2.  \#include <memory.h>  
3.  \#define size1 5  
4.  \#define size2 10  
5.  \#define size3 15  
6.  **int** main()  
7.  \{  
8.         **int** \*\*\* arr;  
9.         **int** i,j,k;  
10.        /// 动态开辟 相当于arr\[size1\]\[size2\]\[size3\]  
11.        arr = **new** **int**\*\*\[size1\];  
12.        **for** (i = 0; i < size1; i ++) \{  
13.               arr\[i\] = **new** **int**\*\[size2\];  
14.               **for** (j = 0; j < size2; j ++) \{  
15.                      arr\[i\]\[j\] = **new** **int**\[size3\];  
16.               \}  
17.        \}  
18.        /// 用for循环初始化  
19.        **for** (i = 0; i < size1; i ++) \{  
20.               **for** (j = 0; j < size2; j ++) \{  
21.                      **for** (k = 0; k < size3; k ++) \{  
22.                             arr\[i\]\[j\]\[k\] = i \* j \* k;  
23.                      \}  
24.               \}  
25.        \}  
26.        **for** (i = 0; i < size1; i ++) \{  
27.               **for** (j = 0; j < size2; j ++) \{  
28.                      **for** (k = 0; k < size3; k ++) \{  
29.                             printf("i\*j\*k=%d\*%d\*%d=%d/n",i,j,k,arr\[i\]\[j\]\[k\]);  
30.                      \}  
31.               \}  
32.        \}  
33.        /// 用memset，如果是静态int arr\[\]\[\]\[\]的话，直接memset(arr,0,sizeof(arr));数组初始化为0  
34.        **for** (i = 0; i < size1; i ++) \{  
35.               **for** (j = 0; j < size2; j ++) \{  
36.                      memset(arr\[i\]\[j\],-1,**sizeof**(**int**) \* size3);  
37.               \}  
38.        \}  
39.        **for** (i = 0; i < size1; i ++) \{  
40.               **for** (j = 0; j < size2; j ++) \{  
41.                      **for** (k = 0; k < size3; k ++) \{  
42.                             printf("i,j,k=%d,%d,%d=%d/n",i,j,k,arr\[i\]\[j\]\[k\]);  
43.                      \}  
44.               \}  
45.        \}  
46.        / 释放内存  
47.        **for** (i = 0; i < size1; i ++) \{  
48.               **for** (j = 0; j < size2; j ++) \{  
49.                      **delete**\[\] arr\[i\]\[j\];  
50.               \}  
51.               **delete**\[\] arr\[i\];  
52.        \}  
53.        **delete**\[\] arr;  
54.        **return** 0;  
55. \}  
56.

[view plain]: https://blog.csdn.net/u012234115/article/details/36686457#