关注我
数组是一种非常有用和常用的数据类型。在Java中数组的定义和使用相对简单，语法较为宽松，但在C++中数组的用法就比较多样，相对复杂了！
Java中的数组
一维数组
一维数组的形式(1)：
int a[]; a = new int[5];
其中定义数组int a[]时并不为数组分配内存，只是声明了(将要使用)int类型数组。只有在创建数组a = new int[5]时才为其分配内存。Int[] a;与int a[];是等价的。形式(1) 等同于形式(2)：
int a[] = new int[5];
Java中的数组还有一个特性就是可以通过数组名直接获得数组的长度，如以上数组a有a.length;
【例1】
public static void main(String grst[]) {
arrayTest(5);
}
private static void arrayTest(int n) {
int arr[] = new int[n];
for(int i=0; i<arr.length; i++) {
System.out.print(arr[i] + " ");
}
System.out.println();
int arr2[] = {1, 2, 3, 4, 5, 6, 7, 8};
for(int i=0; i<8; i++) {
System.out.print(arr2[i] + " ");
}
System.out.println();
}结果如下：
0 0 0 0 0
1 2 3 4 5 6 7 8
二维数组
1.定义时初始化：int a[][] = {{1,2}, {3,4,5,6}, {7,8,9}};
2.二维数组可看成以数组为元素的数组。java中多维数组的声明和初始化应按从高维到低维的顺序进行，如：
方法(1)：
int a[][] = new int[3][]; a[0] = new int[2]; a[1] = new int[4]; a[2] = new int[3];//正确 int t[][] = new int[][4];//非法
方法(2)：
int a[][] = new int[3][5];//正确，分配一个三行五列的二维数组。
C++中的数组
C++中的数组就复杂了，有静态分配的数组和动态分配的数组之分。
静态分配的数组
静态分配的数组即在编译时就确定数组的大小和元素的值。
定义数组形式：
一维数组T arr[N];
T为数组的数据类型，N为数组的大小，N必须是常量值或常量表达式。要注意的几点：
1.默认情况下，定义数组时数组的元素被默认初化，如果在函数内部定义定义内置类型的数组，那么默认初始化会使元素含有未定义的值。
【例2】：
void arrayTest()
{
const unsigned n = 5; //n为一个常量值
int arr[n]; //定义一个int类型的数组，但未对其进行初始化
for (int i=0; i<n; i++)
{
cout << arr[i] << " ";
}
cout << endl;
int * pArr[5]; //保存10个int类型指针的数组
}
int array[5]; //定义的全局的int型数组，数组的元素会默认初始化为0
int main()
{
arrayTest();
for (int i=0; i<5; i++)
{
cout << array[i] << " ";
}
cout << endl;
return 0;
}结果：
-858993460 -858993460 -858993460 -858993460 -858993460
0 0 0 0 0
2.可以显示地初始化数组元素。
【例3】：
void printArray(int arr[], int n)
{
for(int i=0; i<n; i++)
{
cout << arr[i] << " ";
}
cout << endl;
}
void arrTeat2()
{
int a1[] = {1, 2, 3}; //当给定所有初始化值时，[]内可以不指定数组的大小，数组的大小即为初始化列表的个数
int a2[5] = {2, 4, 6, 8, 10}; //当给定初始化值时,也可以指定数组的大小，但[]内的值必须大于等于初始化列表的个数
int a3[5] = {2, 4, 6}; //当指定的数组的大小n大于初始化列表个数m时，初始化列表初始化前面m个元素，后面的元素默认初始化为0
printArray(a1, 3);
printArray(a2, 5);
printArray(a3, 5);
}
结果：
1 2 3
2 4 6 8 10
2 4 6 0 0
二维数组：
T arr[N][M];
T为数组的数据类型，M为第一维的大小，N为第二维的大小，M、N必须是常量值或常量表达式。
【例4】
void arrTest3()
{
int arr[3][4] = {
{1, 2, 3, 4},
{4, 5},
{6}
};
for(int i=0; i<3; i++)
{
for(int j=0; j<4; j++)
{
cout << arr[i][j] << " ";
}
cout << endl;
}
cout << endl;
int arr2[][4] =
{
{1, 2, 3, 4},
{5, 6, 7, 8},
{9, 10, 11, 12}
};
for(int i=0; i<3; i++)
{
for(int j=0; j<4; j++)
{
cout << arr[i][j] << " ";
}
cout << endl;
}
}结果为：
1 2 3 4
4 5 0 0
6 0 0 0
1 2 3 4
4 5 0 0
6 0 0 0
动态分配的数组
动态分配的数组是指在程度运行时才分配内存，在编译时并不分配内存。在上一篇文章中已经讲了《用new分配一个动态数组》，这里主要讲一个动态分配二维数组：
二维数组可以看成是一维数组的数组，得从高以度进行分配，假设要分配一个m*n大小的数组，代码如下:
【例5】：
void D2Array(int m, int n)
{
//分配并初始化二维数组
int **arr = new int*[m]; //分配一个int指针类型的数组，说明保存的是每一个数组的首元素
for(int i = 0; i < m; i++)
{
arr[i] = new int[n]; //分配大小为n的数组空间
for(int j = 0; j < n; j++)
{
arr[i][j] = i * j; //初始化数组元素
}
}
//输出数组的内容
for(int i = 0; i < m; i++)
{
for(int j = 0; j < n; j++)
{
cout << arr[i][j] << " ";
}
cout << endl;
}
cout << endl;
//一定要记得释放数组空间
for (int i = 0; i < m; i ++)
{
delete[]arr[i]; //先一个一个释放第二维的数组
arr[i] = NULL;
}
delete[] arr; //再释放第一维的数组
arr = NULL;
}结果如下：
0 0 0 0
0 1 2 3
0 2 4 6
注意：动态分配的数组一定要记得释放数组空间，不然会导致内存泄露。当然也可以通过malloc进行分配动态数组，原理类似。至于malloc与new的区别，又是另一个话题，在这不再探讨。