10.3 数组与指针

1. 10.3 数组与指针 一个变量有地址，一个数组包含若干元素，每个数组元素都在内存中占用存储单元，它们都有相应的地址。指针变量既然可以指向变量，当然也可以指向数组元素（把某一元素的地址放到一个指针变量中）。 所谓数组元素的指针就是数组元素的地址。

2. 10.3.1 指向数组元素的指针 定义一个指向数组元素的指针变量的方法，与以前介绍的指向变量的指针变量相同。 例如：int a[10]；//定义ａ为包含10个整型数据的数组 int*ｐ； //定义ｐ为指向整型变量的指针变量 对该指针变量赋值： p=&a[0]；  p=a; 把ａ[0]元素的地址赋给指针变量ｐ。也就是使ｐ指向ａ数组的第０号元素，如图：

3. 10.３.２通过指针引用数组元素 引用一个数组元素，可以用： （１） 下标法，如ａ［ｉ］形式； （２） 指针法，如*（ａ＋ｉ）或*（ｐ＋ｉ）。 其中ａ是数组名，ｐ是指向数组元素的指针变量，其初值ｐ＝ａ。 p+i  a+i  &a[i] *(p+i)  *(a+i)  a[i] p[i] 即以下几个语句等效： a[i]=10; *(p+i)=10; *(a+i)=10; p[i]=10;

4. 假设有一个ａ数组，整型，有10个元素。要输出各元素的值有三种方法： 例10.5 输出数组中的全部元素。 (1)下标法。 (2) 通过数组名计算数组元素地址，找出元素的值。 (3)用指针变量指向数组元素。 可否用多种方法读入数组元素值？如何实现？

5. 从键盘输入10个数到数组a： int a[10],i,*p=a,s=0; for(i=0;i<10;i++) scanf(“%d”,&a[i]); for(i=0;i<10;i++) scanf(“%d”,a+i); for(i=0;i<10;i++) scanf(“%d”,p+i);

6. 累加求和的各种用法： for(i=0;i<10;i++)s+=a[i]; for(i=0;i<10;i++)s+=*(a+i); for(i=0;i<10;i++)s+=*(p+i); for(i=0;i<10;i++)s+=p[i]; for(i=0;i<10;i++)s+=*p++; 等效于*(p++) for(p=a;p<a+10;p++)s+=*p;注意不能使用a++ 后两种用法效率高。

7. 例10.６ 通过指针变量输出ａ数组的１０个元素。 #include <stdio.h> void main（） ｛int*ｐ，ｉ，ａ[10]； 　ｐ=a； for（ｉ＝０；ｉ＜１０；ｉ＋＋） scanf（″％ｄ″，ｐ＋＋）； printf（″＼ｎ″）； p=a；//指针重新指向数组的第一个元素 for（ｉ＝０；ｉ＜１０；ｉ＋＋，ｐ＋＋ ） printf（″％ｄ″，*ｐ）； ｝

8. 10.３.3 用数组名作函数参数 在第8章8.7节中介绍过可以用数组名作函数的参数 如：void main（） { if（int arr[ ]，int ｎ）; int array［１０］； … ｆ（array，１０）； … ｝ void ｆ(int arr［　］，int ｎ) { … }

9. 例10.７ 将数组ａ中ｎ个整数按相反顺序存放。

10. #include <stdio.h> void main（） ｛ void inv（int ｘ［ ］，int ｎ）; int i,ａ[10]={3,7,9,11,0,6,7,5,4,2}; printf（″The original array:＼ｎ″）； for（i=0;i<10;i++） printf （″％ｄ，″，a[i]）； printf（″\ｎ″）； inv（ａ，10）； printf（″The array has been in verted：\ｎ″）； for（i=0;i<10;i++） printf （″％ｄ，″，a[i]）； printf （″\ｎ″）； ｝

11. A void inv（int ｘ［ ］，int ｎ） /*形参x是数组名*/ ｛int temp，ｉ，ｊ，ｍ=(n-1)/2； for（ｉ=０；ｉ＜＝ｍ；ｉ＋＋） ｛ ｊ＝ｎ－１－ｉ； temp＝ｘ［ｉ］； ｘ［ｉ］＝ｘ［ｊ］； ｘ［ｊ］＝temp； ｝ return； ｝ 运行情况如下： The original array： ３，７，９，１１，０，６，７，５，４，２ The array has been inverted： ２，４，５，７，６，０，１１，９，７，３

12. a与x共用同一片内存单元

13. 对刚才的程序可以作一些改动。将函数inv中的形参ｘ改成指针变量。对刚才的程序可以作一些改动。将函数inv中的形参ｘ改成指针变量。 B void inv（int *ｘ，int ｎ） /*形参x为指针变量*/ ｛int*ｐ，temp，*ｉ，*ｊ，ｍ=(ｎ-１)/２； ｉ＝ｘ；ｊ＝ｘ＋ｎ－１；ｐ＝ｘ＋ｍ； for（；ｉ＜＝ｐ；ｉ＋＋，ｊ－－） ｛temp＝*ｉ；*ｉ＝*ｊ；*ｊ＝temp；｝ return； ｝ int temp，*ｉ，*ｊ； ｉ＝ｘ；ｊ＝ｘ＋ｎ－１； for（；ｉ＜j；ｉ＋＋，ｊ－－） ｛temp＝*ｉ；*ｉ＝*ｊ；*ｊ＝temp；｝ return; 实际上，C编译都是将形参数组名作为指针变量来处理的。以上两种（A、B）形参表写法本质是等价的。

14. 如果有一个实参数组，想在函数中改变此数组中的元素的值，实参与形参的对应关系有以下４种情况： (1) 形参和实参都用数组名，如： void main（） void ｆ（int ｘ[]，int ｎ） ｛ int a[10]； { … … ｆ（ａ，１０）； } ｝

15. (2) 实参用数组名，形参用指针变量。如： void main（） void ｆ（int *ｘ，int ｎ） ｛int a[10]； { … … ｆ（ａ，１０）； } ｝ (3)实参形参都用指针变量。例如： void main（） void ｆ（int *ｘ，int ｎ） ｛int a[10] , *p=a; { … … ｆ（p，１０）； } ｝

16. (4) 实参为指针变量，形参为数组名。如： void main（） void ｆ（int x[ ]，int ｎ） ｛int a[10] ,*p=a； { … … f (p,10); } ｝ 如果用指针变量作实参，必须先使执针变量有确定值，指向已定义的单元。p240 以上四种方法，实质都是地址传递。

17. 例10．9 用选择法对10个整数按由大到小顺序排序。 #include <stdio.h> void main（） { void sort（int ｘ［ ］，int ｎ）; int*ｐ，ｉ，ａ［10］； ｐ＝ａ； for（ｉ＝０；ｉ＜１０；ｉ＋＋） scanf（″％ｄ″，ｐ＋＋）； ｐ＝ａ； sort（ｐ，１０）； for（ｐ＝ａ，ｉ＝０；ｉ＜１０；ｉ＋＋） ｛ｐｒｉｎｔｆ（″％ｄ″，*ｐ）；ｐ＋＋；｝ ｝

18. void sort（int ｘ[ ]，int ｎ） ｛ int ｉ，ｊ，ｋ，ｔ； for（ｉ＝０；ｉ＜ｎ－１；ｉ＋＋） 　｛ｋ＝ｉ； for（ｊ＝ｉ＋１；ｊ＜ｎ；ｊ＋＋） 　　ｉｆ（ｘ［ｊ］＞ｘ［ｋ］）　 ｋ＝ｊ； 　 ｉｆ（ｋ！＝ｉ） 　　｛ｔ＝ｘ［ｉ］； ｘ［ｉ］＝ｘ［ｋ］； ｘ［ｋ］＝ｔ；｝ 　 ｝ ｝ 分段排序？ main() { int a[10],j; for(j=0;j<10;j++)scanf(“%d”,a+j); sort(a,5); sort(a+5,5); for(j=0;j<10;j++)printf(“%5d”,a[j]); }

19. 10.3.4 多维数组与指针 用指针变量可以指向一维数组中的元素，也可以指向多维数组中的元素。从本质上说，多维数组的指针与一维数组的指针相同，但在概念上和使用上，多维数组的指针比一维数组的指针要复杂一些。 1. 多维数组元素的地址 例 : 定义int a［3］［4］={{1，3，5，7}，｛９，１１，１３，１５｝，｛１７，１９，２１，２３｝}； 则二维数组a是由3个一维数组所组成的。设二维数组的首行的首地址为２０００ ，则

21. 例10.１0 输出二维数组有关的值 #include <stdio.h> ＃define FROMAT″％ｄ，％ｄ＼ｎ″ void main（） ｛ int ａ[3][4]＝｛1，3，5，7，9，１１，１３， １５，１７，１９，２１，２３｝； printf（ＦＯＲＭＡＴ，ａ，*ａ）； printf（ＦＯＲＭＡＴ，ａ[0] , *（ａ＋０））； printf（ＦＯＲＭＡＴ，＆ａ[0]，＆ａ[0][0]）； printf（ＦＯＲＭＡＴ，ａ[1]，ａ＋１）； printf（ＦＯＲＭＡＴ，＆ａ[1][0]，*（ａ+１）+０）； printf（ＦＯＲＭＡＴ，ａ［２］，*（ａ＋２））； printf（ＦＯＲＭＡＴ，＆ａ［２］，ａ＋２）； printf（ＦＯＲＭＡＴ，ａ［１］［０］，*（*（ａ＋ １）＋０））； ｝

22. 某一次运行结果如下： １５８，１５８ (0行首地址和0行0列元素地址) １５８，１５８ (0行0列元素地址) １５８，１５８ (0行0首地址和0行0列元素地址) １６６，１６６ (1行0列元素地址和1行首地址) １６６，１６６ (1行0列元素地址) １７４，１７４ (2行0列元素地址) １７４，１７４ (2行首地址) ９，９ (1行0列元素的值)

23. 例：求数组a的所有元素之和,可有多种用法： for(i=0;i<3;i++) for(i=0;i<3;i++) for(j=0;j<4;j++) for(j=0;j<4;j++) s+=a[i][j]; s+=*(a[i]+j); for(i=0;i<3;i++) for(j=0;j<4;j++) s+=*(*(a+i)+j);

24. 2 . 指向多维数组元素的指针变量 (1) 指向数组元素的指针变量 例10.11 用指针变量输出二维数组元素的值 #include <stdio.h> void main（） ｛ int ａ[3][4]＝｛1,3,5,7,9,11,13,15,17,19,21,23｝； int*ｐ； for（ｐ＝ａ［０］；ｐ＜ａ［０］＋１２；ｐ＋＋） ｛ｉｆ（（ｐ－ａ［０］）％４＝＝０） printf（″＼ｎ″）； printf（″％４ｄ″，*ｐ）； ｝ ｝　　 运行结果如下： 1 3 5 7 9 11 13 15 19 21 23

25. (2) 指向由ｍ个元素组成的一维数组的指针变量 例10.13 输出二维数组任一行任一列元素的值 #include <stdio.h> void main ( ) ｛ int ａ［３］［４］＝｛1，3，5，7，9，11， 13，15，１７，１９，２１，２３｝； int （*ｐ）［４］，ｉ，ｊ； ｐ＝ａ； scanf（″ ｉ＝％ｄ，ｊ＝％ｄ″，＆ｉ，＆ｊ）； printf（″ａ［％ｄ，％ｄ］＝％ｄ＼ｎ″，ｉ， ｊ，*（*（ｐ＋ｉ）＋ｊ））； ｝ 运行情况如下： ｉ＝１，ｊ＝２↙（本行为键盘输入） ａ［１，２］＝１３

26. 3. 用指向数组的指针作函数参数 例10.13 有一个班，３个学生，各学４门课，计算总平均分数以及第ｎ个学生的成绩。这个题目是很简单的。只是为了说明用指向数组的指针作函数参数而举的例子。用函数average求总平均成绩，用函数search找出并输出第ｉ个学生的成绩。

27. 思考两个形参p的区别，各自的应用场合及其优缺点？？？思考两个形参p的区别，各自的应用场合及其优缺点？？？ #include <stdio.h> void main（） { void average（float *p，int n）； void search（float (*p)［4］，int n)； float score［3］［4］={{65，67，70，60}，{80， 87，90，81}，{90，99，100，98}}; average（*score，12）；／*求12个分数的平均分*／ search（score，２）；／*求序号为２的学生的成绩*／ ｝ 必须为常量

28. void average（float *ｐ，int ｎ） { float*ｐ_ｅｎｄ； float sum＝０，aver； p_end＝ｐ＋ｎ－１； for（；ｐ＜＝ｐ_ｅｎｄ；ｐ＋＋） sum＝sum＋（*ｐ）； aver＝sum／ｎ； printf（″average＝％５．２ｆ＼ｎ″，aver）； ｝

29. void search（float (*ｐ)[4]，int ｎ） / * p是指向具有4个元素的一维数组的指针 */｛int ｉ； printf（″the score of No. %ｄ are：＼ｎ″，ｎ）； for（i=0；i<4；i++) printf（″%5.2f ″，*(*(p+n)+i)）； ｝ p[n][i] 程序运行结果如下： average＝８２．２５ The score of No.2 are： ９０.００　９９.００　１００.００　９８.００

30. 例10.１4 在上题基础上，查找有一门以上课程不及格的学生，打印出他们的全部课程的成绩。 #include <stdio.h> void main（） ｛void search（float (*p)［4］，int n）；/*函数声明*/ float score[3][4]={{65，57，70，60}，{58，87， 90，81}，{90，99，100，98}}; search（score，３）； ｝ 注意形参与实参类型的一致性

31. 程序运行结果如下： No.1 fails, his scores are： ６５.０ ５７.０ ７０.０ ６０.０ No.2 fails, his scores are： ５８.０ ８７.０ ９０.０ ８１.０ void search（float (*p)［4］，int ｎ） ｛int ｉ，ｊ，ｆｌａｇ； for（ｊ＝０；ｊ＜ｎ；ｊ＋＋) ｛flag＝０； for（ｉ＝０；ｉ＜４；ｉ＋＋) if（*（*（ｐ＋ｊ）＋ｉ）＜６０)flag＝１； if（ｆｌａｇ＝＝１） { printf("No.%d fails，his scores are:＼n"，j+1); for（ｉ＝０；ｉ＜４；ｉ＋＋） printf（″%5.1ｆ″，*(*(p+j)+i) )； printf（″＼ｎ″）； 　　 ｝ ｝ ｝ p[j][i]

32. 10.４ 字符串与指针 10.4.１字符串的表示形式 (1) 用字符数组存放一个字符串。例 10.15 (2) 用字符指针指向一个字符串。例10.16 #include <stdio.h> void main（） ｛char * string＝″I love China！″； printf（″％s\n″，string）； printf（ ″%c\n ″，*（string+3））； ｝

33. 例10.１7 将字符串ａ复制为字符串ｂ。 　也可以设指针变量，用它的值的改变来指向字符串中的不同的字符。 例10.１8 用指针变量来处理例10．１7问题。 #include <stdio.h> void main（） ｛char ａ[ ] =″I am a boy. ″，ｂ[20]，*p1，*p2； int ｉ； 　 ｐ１＝ａ；ｐ２＝ｂ； for（；*ｐ１！＝′＼０′；p1＋＋，p2＋＋）

34. *ｐ２＝*ｐ１； *ｐ２＝′＼０′； printf（″string ａ is：％ｓ＼ｎ″，ａ）； printf（″string ｂ is：″）； for（ｉ＝０；ｂ［ｉ］！＝′＼０′；ｉ＋＋） printf（″％ｃ″，ｂ［ｉ］）； printf（″＼ｎ″）； ｝ 程序必须保证使ｐ１和ｐ２同步移动

36. 10.4.2 字符指针作函数参数 (1) 用字符数组作参数 例10.19 用函数调用实现字符串的复制 #include <stdio.h> void main（） { void copy_string（char from［ ］， char to［ ］）; char a[ ]=″Ｉ am a teacher．″； char ｂ[ ]=″you are a student．″； printf(“string a=％ｓ＼ｎ string ｂ＝％ｓ＼ｎ″，ａ，ｂ)； printf(“copy string a to string b:\n ”)； copy_string （ａ，ｂ）； printf("＼nstring a=%s＼nstring b=%s＼n"，a，b); ｝

37. void copy_string（char from［ ］， char to［ ］） ｛ int ｉ＝０； while（from［ｉ］！＝′＼０′） 　｛to［ｉ］＝from［ｉ］；ｉ＋＋；｝ to［ｉ］＝′＼０′； ｝ 程序运行结果如下： string a＝I am a teacher． string b＝you are a student． copy string a to string b: string a ＝I am a teacher． stringｂ＝I am a teacher．

38. (2) 形参用字符指针变量 #include <stdio.h> void main（） { void copy_string（char * from， char *ｔｏ）; char *ａ＝″Ｉ am a teacher .″； char *ｂ＝″you are a student ．″； printf("string a=％ｓ\ｎstring ｂ=%ｓ\ｎ″,ａ,ｂ)； printf("copy string a to string b:\n "); copy_string（ａ，ｂ）； printf("＼nstring a=%s＼nstring b=%s＼n" ,a ,b); 　｝

39. void copy_string（char *from，char *to） ｛ for（；*from！＝′＼０′；from＋＋，to＋＋） 　　 *to＝*from； 　 *to＝′＼０′； ｝ (3) 对copy_string函数还可作简化 将copy_string函数改写为 void copy_string （char *from，char *to） ｛while（（*to＝*from）！＝′＼０′） ｛to＋＋；from＋＋；｝ ｝

40. • copy_string函数的函数体还可改为 ｛ while（（*to＋＋＝*from＋＋）！＝′＼０′）； ｝ •copy_string函数的函数体还可写成 { while（*from！＝′＼０′） 　　*to＋＋＝*from＋＋； 　 *to＝′＼０′； ｝

41. •上面的while语句还可以进一步简化为下面的while语句：•上面的while语句还可以进一步简化为下面的while语句： while（*to＋＋＝*from＋＋）； 它与下面语句等价： while（（*to＋＋＝*from＋＋）！＝′＼０′）； 将*from赋给*to，如果赋值后的*to值等于′＼０′则循环终止（′＼０′已赋给*to） •函数体中while语句也可以改用for语句： for（；（*to＋＋＝*from＋＋）！＝０；）； 或 for（；*to＋＋＝*from＋＋；）；

42. •也可用指针变量，函数copy_string可写为 void copy_string （char from［ ］，char to［ ］） ｛char*ｐ１，*ｐ２； ｐ１＝from；ｐ２＝ｔｏ； while（（*p2＋＋＝*p1＋＋）！＝′＼０′）； ｝ •甚至，函数copy_string可写为 void copy_string （char from［ ］，char to［ ］） ｛while（（*to＋＋＝*from＋＋）！＝′＼０′）； ｝

43. 10.4.3 对使用字符指针变量和字符数组的讨论 字符数组和字符指针变量二者之间的区别： (1) 字符数组由若干个元素组成，每个元素中放一个字符，而字符指针变量中存放的是地址（字符串第1个字符的地址），决不是将字符串放到字符指针变量中。 (2)赋值方式。对字符数组只能对各个元素赋值，不 能用以下办法对字符数组赋值。 char str［１４］； str＝″I love China！″； 而对字符指针变量，可以采用下面方法赋值： char*ａ； ａ＝″I love China！″；

44. (3)对字符指针变量赋初值： char *ａ＝″Ｉ love China！″；等价于 char*ａ； ａ＝″I love Chian！″； 而对数组的初始化： char str［１４］＝｛″Ｉ love China！″｝; 不能等价于 char str［１４］； str［ ］＝″I love China！″；

45. (4) 定义了一个字符数组，在编译时为它分配内存单元，它有确定的地址。而定义一个字符指针变量时，给指针变量分配内存单元，在其中可以放一个字符变量的地址。 例如:char str［１０］； scanf（″％ｓ″，str）； 没有特定的指向 例如:char *a； scanf（″％ｓ″，a）； ×

46. (5) 指针变量的值是可以改变的，例如： 例10.２0　改变指针变量的值 #include <stdio.h> void main（） ｛char*ａ＝″I love China！″； ａ＝ａ＋７； printf（″％ｓ″，ａ）； ｝

47. 若定义了一个指针变量，并使它指向一个字符串，就可以用下标形式引用指针变量所指的字符串中的字符。例10.21: （6）用指针变量指向一个格式字符串，可以用它替代printf中的格式字符串。

48. 内存空间的动态分配 在程序设计中，对于要处理的批量数据，我们往往是选用数组作为存放这些数据的数据结构，然而，数组有一个明显的缺点，就是在定义数组时，其长度必须是常值，无法根据需要动态地定义。这样，在很多情况下，不是定义的数组长度不够，就是定义太长以至于浪费。 采用动态分配可以克服这一缺点，并且可以随时释放。

49. 动态分配内存空间步骤： ①定义一指针变量。 ②申请一片内存空间，并将其首地址赋给指针变量。此时便可通过指针变量访问这片内存。 ③用完后释放这片内存空间。 int *p; p=malloc(byte); …… free(p); //malloc函数的原形在stdio.h中。 //void * malloc(unsigned size);

50. 例：对n个学生的分数排序后输出。 #include “stdio.h” void sort(int *a, int n) { ……} main() { int *a,j,n; scanf(“%d”,&n); a=malloc(n*sizeof(int)); if(!a) exit(0); for(j=0;j<n;j++) scanf(“%d”,a+j); sort(a,n); for(j=0;j<n;j++) printf(“%5d”,a[j]); free(a); }