经典C语言 数组公开课一等奖省优质课大赛获奖课件

教学目标：本讲介绍C语言中数组定义和使用，其中重点介绍一维数组定义、引用、初始化，另外对二维数组定义、引用和初始化在文中也作了详细说明。要求大家熟练掌握一维数组使用，了解二维数组应用，灵活利用数组编程。本讲重点：１．一维数组定义、初始化及应用；２．数组元素引用方法：下标法、数组名法。３．字符串使用和字符串函数应用。本讲难点：１．利用指针实现对数组操作；２．二维数组应用。教学方法：理论教学与实践教学相结合。

5.1一维数组及指针5.2一维字符数组及指针5.3多维数组及指针5.4指针数组

5.5二级指针5.6

程序设计举例

第五章数组5.1一维数组及指针数组属于结构类型，数组是含有相同数据类型变量序列，序列中每个变量称为数组元素，数组元素用一个统一标识符“数组名”和其次序号“下标”来表示。数组能够是一维，也能够是多维。数组必须先定义后使用。

5.1.1.一维数组定义和初始化

1．一维数组定义

一维数组定义普通形式为：类型标识符数组名[常量表示式]其中，类型标识符表示数组数据类型，即数组元素数据类型，能够是任意数据类型，如整型、实型、字符型等。常量表示式能够是任意类型，普通为算术表示式，其值表示数组元素个数，即数组长度。数组名要遵照标识符取名规则。如：inta[10];定义了一个一维数组，数组名为a，数据类型为整型，数组中有10个元素，分别是：a[0],a[1],a[2],a[3],a[4],a[5],a[6],a[7],a[8],a[9]。

说明：①不允许对数组大小作动态定义。以下面对数组定义是错误。

intn=10; inta[n]; ②数组元素下标从0开始。如数组a中数组元素是从a[0]到a[9]。 ③C语言对数组元素下标不作越界检验。如：数组a中即使不存在数组元素a[10]，但在程序中使用并不作错误处理，所以在使用数组元素时要尤其小心。 ④数组在内存分配到存放空间是连续，数组元素按其下标递增次序依次占用对应字节内存单元。数组所占字节数为：sizeof(类型标识符)*数组长度。如数组a占用连续20个字节存放空间，为其分配内存见图5.1。

图5.1⑤在函数内或函数外能够同时定义多个数组，还能够同时定义数组和变量，如：

floata[10],b[20],c,d,*p;但在函数参数中一次只能定义一个数组。2．一维数组初始化

在定义数组同时，能够对数组全部元素或部分元素赋初值，称为数组初始化。①全部元素初始化。在对全部数组元素初始化时，能够不指定数组长度。如：下面对数组a初始化是等价：

inta[10]={0,1,2,3,4,5,6,7,8,9}; inta[]={0,1,2,3,4,5,6,7,8,9};a[0]到a[9]值分别为：0,1,2,3,4,5,6,7,8,9。

TurboC中，若数组存放类型为static，且没有初始化，编译系统自动对数组初始化，将数值型数组全部元素都初始化为0，将字符型数组全部元素都初始化为空(’\0’)。如：staticinta[10];/*数组元素a[0]到a[9]值都为0。*/②部分元素初始化。 部分元素初始化时，数组长度不能省略，而且是赋值给前面元素，没有被赋值数组元素，数值型数组时值为0，字符型数组时值为’\0’。如：inta[10]={1,2};/*a[0]值为1，a[1]值为2，a[2]到a[9]值都为0*/

5.1.2一维数组元素下标法引用

一维数组元素下标表示形式为：数组名[表示式]其中，表示式类型任意，普通为算术表示式，其值为数组元素下标。用下标法引用数组元素时，数组元素使用与同类型普通变量相同。 若有定义：inta[10]={1,2,3,4,5,6,7,8,9,10},i=3;则以下对数组元素引用都是正确：a[i]/*表示a[3]*/a[++i]/*表示a[4]*/a[3*2]/*下标6数组元素*/a[3.4]/*下标为实型数据，系统自动取整，表示a[3]*/

a[’b’-’a’]/*下标为表示式，表示式’b’-’a’值为1，表示a[1]*/a[4]+=10/*与a[4]=a[4]+10等价，表示将a[4]原值加10*/a[4]++/*与a[4]=a[4]+1等价，表示将a[4]原值加1*/【例5.1】将整型数组a中十个整型数逆序存放并输出。main(){inta[10],i,j,t;for(i=0;i<10;i++)/*输入10个整型数存入数组a中*/

scanf("%d",&a[i]);for(i=0,j=9;i<j;i++,j--)/*交换对称元素值，实现逆序*/{t=a[i];a[i]=a[j];a[j]=t;}for(i=0;i<10;i++)/*输出数组a中10个元素值*/

printf("%4d",a[i]);}〖运行结果〗：12345678910↙10987654321需要注意是数值型数组不能用数组名输入输出它全部元素，只能是单个元素输入，单个元素输出。如：例5.1中程序段：for(i=0;i<10;i++)scanf("%d",&a[i]);不能写成：

scanf("%d",a);例5.1中程序段：for(i=0;i<10;i++)printf("%4d",a[i]);不能写成：

printf("%d",a);5.1.3一维数组指针

C语言要求，数组存放空间首地址存放在数组名中，即数组名指向下标为0数组元素。由此可知数组名不但是一个标识名字，它本身又是个地址量。因为数组存放位置是系统分配，用户不能任意改变和设置，所以，表示数组存放起始位置数组名是个地址常量。另外，数组中每个元素都有地址，其表示形式为：&数组名[下标]，其值也是地址常量。如：数组a首地址为a或&a[0]，数组元素a[3]地址为&a[3]。需要说明是：即使数组名代表数组存放起始地址，但系统并不为数组名分配内存单元。另外，对数组名用取地址符“&”进行运算没有意义。

1．指向一维数组元素指针变量上面介绍了指向数组元素指针常量，C语言中还能够定义指向数组元素指针变量。指向一维数组元素指针变量定义与前面介绍指向变量指针变量定义相同。如：

int*p;定义p为指向整型变量指针变量，若有下面赋值语句：

p=&a[3];则把元素a[3]地址赋给指针变量p。也就是说，指针变量p指向数组a中下标为3元素。能够在定义指针变量同时，把数组元素地址初始化给指针变量。如：

inta[10]，*p=a；它等价于：inta[10]，*p；p=a；其作用是把数组a起始地址，即a[0]地址赋给指针变量p。需要注意是：指针变量类型必须与它指向数组元素类型一致。

2．指针运算除了上面介绍赋值运算外，指向一维数组元素指针，还能够进行以下运算：①指向数组元素指针能够加（减）一个整型数。假设p是指向数组元素指针，n是一个整型数，则：p±n含义是使p原值（地址）加（减）n个数组元素所占字节数，即p±n×d(其中d代表一个数组元素占用字节数，如：int型为2，float型为4)。若有定义：inta[10],*p;，则a+3实际代表a+3*2，即a+3指向a[3]；假如p指向a[2]，则p-1实际代表p-1*2，即p-1指向a[1]。由此可知，假如指针变量p值为&a[0]，则：&a[i]、a+i和p+i是等价，它们都表示数组元素a[i]地址。②指向数组元素指针变量能够进行自加自减运算，自加后指向原来指向元素下一个元素，自减后指向原来指向元素上一个元素。假如指针变量p指向a[2]，则++p指向a[3]，--p指向a[1]。需要注意是数组名是常量，不能进行自加自减运算。③若两个指针指向同一个数组元素，则两个指针能够进行减运算，其含义为两个指针之间数组元素个数。假如p指向a[2]，则q-a=2，2表示p和a之间有两个数组元素。④若两个指针指向同一个数组元素，则能够进行关系运算。假设p指向a[2]，则p>a为真，p>a+4为假。5.1.4一维数组元素指针法引用由前面介绍可知，若有定义：inta[10],*p=a;则&a[i]、(a+i)和(p+i)是等价，它们都表示数组元素a[i]地址。由此可得以下等价关系：a[i]、*(a+i)和*(p+i)等价。它们都表示下标为i数组元素。由此可知，一维数组元素除了能够用下标法引用外，还能够用指针法引用。

1．数组名法用数组名引用数组元素普通形式为： *(数组名+表示式) 其中，表示式类型任意，普通为算术表示式，其值为数组元素下标。

如：*(a+3-1)表示数组元素a[2]。

【例5.2】用数组名法实现例5.1。main(){inta[10],i,j,t;for(i=0;i<10;i++)scanf("%d",a+i);for(i=0,j=9;i<j;i++,j--){t=*(a+i);*(a+i)=*(a+j);*(a+j)=t;}for(i=0;i<10;i++)printf("%4d",*(a+i));}2．指针变量法用指针变量引用数组元素普通形式为： *(指针变量+表示式) 其中，指针变量为指向一维数组元素指针变量。表示式类型任意，普通为算术表示式。若指针变量指向下标为0数组元素，则表示式值就是要引用数组元素下标，不然要引用数组元素下标为：指针变量-数组名+表示式。 假如p指向a[3]，则以下用指针变量p对数组元素引用都是正确。

*p=10/*与a[3]=10等价*/ *(p+2*2)=20/*与a[7]=20等价*/ *p+=40/*与*p=*p+40等价*/【例5.3】用指针变量法实现例5.1。main(){inta[10],*i,*j,t;for(i=a;i<a+10;i++)scanf("%d",i);for(i=a,j=a+9;i<j;i++,j--){t=*i;*i=*j;*j=t;}for(i=a;i<a+10;i++)printf("%4d",*i);}在编译时，编译系统将下标表示法转换为数组名表示法，所以用下标法和数组名法执行效率是一样，但用指针变量法既简捷，又能提升效率。

指向数组元素指针变量也可用下标法表示数组元素，即*(p+i)和p[i]是等价。

在使用指针变量引用数组元素时，应注意以下几个情况：①*(p++)/*先用p指向元素值，然后p指向下一个元素*/②*(++p)/*p先指向下一元素，然后用p指向元素值*/③*(p--)/*先用p指向元素值，然后p指向上一个元素*/④*(--p)/*p先指向上一元素，然后用p指向元素值*/⑤*p++/*与*(p++)等价*/⑥*p--/*与*(p--)等价*/⑦(*p)++/*先用p指向元素值，然后将p指向元素值加1*/⑧(*p)--/*先用p指向元素值，然后将p指向元素值减1*/⑨++(*p)/*先将p指向元素值加1，然后再用p指向元素值*/⑩--(*p)/*先将p指向元素值减1，然后再用p指向元素值*/

【例5.4】

main(){inta[]={1,3,5};/*数组初始化，a[0]=1，a[1]=3，a[3]=5*/int*p;p=&a[1];/*p指向a[1]*/printf("*(p++)=%d\n",*(p++));/**(p++)=3*/printf("*p=%d\n",*p);/**p=5，p指向a[2]*/p=&a[1];/*p指向a[1]*/printf("*(++p)=%d\n",*(++p));/**(++p)=5*/printf("*p=%d\n",*p);/**p=5，p指向a[2]*/p=&a[1];/*p指向a[1]*/printf("*(p--)=%d\n",*(p--));/**(p--)=3*/printf("*p=%d\n",*p);/**p=1,p指向a[0]*/

p=&a[1];/*p指向a[1]*/printf("*(--p)=%d\n",*(--p));/**(--p)=1*/printf("*p=%d\n",*p);/**p=1,p指向a[0]*/p=&a[1];/*p指向a[1]*/printf("*p++=%d\n",*p++);/**p++=3*/printf("%d\n",*p);/**p=5,p指向a[2]*/p=&a[1];/*p指向a[1]*/printf("*p--=%d\n",*p--);/**p--=3*/printf("*p=%d\n",*p);/**p=1,p指向a[0]*/p=&a[1];/*p指向a[1]*/printf("(*p)++=%d\n",(*p)++);/*(*p)++=3*/printf("*p=%d\n",*p);/**p=4,即a[1]=4,p指向a[1]*/p=&a[1];/*p指向a[1]*/

printf("(*p)--=%d\n",(*p)--);/*(*p)--=4*/printf("*p=%d\n",*p);/**p=3,即a[1]=3,p指向a[1]*/p=&a[1];/*p指向a[1]*/printf("++(*p)=%d\n",++(*p));/*++(*p)=4*/printf("*p=%d\n",*p);/**p=4,即a[1]=4,p指向a[1]*/p=&a[1];/*p指向a[1]*/printf("--(*p)=%d\n",--(*p));/*--(*p)=3*/printf("*p=%d\n",*p);/**p=3,即a[1]=3,p指向a[1]*/}5.2一维字符数组及指针5.2.1一维字符数组定义和初始化

1．一维字符数组定义C语言中没有专门字符串变量，字符串存放和处理能够用字符数组来实现。一维字符型数组定义普通形式为：

char数组名[常量表示式]如：charstr[6];字符数组str有6个元素，分别为：str[0],str[1],str[2],str[3],str[4],str[5]。

字符数组中一个元素存放一个字符。如字符数组str只能存放6个字符。

2．一维字符数组初始化字符数组初始化时，能够用字符常量，也可用字符串常量，全部元素初始化时，数组长度能够省略。 ①用字符常量初始化 能够用字符常量对字符数组全部元素初始化。 如：charstr[3]={’U’,’S’,’A’};等价于下面初始化：charstr[]={’U’,’S’,’A’};字符数组str中有3个元素，str[0]值为’U’，str[1]值为’S’，str[2]值为’A’。见图5.2。图5.2也能够用字符常量对字符数组部分元素初始化。如：charstr[6]={’U’,’S’,’A’};字符数组str中有6个元素，str[0]值为’U’，str[1]值为’S’，str[2]值为’A’，未初始化元素str[3]、str[4]和str[5]值都为空(’\0’)。见图5.3。

②用字符串常量初始化

能够用字符串常量对字符数组全部元素初始化。如：charstr[]={"USA"};可将花括号省略，即写成：charstr[]="USA";等价于下面用字符常量初始化：charstr[]={’U’,’S’,’A’,

’\0’};。

字符数组str中有四个元素，str[0]值为’U’，str[1]值为’S’，str[2]值为’A’，str[3]值为’\0’。见图5.4。 由此可知，用字符串常量初始化字符数组时，字符数组长度最少要比字符串最大长度多一，最终一个元素用来存放字符串结束标志’\0’。 也能够用字符串常量对字符数组部分元素初始化。部分元素初始化时，长度不能省略。如：charstr[6]="USA";与下面用字符常量初始化等价：

charstr[6]={’U’,’S’,’A’,’\0’,’\0’,’\0’};

见图5.5。

图5.4图5.55.2.2字符数组输入和输出1．字符串输出函数—puts()普通调用格式：puts(str)其中，参数str能够是地址表示式(普通为数组名或指针变量)，也能够是字符串常量。功效：将一个以’\0’为结束符字符串输出到终端（普通指显示器），并将’\0’转换为回车换行。返回值：输出成功，返回换行符(ASCII码为10)，不然，返回EOF（-1）若有定义：charstr[]="China";

则：puts(str);输出结果为：China puts(str+2);输出结果为：ina

说明：①使用puts()函数函数前面要有文件包含： #include"stdio.h"或#include<stdio.h>②输出字符串中能够包含转义字符，并输出到第一个’\0’为止，并将’\0’转换为’\n’，即输出完字符串后回车换行。如：charstr[]="china\nliaoning\0jinzhou";输出结果为：china liaoning③puts()函数一次只能输出一个字符串。

2．字符串输入函数—gets()普通调用格式为：gets(str)

其中，参数str是地址表示式，普通是数组名或指针变量。功效：从终端（普通指键盘）输入一个字符串，存放到以str为起始地址内存单元。返回值：字符串在内存中存放起始地址，即str值。 如：charstr[20]; gets(a);把从键盘上输入字符串存放到字符数组str中。说明：①使用gets()函数函数前面要有文件包含：#include"stdio.h"或#include<stdio.h>②gets()函数一次只能输出一个字符串。③系统自动在字符串后面加一个字符串结束标志’\0’。

3．字符数组输出能够用两种方法输出字符数组：(1)单个字符输出。用格式输出函数printf()%c格式，或用字符输出函数putchar()。(2)将整个字符串一次输出。用格式输出函数printf()%s格式，或用字符串输出函数puts()。将整个字符串一次输出时要注意以下几点：①输出字符不包含字符串结束标志’\0’。②printf()%s格式输出项参数和puts()参数是地址表示式，而不是数组元素名。如：charstr[10]="China";printf("%s",str);/*输出：China*/ puts(str+2);/*输出：ina*/③假如数组长度大于字符串实际长度，也只输出到’\0’结束。④假如一个字符数组中包含一个以上’\0’，则碰到第一个’\0’

输出结束。如：charstr[10]="china\0usa"; printf("%s",str);输出结果为：china

4．字符数组输入字符数组输入也有两种方法：(1)单个字符输入。能够用格式输入函数scanf()%c格式，或用字符输入函数getchar()。(2)将整个字符串一次输入。能够用格式输入函数scanf()%s格式，或用字符串输入函数gets()。将整个字符串一次输入时要注意以下几点：①用scanf()%s格式不能输入含有空格字符串，碰到空格系统认为输入结束，所以用scanf()函数一次能输入多个不含空格字符串。用gets()函数能够输入含有空格字符串，但一次只能输入一个字符串。如：charstr1[12]; scanf("%s",str1); printf("%s",str1);数据输入：howareyou↙输出结果：how字符数组str1内容见图5.6。图5.6假如改为：charstr1[12]; gets(str1); printf("%s",str1);数据输入：howareyou↙输出结果：howareyou字符数组str1内容见图5.7。(□代表空格)图5.7假如改为：charstr1[4],str2[4],str3[4]; scanf("%s%s%s",str1,str2,str3); printf("%s\n%s\n%s",str1,str2,str3);数据输入：howareyou↙输出结果：how are you字符数组str1、str2和str3内容见图5.8。

②系统自动在最终一个字符后面加上一个字符串结束符’\0’。③scanf()%s格式输入项是数组名时，数组名前不能加取地址符“&”，因为数组名本身代表数组首地址。

5.2.3用字符数组实现字符串若字符串存放在字符数组中，对字符串中字符引用能够用下标法，也可用指针法。其引用形式和前面介绍一维数组元素引用相同。1．用下标法引用【例5.5】将一个字符串逆置后接到原串后面。#include"stdio.h"main(){charstr[81];inti,j;gets(str);i=0;while(str[i]!=’\0’)i++;

j=i;i--;while(i>=0){str[j]=str[i];i--;j++;}str[j]=

’\0’;puts(str);}〖运行结果〗：abc↙abccba

2．用数组名法引用【例5.6】将字符数组a中字符串复制到字符数组b。#include"stdio.h"main(){chara[81],b[81];inti=0;gets(a);while(*(a+i)!=’\0’){*(b+i)=*(a+i);i++;}*(b+i)=’\0’;puts(b);}〖运行结果〗：china↙china3．用指针变量法引用【例5.7】删除字符串尾部空格。#include"stdio.h"main(){charstr[80],*p;gets(str);p=str;while(*p)p++;p--;while(*p==’

’)p--;p++;*p=’\0’;printf("%s",str);}〖运行结果〗：abcd□□□□□↙abcd/*光标在d后一列上*/5.2.4用字符指针变量实现字符串

除了能用字符数组处理字符串外，还能够用字符指针变量。如：

char*str="china";等价于：

char*str; str="china";其含义为：定义了一个字符型指针变量str，并将字符串"china“首地址赋给它，即str指向字符串第一个字符“c”。【例5.8】#include"stdio.h"main(){char*p1="china";char*p2;puts(p1);p2=p1;puts(p2+2);}〖运行结果〗：chinaina即使用字符数组和字符指针变量都能实现对字符串处理，但它们之间是有区分，主要注意以下几点：①字符数组有若干个元素组成，每个元素中存放一个字符，而字符指针变量中存放是字符串首地址，而不是将字符串存放到指针变量中。②不能用赋值语句将一个字符串常量或字符数组直接赋给字符数组，但能够用赋值语句将一个字符串常量或字符数组首地址直接赋给指针变量。如有定义：charstr1[10]="china",str2[10],*p1,*p2;下面赋值是不正当：

str2=str1；str2="USA";

下面赋值是正当：p1=str1;/*把数组str1首地址赋给p1*/p2="USA";/*把字符串"USA"首地址赋给p2*/③使用数组名能够安全地把从键盘上输入字符串存放到字符数组中，但用未赋以地址值指针是危险。如：char*p;scanf("%s",p);即使普通也能运行，但有可能破坏其它程序。④使用字符指针变量处理字符串比用字符数组处理字符串节约内存。如：char*p="china";是把字符串常量"china"地址赋给指针变量p,而

charstr[]="china";是将字符串常量"china"拷贝到字符数组，"china"地址与数组str地址不一样。

5.2.5惯用字符串处理函数

在TurboC

string.h头文件中提供了一些专门用来处理字符串函数，下面介绍其中几个最惯用函数。1．字符串拷贝函数—strcpy()普通调用格式：strcpy(str1,str2)其中，str1是地址表示式（普通为数组名或指针变量）str2能够是地址表示式（普通为数组名或为指针变量），也能够是字符串常量。功效：将str2指向字符串拷贝到以str1为起始地址内存单元。返回值：str1值。 如：charstr1[40],str2[]="china"; strcpy(str1,str2); puts(str1);

输出结果为：china说明：①以str1开始内存单元必须定义足够大，方便容纳被拷贝字符串。②拷贝时连同字符串后面’\0’一起拷贝。③不能用赋值语句将一个字符串常量赋给一个字符数组，也不能将一个字符数组赋给另一个字符数组，只能用strcpy()函数处理。如：charstr1[10]="china",str2[10];下面赋值是不正当：

str2=str1；str2="USA";下面赋值是正当：

strcpy(str2,str1)；strcpy(str2,"USA");

2．字符串连接函数—strcat()

普通调用格式：strcat(str1,str2)其中，str1是地址表示式（普通为数组名或指针变量）。str2能够是地址表示式（普通为数组名或为指针变量），也能够是字符串常量。功效：把str2指向字符串连接到str1指向字符串后面。返回值：str1值。如：charstr1[40]="china",str2[]="beijing";strcat(str1,str2);puts(str1);输出结果为：chinabeijing说明： ①以str1开始内存单元必须定义足够大，方便容纳连接后字符串。 ②连接后，str2指向字符串第一个字符覆盖了连接前str1指向字符串结束符’\0’。只在新串最终保留一个’\0’。 ③连接后，str2指向字符串不变。

3．字符串比较函数—strcmp()普通调用格式：strcmp(str1,str2)其中，str1和str2能够是地址表示式（普通为数组名或指针变量），也能够是字符串常量。功效：比较两个字符串。返回值：假如两个字符串相等，返回值为0；假如不相等，返回从左侧起第一次不相同两个字符ASCII码差值。如：printf("%d\n",strcmp("acb","aCb");

输出结果为：32（’c’和’C’ASCII码差值）说明：①字符串比较是从左向右比较对应字符ASCII码值。②两个字符串比较不能用关系运算符，只能用strcmp()函数。③不能用strcmp()函数比较其它型数据。

4．测试字符串长度函数—strlen()普通调用格式：strlen(str)其中，str能够是地址表示式（普通为数组名或指针变量），也能够是字符串常量。功效：统计字符串str中字符个数（不包含结束符’\0’）。返回值：字符串中实际字符个数。如：charstr[10]="china"; printf("%d",stren(str));输出结果是5，不是10，也不是6。

5．字符串小写变大写函数—strupr()普通调用格式：strupr(str)其中，str能够是地址表示式（普通为数组名或指针变量），也能够是字符串常量。功效：将字符串中小写字母转换成大写字母。返回值：str值，即字符串首地址。如：puts(strupr("aB3c"));输出结果为：AB3C。6．字符串大写变小写函数—strlwr()普通调用格式：strlwr(str)其中，str能够是地址表示式（普通为数组名或指针变量），也能够是字符串常量。功效：将字符串中大写字母转换成小写字母。返回值：str值，即字符串首地址。如：puts(strupr("aB3c"));输出结果为：ab3c。【例5.9】有两个字符串，按由小到大连接在一起。#include"stdio.h"#include"string.h"main(){charstr1[20],str2[20],str3[60];gets(str1);gets(str2);if(strcmp(str1,str2)>0){strcpy(str3,str1);strcat(str3,str2);}else{strcpy(str3,str2);strcat(str3,str1);}puts(str3);}

〖运行结果〗China↙American↙AmericanChina3.3多维数组及指针

除了一维数组外，C语言还允许使用二维、三维等多维数组，数组维数没有限制。除了二维数组外，其它多维数组普通极少用到，所以下面重点介绍二维数组。

3.3.1二维数组定义和初始化

1．二维数组定义

二维数组定义普通形式为：类型标识符数组名[常量表示式1][常量表示式2]其中，常量表示式1值是行数，常量表示式2值是列数。 如：

inta[3][4];定义了一个整型二维数组，数组名为a，行数为3，列数为4，共有12个元素，分别为：a[0][0],a[0][1],a[0][2],a[0][3],a[1][0],a[1][1],a[1][2],a[1][3],a[2][0],a[2][1],a[2][2],a[2][3]。C语言中，对二维数组存放是按行存放，即按行次序依次存放在连续内存单元中。如二维数组a存放次序如图5.9所表示。

C语言对二维数组a处理方法是：把a看成是一个一维数组，数组a包含三元素：a[0]，a[1]，a[2]。而每个元素又是一个一维数组，各包含四个元素，如a[0]所代表一维数组又包含四个元素：a[0][0]，a[0][1]，a[0][2]，a[0][3]。见图3.10。

因为系统并不为数组名分配内存，所以由a[0]、a[1]、a[2]组成一维数组在内存并不存在，它们只是表示对应行首地址。C语言中，多维数组定义普通形式为：类型标识符

数组名[常量表示式1][常量表示式2]…[常量表示式n]

2．二维数组初始化①全部元素初始化全部元素初始化时，第一维长度，即行数能够省略，第二维长度，即列数不能省略。能够用花括号分行赋初值，也能够整体赋初值。如：以下初始化是等价：inta[3][4]={{1,2,3,4},{5,6,7,8},{9,10,11,12}};inta[][4]={{1,2,3,4},{5,6,7,8},{9,10,11,12}};inta[][4]={1,2,3,4,5,6,7,8,9,10,11,12};②部分元素初始化部分元素初始化时，若省略第一维长度，必须用花括号分行赋初值。没初始化元素，数值型数组时值为0，字符型数组时值为’\0’。如：以下初始化是等价：inta[3][4]={1,2,3,4,0,5};inta[3][4]={{1,2,3,4},{0,5}};inta[][4]={{1,2,3,4},{0,5}};见图5.11。下面是对二维字符型数组初始化：charstr[3][6]={"china","USA","japan"};三个一维数组str[0]，str[1]，str[2]各有6个元素，其值分别为：“china”、“USA”和“japan”。见图5.12。5.3.2二维数组元素下标法引用

数组元素在使用时与同类型普通变量相同，能够出现在表示式中，也能够被赋值。使用时要尤其注意下标范围。二维数组元素下标表示形式为：数组名[表示式1][表示式2]其中，表示式1和表示式2类型任意，普通为算术表示式。表示式1值是行标，表示式2值是列标。【例3.10】求3×4矩阵最小值，及其所在位置（行号和列号）。

main(){inta[][4]={{2,-8,20,0},{9,5,-38,-34},{10,32,4,-3}};inti,j,row,col,min;min=a[0][0];row=0;col=0;for(i=0;i<3;i++)for(j=0;j<4;j++)if(min>a[i][j]){min=a[i][j];row=i;col=j;}printf("min=%d,row=%d,col=%d",min,row,col);}〖运行结果〗：min=-38,row=1,col=25.3.3二维数组指针C语言要求，二维数组数组名代表整个二维数组首地址，二维数组数组名加1是加一行元素所占字节数。二维数组元素地址能够经过取地址符“&”得到，其普通形式为：&数组名[行标][列标]设有定义：inta[3][4];，则a代表整个二维数组首地址，a+i(0≤i≤2)是第i行首地址。数组元素a[i][j](0≤i≤2，≤j≤3)地址为：&a[i][j]。依据前面介绍二维数组处理方法可知，a是由a[0]、a[1]和a[2]三个元素组成一维数组数组名，而每个元素a[i](0≤i≤2)又是由四个元素组成一维数组数组名，所以由一维数组元素数组名表示法能够得到以下等价关系：①*(a+i)与a[i]是等价，代表一维数组a[i]首地址，即第i行首地址。②a[i]+j，*(a+i)+j与&a[i][j]是等价(0≤j≤3)，代表数组元素a[i][j]地址。

1．指向数组元素指针变量

指向二维数组元素指针变量定义与指向变量指针变量定义相同。如：

int*p;定义p为指向整型变量指针变量，若有下面赋值语句：

p=a[0];则把元素a[0][0]地址赋给指针变量p，也就是说，指针变量p指向数组元素a[0][0]。

2．指向由m个元素组成一维数组指针变量指向数组元素指针变量加（减）1，是加（减）一个数组元素所占字节数，指向元素是原来指向元素下（上）一个元素。C语言中，也能够定义指向由m个元素组成一维数组指针变量，指针变量加（减）1，是加（减）整个一维数组所占字节数，其定义普通形式为：类型标识符(*指针变量名)[常量表示式]如：int(*p)[4];其含义为：p是一个指针变量，它指向包含4个整型元素一维数组。p值加（减）1，是加（减）4个整型数据所占字节数。用这种类型指针变量能够指向二维数组中一行，这时m就是二维数组列数。若有赋值语句：p=a;则p+i(0≤i≤2)是一维数组a[i]首地址。由此可得到以下等价关系：①*(a+i)，*(p+i)和a[i]是等价，即第i行首地址。②a[i]+j，*(a+i)+j，*(p+i)+j和&a[i][j]是等价(0≤j≤3)，即数组元素a[i][j]地址。5.3.4二维数组元素指针法引用1．利用一维数组数组名引用二维数组元素因为a[i]+j和&a[i][j]是等价，所以*(a[i]+j)和a[i][j]是等价，其中a[i]是第i行一维数组数组名。所以，能够用一维数组名引用二维数组中元素。其引用普通形式为：*(一维数组名+表示式)其中，表示式类型任意，普通为算术表示式，其值为二维数组元素列标。如：*(a[1]+2-1)表示二维数组元素a[1][1]。另外，因为二维数组在内存中是按行连续存放，所以能够把二维数组a看成是数组名为a[0]一维数组，二维数组元素a[i][j]对应一维数组元素是:*(a[0]+i*列数+j)。如：*(a[0]+2*4+1)表示二维数组元素a[2][1]。【例5.11】输出行标为1、列标为2数组元素和行标为2、列标为1数组元素。main(){inta[3][4]={1,3,5,7,9,11,13,15,17,19,21,23};printf("%4d",*(a[1]+2));printf("%4d\n",*(a[0]+2*4+1));}〖运行结果〗13192．利用指向二维数组元素指针变量引用数组元素

用指向二维数组元素指针变量引用二维数组元素普通形式为： *(指针变量+表示式)其中，指针变量是指向二维数组元素指针变量。表示式类型任意，普通为算术表示式。若指针变量指向行标和列标都为0数组元素，则引用二维数组元素行标为：(表示式)/列数，列标为：(表示式)%列数；不然引用二维数组元素行标为：(指针变量-数组名[0]+表示式)/列数，列标为：(指针变量-数组名[0]+表示式)%列数。

【例5.12】按行输出二维数组中元素值。main(){inta[3][4]={1,3,5,7,9,11,13,15,17,19,21,23};int*p;for(p=&a[0][0];p<&a[0][0]+12;p++){if((p-a[0])%4==0)printf("\n");printf("%4d",*p);}} 〖运行结果〗： 1357 9111315 171921233．利用二维数组名引用数组元素*(a+i)+j和&a[i][j]等价*(*(a+i)+j)和a[i][j]等价。所以，能够利用二维数组数组名引用二维数组中元素。其引用普通形式为：*(*(数组名+表示式1)+表示式2)其中，表示式1和表示式2类型任意，普通为算术表示式。表示式1值是行标，表示式2值是列标。【例5.13】计算4×4阶矩阵周围元素值之和。main(){inta[4][4],i,j,sum;sum=0;for(i=0;i<4;i++)for(j=0;j<4;j++)scanf("%d",*(a+i)+j);for(i=0;i<4;i++)for(j=0;j<4;j++)if(i==0||i==3||j==0||j==3)sum+=*(*(a+i)+j);printf("sum=%d\n",sum);}〖运行结果〗：12345678910111213141516sum=1024．利用指向由m(二维数组列数)个元素组成一维数组指针变量引用二维数组元素由前面讨论可知，若有定义：inta[3][4],(*p)[4]=a;则*(p+i)+j和&a[i][j]等价，由此可得，*(*(p+i)+j)和a[i][j]等价。所以，二维数组元素能够用指向由多个元素组成一维数组指针变量引用，其普通形式为：*(*(指针变量+表示式1)+表示式2)其中，指针变量是指向一维数组指针变量，指向二维数组中某一行。表示式1和表示式2类型任意，普通为算术表示式。表示式2值为要引用二维数组元素列标。若指针变量指向第一行，则表示式1值为要引用二维数组元素行标；不然，要引用二维数组元素行标为：指针变量-二维数组名+表示式1若有定义：inta[3][4],(*p)[4]=a+1;，则*(*(p+1)+3-1)表示数组元素a[2][2]。

【例5.14】输出4×4阶矩阵任意一个元素值main(){inta[3][4]={{1,2,3,4},{5,6,7,8},{9,10,11,12}};introw,col,(*p)[4];p=a;scanf("row=%d,col=%d",&row,&col);printf("a[%d][%d]=%d\n",row,col,*(*(p+row)+col));}〖运行结果〗：row=2,col=1↙a[2][1]=10*(*(p+i)+j)与*(p[i]+j)和p[i][j]等价

5.4指针数组

元素为指针类型数组称为指针数组，也就是说，指针数组中每个元素都是指针变量。指针数组定义形式为：类型标识符*数组名[常量表示式]如：int*p[4];定义了一个指针数组，数组名为p，它有4个元素，每个元素都是指向整型变量指针变量。注意以下三种定义区分：

intp[4]; int(*p)[4]; int*p[4];

和普通数组一样，指针数组在内存中分配连续存放空间，指针数组也能够初始化。指针数组元素在使用时与同类型指针变量相同。【例5.15】将5个字符串按由小到大次序输出#defineN5#include"string.h"main(){char*name[]={"China","Japan","USA","Russia","Canda"};char*temp;inti,j;for(i=0;i<N-1;i++)for(j=i+1;j<N;j++)if(strcmp(name[i],name[j])>0){temp=name[i];name[i]=name[j];name[j]=temp;}for(i=0;i<N;i++)printf("%s\n",name[i]);}〖运行结果〗：

Canda China Japan RussiaUSA此程序处理方法是：将字符串地址按字符串由小到大次序重新存放到指针数组name中，即交换是字符串地址，而不是字符串本身。排序前后指针数组name内容见图5.13（a）和5.13（b）。

图5.13（a）交换前图5.13（a）交换后5.5二级指针在例5.14中，定义了一个指针数组name，它元素是指针类型，其值为地址。既然name是数组，它每一个元素都有对应地址，name+i(0≤i≤4)是数组元素name[i]地址。name+i就是指向数组元素name[i]指针，name+i就是指向name[i]所指向对象二级指针(指针常量)。见图5-13(a)。我们还能够定义指向指针变量指针变量，其定义普通形式为： 类型标识符**变量名；如：

char**p;p是指向字符型指针变量指针变量，即指针变量p存放内容是另一个字符型指针变量地址。 二级指针变量能够初始化，如：

char**p=name;等价于

char**p; p=name;把指针数组name首地址赋给指针变量p，即p指向name[0]。

使用二级指针变量能够存取和处理数据，在使用时，要注意其使用方法，如：

inta=3,*p=&a;**pp=&p; printf("a=%d,*p=%d,**pp=%d",a,*p,**pp);输出结果：a=3,*p=3,**pp=3【例5.16】用二级指针变量实现例5.15。#defineN5#include"string.h"main(){char*name[]={"China","Japan","USA","Australia","Canda"};char*temp;char**i,**j;for(i=name;i<name+N-1;i++)for(j=i+1;j<name+N;j++)if(strcmp(*i,*j)>0){temp=*i;*i=*j;*j=temp;}for(i=name;i<name+N;i++)printf("%s\n",*i);}〖运行结果〗：见例5.155.6程序设计举例

【例5.17】用选择排序法将数组a中N个整型数升序排序并输出。选择排序法思想是：第一步从N个元素中找出值最小元素，将其与第一个元素值交换。第二步从剩下N-1元素中找出值最小元素，将其与第二个元素值交换。如此下去，直到剩下一个最大数在第N个元素中