详解C++中的一维数组和二维数组

C++⼀维数组定义⼀维数组

定义⼀维数组的⼀般格式为：

类型标识符 数组名[常量表达式];例如：

int a[10];

它表⽰数组名为a，此数组为整型，有10个元素。关于⼀维数组的⼏点说明：

1) 数组名定名规则和变量名相同，遵循标识符定名规则。

2) ⽤⽅括号括起来的常量表达式表⽰下标值，如下⾯的写法是合法的：

int a[10]; int a[2*5];

int a[n*2]; //假设前⾯已定义了n为常变量

3) 常量表达式的值表⽰元素的个数，即数组长度。例如，在“int a[10];”中，10表⽰a数组有10个元素，下标从0开始，这10个元素是： a[0]，a[1]，a[2]，a[3]，a[4]，a[5]，a[6]，a[7]， a[8]，a[9]。注意最后⼀个元素是a[9]⽽不是a[10]。

4) 常量表达式中可以包括常量、常变量和符号常量，但不能包含变量。也就是说，C++不允许对数组的⼤⼩作动态定义，即数组的⼤⼩不依赖于程序运⾏过程中变量的值。例如，下⾯这样定义数组是不⾏的：

int n;

cin>>n; //输⼊a数组的长度

int a[n]; //企图根据n的值决定数组的长度

如果把第1，2⾏改为下⾯⼀⾏就合法了：

const int n=5;

引⽤⼀维数组的元素

数组必须先定义，然后使⽤。只能逐个引⽤数组元素的值⽽不能⼀次引⽤整个数组中的全部元素的值。数组元素的表⽰形式为： 数组名[下标]

下标可以是整型常量或整型表达式。例如：

a[0]= a[5]+ a[7]- a[2*3]

【例】数组元素的引⽤。

#include using namespace std;int main( ){

int i, a[10];

for (i=0;i<=9;i++) a[i]=i;

for (i=9;i>=0;i--) cout<运⾏结果如下：

9 8 7 6 5 4 3 2 1 0

程序使a[0]~a[9]的值为0~9，然后按逆序输出。⼀维数组的初始化

1) 在定义数组时分别对数组元素赋予初值。例如：

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

2) 可以只给⼀部分元素赋值。例如：

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

3) 如果想使⼀个数组中全部元素值为1，可以写成：

int a[10]={1,1,1,1,1,1,1,1,1,1};

不能写成

int a[10]={1*10};

不能给数组整体赋初值。

4) 在对全部数组元素赋初值时，可以不指定数组长度。例如：

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

可以写成

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

⼀维数组程序举例

【例】⽤数组来处理求Fibonacci数列问题。

可以⽤20个元素代表数列中的20个数，从第3个数开始，可以直接⽤表达式f[i]=f[i-2]+f[i-1]求出各数。程序如下：

#include #include using namespace std;int main( ){

int i;

int f[20]={1,1}; //f[0]=1,f[1]=1 for(i=2;i<20;i++)

f[i]=f[i-2]+f[i-1]; //在i的值为2时,f[2]=f[0]+f[1],依此类推 for(i=0;i<20;i++) //此循环的作⽤是输出20个数 {

if(i%5==0) cout<cout<运⾏结果如下：

【例】编写程序，⽤起泡法对10个数排序（按由⼩到⼤顺序）。

起泡法的思路是：将相邻两个数⽐较，将⼩的调到前头。见图5.2。然后进⾏第2趟⽐较，对余下的前⾯5个数按上法进⾏⽐较，见图。

可以推知，如果有n个数，则要进⾏n-1趟⽐较(和交换)。在第1趟中要进⾏n-1次两两⽐较，在第j趟中要进⾏n-j次两两⽐较。根据以上思路写出程序，今设n=10，本例定义数组长度为11，a[0]不⽤，只⽤a[1]~a[10]，以符合⼈们的习惯。从前⾯的叙述可知，应该进⾏9趟⽐较和交换。

#include using namespace std;int main( ){

int a[11]; int i, j, t;

cout<<\"input 10 numbers ：\"<>a[i]; cout<for (j=1;j<=9;j++) //共进⾏9趟⽐较

for(i=1;i<=10-j;i++)//在每趟中要进⾏(10-j)次两两⽐较 if (a[i]>a[i+1]) //如果前⾯的数⼤于后⾯的数 {

t=a[i];a[i]=a[i+1];a[i+1]=t;

}//交换两个数的位置, 使⼩数上浮 cout<<\"the sorted numbers ：\"<运⾏情况如下：

input 10 numbers：

3 5 9 11 33 6 -9 -76 100 123↙the sorted numbers：

-76 -9 3 5 6 9 11 33 100 123

C++⼆维数组

具有两个下标的数组称为⼆维数组。有些数据要依赖于两个因素才能惟⼀地确定，例如有3个学⽣，每个学⽣有4门课的成绩，显然，成绩数据是⼀个⼆维表，如书中表所⽰。

想表⽰第3个学⽣第4门课的成绩，就需要指出学⽣的序号和课程的序号两个因素，在数学上以S3,4表⽰。在C++中以s[3][4]表⽰，它代表数据73。定义⼆维数组

定义⼆维数组的⼀般形式为：

类型标识符 数组名[常量表达式][常量表达式];例如：

float a[3][4], b[5][10];

定义a为3×4(3⾏4列)的单精度数组，b为5×10(5⾏10列)的单精度数组。注意不能写成“float a[3,4], b[5,10];”。C++对⼆维数组采⽤这样的定义⽅式，使我们可以把⼆维数组看作是⼀种特殊的⼀维数组：它的元素⼜是⼀个⼀维数组。例如，可以把a看作是⼀个⼀维数组，它有3个元素：a[0]，a[1]，a[2]，每个元素⼜是⼀个包含4个元素的⼀维数组，见图5.4。a[0]，a[1]，a[2]是3个⼀维数组的名字。

上⾯定义的⼆维数组可以理解为定义了3个⼀维数组，即相当于：

float a[0][4], a[1][4], a[2][4];

此处把a[0]，a[1]，a[2]作⼀维数组名。C++的这种处理⽅法在数组初始化和⽤指针表⽰时显得很⽅便，这在以后会体会到。C++中，⼆维数组中元素排列的顺序是：按⾏存放，即在内存中先顺序存放第⼀⾏的元素，再存放第⼆⾏的元素。图表⽰对a[3][4]数组存放的顺序。

上⾯定义的⼆维数组可以理解为定义了3个⼀维数组，即相当于：

float a[0][4], a[1][4], a[2][4];

此处把a[0]，a[1]，a[2]作⼀维数组名。C++的这种处理⽅法在数组初始化和⽤指针表⽰时显得很⽅便，这在以后会体会到。C++中，⼆维数组中元素排列的顺序是：按⾏存放，即在内存中先顺序存放第⼀⾏的元素，再存放第⼆⾏的元素。图5.5表⽰对a[3][4]数组存放的顺序。

C++允许使⽤数组。有了⼆维数组的基础，再掌握数组是不困难的。例如，定义三维数组的⽅法是： float a[2][3][4];

定义float型三维数组a，它有2×3×4=24个元素。数组元素在内存中的排列顺序：第⼀维的下标变化最慢，最右边的下标变

化最快。例如，上述三维数组的元素排列顺序为：

复制代码 代码如下:

a[0][0][0]→a[0][0][1]→a[0][0][2]→a[0][0][3]→a[0][1][0]→a[0][1][1]→a[0][1][2]→a[0][1][3]→a[0][2][0]→a[0][2][1]→a[0][2][2]→a[0][2][3]→a[1][0][0]→a[1][0][1]→a[1][0][2]→a[1][0][3]→a[1][1][0]→a[1][1][1]→a[1][1][2]→a[1][1][3]→a[1][2][0]→a[1][2][1]→a[1][2][2]→a[1][2][3]

⼆维数组的引⽤

⼆维数组的元素的表⽰形式为：

数组名 [下标][下标]

如：

a[2][3]

下标可以是整型表达式，如a[2-1][2*2-1]。不要写成a[2,3]，a[2-1,2*2-1]形式。数组元素是左值，可以出现在表达式中，也可以被赋值，例如：

b[1][2]=a[2][3]/2;

在使⽤数组元素时，应该注意下标值应在已定义的数组⼤⼩的范围内。常出现的错误是：

int a[3][4]; //定义3⾏4列的数组 ┆

a[3][4]=15; //引⽤a[3][4]元素

定义a为3×4的数组，它可⽤的⾏下标值最⼤为2，列坐标值最⼤为3。最多可以⽤到a[2][3]，a[3][4]就超过了数组的范围。请严格区分在定义数组时⽤的a[3][4]和引⽤元素时的a[3][4]的区别。前者a[3][4]⽤来定义数组的维数和各维的⼤⼩，后者a[3][4]中的3和4是下标值，a[3][4]代表某⼀个元素。⼆维数组的初始化

可以⽤下⾯的⽅法对⼆维数组初始化：1) 分⾏给⼆维数组赋初值。如

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

这种赋初值⽅法⽐较直观，把第1个花括号内的数据赋给第1⾏的元素，第2个花括号内的数据赋给第2⾏的元素……即按⾏赋初值。

2) 可以将所有数据写在⼀个花括号内，按数组排列的顺序对各元素赋初值。如

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

效果与前相同。但以第1种⽅法为好，⼀⾏对⼀⾏，界限清楚。⽤第2种⽅法如果数据多，写成⼀⼤⽚，容易遗漏，也不易检查。

3) 可以对部分元素赋初值。如：

int a[3][4]={{1},{5},{9}};

它的作⽤是只对各⾏第1列的元素赋初值，其余元素值⾃动置为0。赋初值后数组各元素为：

1 0 0 05 0 0 09 0 0 0

也可以对各⾏中的某⼀元素赋初值：

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

初始化后的数组元素如下：

1 0 0 00 6 0 00 0 11 0

这种⽅法对⾮0元素少时⽐较⽅便，不必将所有的0都写出来，只需输⼊少量数据。也可以只对某⼏⾏元素赋初值：

int a[3][4]={{1},{5,6}};

数组元素为：

1 0 0 05 6 0 00 0 0 0

第3⾏不赋初值。也可以对第2⾏不赋初值：

int a[3][4]={{1},{},{9}};

4) 如果对全部元素都赋初值（即提供全部初始数据），则定义数组时对第⼀维的长度可以不指定，但第⼆维的长度不能省。如：

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

可以写成

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

系统会根据数据总个数分配存储空间，⼀共12个数据，每⾏4列，当然可确定为3⾏。在定义时也可以只对部分元素赋初值⽽省略第⼀维的长度，但应分⾏赋初值。如

int a[][4]={{0,0,3},{},{0,10}};

这样的写法，能通知编译系统： 数组共有3⾏。数组各元素为：

0 0 3 00 0 0 00 10 0 0

C++在定义数组和表⽰数组元素时采⽤a[][]这种两个⽅括号的⽅式，对数组初始化时⼗分有⽤，它使概念清楚，使⽤⽅便，不易出错。

⼆维数组程序举例

【例】将⼀个⼆维数组⾏和列元素互换，存到另⼀个⼆维数组中。例如：程序如下：

#include using namespace std;int main( ){

int a[2][3]={{1,2,3},{4,5,6}}; int b[3][2],i,j;

cout<<\"array a：\"<for (j=0;j<=2;j++) {

cout<cout<cout<<\"array b：\"<for(j=0;j<=1;j++) cout<return 0;}

运⾏结果如下：

array a： 1 2 3 4 5 6array b： 1 4 2 5 3 6

【例】有⼀个3×4的矩阵，要求编程序求出其中值最⼤的那个元素的值，以及其所在的⾏号和列号。

开始时把a[0][0]的值赋给变量max，然后让下⼀个元素与它⽐较，将⼆者中值⼤者保存在max中，然后再让下⼀个元素与新的max⽐，直到最后⼀个元素⽐完为⽌。max最后的值就是数组所有元素中的最⼤值。程序如下：

#include using namespace std;int main( ){

int i,j,row=0,colum=0,max;

int a[3][4]={{5,12,23,56},{19,28,37,46},{-12,-34,6,8}}; max=a[0][0];//使max开始时取a[0][0]的值 for (i=0;i<=2;i++)//从第0⾏~第2⾏ for (j=0;j<=3;j++) //从第0列~第3列 if (a[i][j]>max) //如果某元素⼤于max {

max=a[i][j]; //max将取该元素的值 row=i; //记下该元素的⾏号i colum=j;//记下该元素的列号j }

cout<<\"max=\"<输出结果为

max=56，row=0，colum=3