数组是具有一定顺序关系的若干对象的集合体，组成数组的对象称为该数组的元素。 数组元素用数组名与带方括号的下标表示，同一数组的各个元素具有相同的类型。数组可以由除void型以外的任何一种类型构成，构成数组的类型和数组之间的关系，可以类比为数学上数与向量或矩阵的关系。

每个元素有n个下标的数组称为n维数组。如果用array来命名一个数组，且其下标为从0到N的整数，则数组各元素为array[0]，array[1]，…，array[N]。这样一个数组可以顺序存储N+1个数据，因此N+1就是数组array的大小，数组的下标下界为0，数组的下标上界为N。

1.数组的声明与使用

（1）数组的声明

数组属于自定义数据类型，因此在使用之前首先要进行类型声明。声明一个数组类型，应该包括以下几个方面：

①确定数组的名称
②确定数组元素的类型
③确定数组的结构（包括数组维数，每一维的大小等）

数组类型声明的一般形式为：

数据类型 标识符[常量表达式1][常量表达式2]...;

数组中元素的类型是由“数据类型”给出，这个数据类型，可以是整型、浮点型等基本类型，也可以是结构体、类等用户自定义类型。数组的名称由“标识符”指定。

“常量表达式1”、“常量表达式2”、…称为数组的界，必须是在编译时就可求出的常量表达式，其值必须为正整数。数组的下标用来限定数组的元素个数、排列次序和每一个元素在数组中的位置。一个数组可以有多个下标，有n个下标的数组称为n维数组，数组元素的下标个数称为数组的维数。声明数组时，每一个下标表达式表示该维的下标个数（注意：不是下标上界）。数组元素个数是各下标表达式的乘积。例如：

①

int b[10];

表示b为int型数组，有10个元素：b[0]~b[9]，可以用于存放10个元素的整数序列。

②

int a[5][3];

表示a为int型二维数组，其中第一维有5个下标（0~4），第二维有3个下标（0~2），数组元素的个数为15，可以用于存放5行3列的整型数据表格。值得注意的是数组下标的起始值为0。对于上面声明的数组a，第一个元素是a[0][0]，最后一个元素是a[4][2]。也就是说每一维的下标都是从0开始。

（2）数组的使用

使用数组时，只能分别对数组的各个元素进行操作。数组的元素是由下标来区分的。对于一个已经声明过的数组，其元素的使用形式为：

数组名[下标表达式1][下标表达式2]...

其中下标表达式个数取决于数组的维数，N维数组就有N个下标表达式。

数组中的每一个元素都相当于一个相应类型的变量，凡是允许使用该类型变量的地方，都可以使用数组元素。可以像使用一个整型变量一样使用整型数组的每一个元素。同样，每一个类类型的数组也可以和一个该类的普通对象一样使用。在使用过程中注意以下两点：

（1）数组元素的下标表达式可以是任意合法的算术表达式，其结果必须为整数。
（2）数组元素的下标值不得超过声明时所确定的上下界，否则运算时数组越界错误。

【例】数组的声明与使用

#include<iostream>
using namespace std;

int main()
{
	int a[10], b[10];
	for (int i = 0; i < 10; i++)
	{
		a[i] = i * 2 - 1;
		b[10 - i - 1] = a[i];
	}
	for (int i = 0; i < 10; i++)
	{
		cout << "a[" << i << "]=" << a[i] << endl;
		cout << "b[" << i << "]=" << b[i] << endl;
	}
	return 0;
}

运行结果：

结果分析：
程序中，定义了两个有10个元素的一维数组a和b，使用for循环对它们赋值，在引用b元素时采用了算术表达式作为下标。程序运行之后将-1，1，3，…，17分别赋给数组元素a[0]，a[1]，…，a[9]，数组b中元素的值刚好是数组a中的逆序排列。

如果把两个循环语句for(int i=0;i<10;i++)改写为for(int i=1;i<=10;i++)，在编译和连接过程中都不会出错，但最后运行时不仅不会得到正确结果，而且有可能产生意想不到的错误，这就是一个典型的数组越界错误。如下：

#include<iostream>
using namespace std;

int main()
{
	int a[10], b[10];
	for (int i = 1; i <= 10; i++)
	{
		a[i] =  i * 2 - 1; ;
		b[10 - i - 1] = a[i];
	}
	for (int i = 1; i <= 10; i++)
	{
		cout << "a[" << i << "]=" << a[i] << endl;
		cout << "b[" << i << "]=" << b[i] << endl;
	}
	return 0;
}

运行结果：

2.数组的存储与初始化

（1）数组的存储

**数组元素在内存中是顺序、连续存储的。**数组元素在内存中占据一组连续的存储单位，逻辑上相邻的元素在物理地址上也是相邻的。一维数组是简单地按照下标的顺序连续存储的。多维数组的元素也是顺序、连续存储的，其存储顺序的约定非常重要。

元素的存储顺序问题关系到对数组做整体处理时，以什么样的顺序对数组元素进行操作。C++中很多操作都与数组元素的存储顺序相关，如数组初始化、函数间的数据传递等。

①一个一维数组可以看作是数学上的一个列向量，各元素是按下标从小到大的顺序连续存放在计算机内存单元中。例如，数组声明语句：

int arr[5];

声明了一个有5个元素的一维int型数组，可以看作是列向量[arr[0],arr[1],arr[2],arr[3],arr[4]]，元素在内存中的存放顺序如下图所示：

②一个二维数组可以看作数学中的一个矩阵，第一个下标称为行标，第二个下标称为列标。例如，数组声明语句：

int m[2][3];

声明了一个数组，相当于一个2行3列的矩阵：

但在C++中，数组元素每一维的下标都是从0开始的，因此在程序中，矩阵M就被表示为：

其中，元素m[1][0]，行标为1，列标为0，表示矩阵第2行第1个元素。二维数组在内存中是按行存放的，即先放第1行，再放第2行…每行中的元素是按列下标从小到大的顺序存放，这样的存储方式也称为优先存储。二维数组m在内存中的存放顺序如下图所示：

【注意】
C++中二维数组被当作一维数组的数组。例如int m[2][3]所定义的m，可以看作是这样一个数组，它的大小是2，每一个元素都是一个大小为3、类型为int的数组。由于数组的每个元素都要存放在连续空间中，因此二维数组自然会按行优先的顺序存储。

③多维数组也是采取类似的方式顺序存放。

（2）数组的初始化

数组的初始化就是在声明数组时给部分或全部元素赋初值。对于基本类型的数组，初始化过程就是给数组元素赋值；对于对象数组，每个元素都是某个类的一个对象，初始化就是调用该对象的构造函数。

声明数组时给出数组元素的初值，例如：

#include<iostream>
using namespace std;

int main()
{

	int a[10] = { 1,2,3,4,5,6,7,8,9,10 };

	for (int i = 0; i < 10; i++)
	{
		cout << "a[" << i << "]=" << a[i] << endl;
		
	}
	return 0;
}

运行结果：

表示声明了一个具有10个元素的int型数组，数组元素a[0]，a[1]，…，a[10]的值分别为1，2，3，4，5，6，7，8，9，10。声明数组时如果列出全部元素的初值，可以不用说明数组元素的个数，下面语句和int a[10] = { 1,2,3,4,5,6,7,8,9,10 };语句完全等价：

int a[] = { 1,2,3,4,5,6,7,8,9,10 };

当然，也可以只对数组元素中的部分元素进行初始化，比如声明一个有5个元素的浮点型数组，给前3个元素分别赋值1.0，2.0，3.0，可以写为：

int main()
{
	float fa[5] = { 1.0,2.0,3.0 };

	int a[10] = { 1,2,3,4,5,6,7,8,9,10 };

	for (int i = 0; i < 5; i++)
	{
		cout << "a[" << i << "]=" << fa[i] << endl;
	}
	return 0;
}

运行结果：

这时数组元素的个数必须明确指出，对于后面没有赋值的两个元素，也不用做任何说明。初始化只能针对所有元素或者从起始地址开始的前若干元素，而不能间隔赋初值。

【注意】
当指定的初值个数小于数组大小时，剩下的数组元素会被赋予0值。若定义数组时没有指定任何一个元素的初值，对于静态生存期的数组，每个元素仍然会被赋值为0；但对于动态生存期的数组，每个元素的初值都是不确定的。例如：
①静态生存期的数组

#include<iostream>
using namespace std;

int main()
{
	static int a[10]；
	for (int i = 0; i < 10; i++)
	{
		cout << "a[" << i << "]=" << a[i]<<" ";
	}
	return 0;
}

运行结果：

②动态生存期的数组

#include<iostream>
using namespace std;

int main()
{
	int a[10];

	for (int i = 0; i < 10; i++)
	{
		cout << "a[" << i << "]=" << a[i] << ",";
	}
	cout << endl;
	return 0;
}

运行结果：

多维数组的初始化也遵守同样的规则。此外，如果给出全部元素的初值，第一维的下标个数可以不用显式说明，例如：

int a[2][3]={1,0,0,0,1,0};

等价于：

int a[][3]={1,0,0,0,1,0};

多维数组可以按第一维的下标进行分组，使用花括号将每一组的数据括起来。对于二维数组，可以分行用花括号括起来。下面的写法与上面的语句完全等效：

int a[2][3]={{1,0,0},{0,1,0}};

采用括号分组写法，容易识别，易于理解。

此外，数组也可以被声明为常量，例如：

const float fa[5]={1.0,2.0,3.0};

它表明fa数组中每个元素都被当作常量对待，也就是说它们的值在初始化后皆不可以改变。声明为常量的数组，必须给定初值。