《C++语言程序设计》课程辅导二（2.1）
------数组和字符串
一、数组的概念
在程序设计中存储单个数据时，需要根据数据的类型定义相应的变量来保存。如存储一个整数时需要定义一个整数变量来保存，存储一个实数时需要定义一个单精度或双精度变量来保存，存储含有多个成分的一个记录数据时，需要定义该类型的一个结构变量来保存。
若在程序设计中需要存储同一数据类型的、彼此相关的多个数据时，如存储数学上使用的一个数列或一个矩阵中的全部数据时，显然采用定义简单变量的方法是不行的，这就要求定义出能够同时存储多个值的变量，这种变量在程序设计中称为数组。
在实际应用中，一组相关的数据之间可能存在着一维关系，也可能存在着二维关系，等等。一个数列中的数据若是一维关系，则它除第一个数据外，每个数据只有一个直接前驱；除最后一个数据外，每个数据只有一个直接后继。假定一个数列为(38,42,25,60)，则每个数的后一个数就是它的直接后继，每一个数的前一个数就是它的直接前驱，如42的直接前驱为38，直接后继为25。一个矩阵中的数据若二维关系，则它除第一行和第一列上的所有数据外，每个数据在行和列的方向上各有一个直接前驱；除最后一行和最后一列上的所有数据外，每个数据在行和列的方向上各有一个直接后继。假定一个矩阵为：
2 6 9 12
8 4 7 3
5 1 6 8
则每一个元素均处于相应行和列的交点位置上，虽然有的元素值相同，但由于所处的位置不同，所以是不同的元素。
在程序设计中，用一维数组表示和存储一维相关的数据，用二维数组表示和存储二维相关的数据，用三维数组表示和存储三维相关的数据，等等。假定一个数列为a1,a2,...,an,则需要用一个一维数组来存储，假定仍用a作为数组名，则a中应至少包含有n个元素，每个元素用来存储数列中一个相应的数据。若a中正好包含有n个元素，则这n个元素依次表示为a[0],a[1],...,a[n-1]，用a[0]存储数列中的第一个数据a1，用a[1]存储数列中的第二个数据a2，依次类推。假定一个矩阵为：
a11 a12 ... a1n
a21 a22 ... a2n
...
am1 am2 ... amn
则需要用一个二维数组来存储，假定二维数组名用b表示，则b中应至少包含mn个元素，也就是说，第一维尺寸至少为m，第二维尺寸至少为n，该数组b中的每个元素用来存储矩阵中的一个相应的数据。
二、数组的定义
2.1 一维数组
1. 定义格式
一维数组同简单变量一样，也是通过变量定义语句定义的。其定义格式为：
<类型关键字> <数组名> [<常量表达式>] [={<初值表>}];
<类型关键字>为已存在的一种数据类型，<数组名>是用户定义的一个标识符，用它来表示一个数组，<常量表达式>的值是一个整数，由它标明该数组的长度，即数组中所含元素的个数，每个元素具有<类型关键字>所指定的类型，<常量表达式>两边的中括号是语法所要求的符号，不是标明其内容为可选而使用的符号，<初值表>是用逗号分开的一组表达式，每个表达式的值将被赋给数组中的相应元素。
当数组定义中包含有初始化选项时，其<常量表达式>可以被省略，此时所定义的数组的长度将是<初值表>中所含的表达式的个数。
一个数组被定义后，系统将在内存中为它分配一块含有n个（n为数组长度）存储单元的存储空间，每个存储单元包含的字节数等于元素类型的长度。如对于一个含有10个int型元素的数组，它将对应10*4=40个字节的存储空间。
定义了一个数组，就相当于同时定义了它所含的每个元素。数组中的每个元素是通过下标运算符[]来指明和访问的，具体格式为：“<数组名>[<下标>]”，这与数组的定义格式相同，但出现的位置是不同的，当出现在变量定义语句时则为数组定义，而当出现在表达式中时则为一个元素。
对于一个含有n个元素的数组，C++语言规定：它的下标依次为0,1,2,...,n-1，因此全部n个元素依次为a[0],a[1],a[2],...,a[n-1]，其中假定a为数组名。
2. 格式举例
(1) int a[20];
(2) double b[MS]; //假定MS为已定义的整型常量
(3) int c[5]={1,2,3,4,0};
(4) char d[]={'a','b','c','d'};
(5) int e[8]={1,4,7};
(6) char f[10]={'B','A','S','I','C'};
(7) bool g[2*N+1]; //假定N为已定义的整型常量
(8) float h1[5], h2[10];
(9) short x=1, y=2, z, w[4]={25+x, -10, x+2*y, 44};
(10) int p[];
第一条语句定义了一个元素为int型、数组名为a、包含20个元素的数组，所含元素依次为a[0],a[1],...,a[19]，每个元素同一个int型简单变量一样，占用4个字节的存储空间，用来存储一个整数，整个数组占用80个字节的存储空间，用来存储20个整数。
第二条语句定义了一个元素类型为double、数组长度为MS的数组b，该数组占用MS*8个字节的存储空间，能够用来存储MS个双精度数，数组b中的元素依次为b[0],b[1],...,b[MS-1]。
第三条语句定义了一个整型数组c，即元素类型为整型的数组c，它的长度为5，所含元素依次为c[0],c[1],c[2],c[3]和c[4]，并相应被初始化为1,2,3,4和0。
第四条语句定义了一个字符数组d，由于没有显式地给出它的长度，所以隐含为初值表中表达式的个数4，该数组的4个元素d[0],d[1],d[2]和d[3]依次被初始化为’a’,’b’,’c’,和’d’。注意若没有给出数组的初始化选项，则表示数组长度的常量表达式不能省略。
第五条语句定义了一个含有8个元素的整型数组e，它的初始化数据项的个数为3，小于数组中元素的个数8，这是允许的，这种情况的初始化过程为：将利用初始化表对前面相应元素进行初始化，而对后面剩余的元素则自动初始化为常数0。数组e中的8个元素被初始化后得到的结果为：e[0]=1, e[1]=4, e[2]=7, e[3]e[7]=0。
第六条语句定义了一个字符数组f，它包含有10个字符元素，其中前5个元素被初始化为初值表所给的相应值，后5个元素被初始化为字符’\0’，对应数值为0。
第七条语句定义了一个布尔型数组g，它的数组长度为2*N+1，每个元素没有被初始化。
第八条语句定义了两个单精度型一维数组h1和h2，它们的数组长度分别为5和10。在一条变量定义语句中，可以同时定义任意多个简单变量和数组，每两个相邻定义项之间必须用逗号分开。
第九条语句定义了三个短整型简单变量x,y和z，其中x和y被初始化为1和2，定义了一个短整型数组w，它包含有四个元素，其中w[0]被初始化为25+x的值，即26，w[1]被初始化为-10，w[2]被初始化为x+2*y的值，即5，w[3]被初始化为44。
第十条语句是错误的数组定义，因为它既省略了数组长度选项，又省略了初始化选项，使系统无法确定该数组的大小，从而无法分配给它确定的存储空间。
3. 数组元素的访问
通过变量定义语句定义了一个数组后，用户便可以随时使用其中的任何元素。数组元素的使用是通过下标运算符[]指明和访问的，其中运算符左边为数组名，中间为下标。一个数组元素又称为下标变量，所使用的下标可以为常量，也可以为变量或表达式，但其值必须是整数，否则将产生编译错误。
假定a[n]为一个已定义的数组，则下面都是访问该数组的下标变量的合法格式：
(1) a[5] //下标为一个常数
(2) a[i] //下标为一个变量
(3) a[j++] //下标为后增1表达式
(4) a[2*x+1] //下标为一般表达式
假定在上述每个变量的下标表达式中，所使用的变量i,j和x的值分别为2,3和4，则a[i]对应的数组元素为a[2]，a[j++]对应的数组元素为a[3]，同时j的值被修改为4，a[2*x+1]对应的数组元素为a[9]。
使用一个下标变量同使用一个简单变量一样，可以对它赋值，也可以取出它的值。如：
(1) int a[5]={0,1,2,3,8}; //定义数组a并进行初始化
(2) a[0]=4; //把4赋给a[0]
(3) a[1]+=a[0]; //把a[0]的值4累加到a[1]，使a[1]的值变为5
(4) a[3]=3*a[2]+1; //把赋值号右边表达式的值7赋给a[3]
(5) cout<<a[a[0]]; //因a[0]=4，所以a[a[0]]对应的元素为a[4]，
//该语句输出a[4]的值8
C++语言对数组元素的下标值不作任何检查，也就是说，当下标值超出它的有效变化范围0n-1（假定n为数组长度）时，也不会给出任何出错信息。为了防止下标值越界（即小于0或大于n-1），则需要编程者对下标值进行有效性检查。如：
(1) int a[5];
(2) for(int i=0; i<5; i++) a[i]=i*i;
(3) for(i=0; i<5; i++) cout<<a[i]<<’ ’;
第一条语句定义了一个数组a，其长度为5，下标变化范围为04。第二条语句让循环变量i在数组a下标的有效范围内变化，使下标为i的元素赋值为i的平方值，该循环执行后数组元素a[0],a[1],a[2],a[3]和a[4]的值依次为0,1,4,9和16。第三条语句控制输出数组a中每一个元素的值，输出语句中下标变量a[i]中的下标i的值不会超出它的有效范围。如果在第三条语句中，用做循环判断条件的<表达式2>不是i<5，而是i<=5，则虽然a[5]不属于数组a的元素，但也同样会输出它的值，而从编程者角度来看是一种错误。由于C++系统不对元素的下标值进行有效性检查，所以用户必须通过程序检查，确保其下标值有效。
4. 程序举例
(1) #include<iostream.h>
void main()
{
int i, a[6];
for(i=0;i<6;i++) cin>>a[i];
for(i=5;i>=0;i--) cout<<a[i]<<' ';
cout<<endl;
}
在程序的主函数中首先定义了一个int型简单变量i和一个含有6个int型元素的数组a，接着使数组a中的每一个元素依次从键盘上得到一个相应的整数，最后使数组a中的每一个元素的值按下标从大到小的次序显示出来，每个值之后显示出一个空格，以便使相邻的元素值分开。
若程序运行时，从键盘上输入3,8,12,6,20,15这6个整数，则得到的输入和运行结果为：
3 8 12 6 20 15
15 20 6 12 8 3
(2) #include<iostream.h>
void main()
{
int a[8]={25,64,38,40,75,66,38,54};
int max=a[0];
for(int i=1;i<8;i++)
if(a[i]>max) max=a[i];
cout<<"max:"<<max<<endl;
}
在这个程序的主函数中，第一条语句定义了一个整型数组a[8]，并对它进行了初始化；第二条语句定义了一个整型变量max，并用数组a中第一个元素a[0]的值初始化；第三条语句是一个for循环，它让循环变量i从1依次取值到7，依次使数组a中的每一个元素a[i]同max进行比较，若元素值大于max的值，则就把它赋给max，使max始终保存着从a[0]a[i]元素之间的最大值，当循环结束后，max的值就是数组a中所有元素的最大值；第四条语句输出max的值。
在该程序的执行过程中，max依次取a[0],a[1]和a[4]的值，不会取其他元素的值。程序运行结果为：
max:75
(3) #include<iostream.h>
const int N=7;
void main()
{
double w[N]={2.6,7.3,4.2,5.4,6.2,3.8,1.4};
int i,x;
cout<<"输入一个实数:";
cin>>x;
for(i=0;i<N;i++)
if(w[i]>x) cout<<"w["<<i<<"]="<<w[i]<<endl;
}
此程序的功能是从数组a[N]中顺序查找出比x值大的所有元素并显示出来。若从键盘上输入的x值为5.0，则得到的程序运行结果为：
输入一个实数:5.0
w[1]=7.3
w[3]=5.4
w[4]=6.2
(4) #include<iostream.h>
const int M=10;
void main()
{
int a[M+1];
a[0]=1; a[1]=2;
int i;
for(i=2;i<=M;++i)
a[i]=a[i-1]+a[i-2];
for(i=0;i<M;++i)
cout<<a[i]<<',';
cout<<a[M]<<endl;
}
该程序首先定义数组a，并分别为数组元素a[0]和a[1]赋值1和2，接着依次计算出a[2]至a[M]的值，每个元素值均等于它的前两个元素值之和，最后按照下标从小到大的次序显示出数组a中每个元素的值。该程序运行结果为：
1,2,3,5,8,13,21,34,55,89,144