数组是一种非常有用和常用的数据类型。在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

从Java到C++——数组的用法,古老的榕树,5-wow.com