第八章 使用指针.

Presentation on theme: "第八章 使用指针."— Presentation transcript:

1 第八章 使用指针

2 主要内容 8.1 地址和指针的概念 8.2 变量的指针和指向变量的指针变量 8.3 通过指针引用数组 8.4 通过指针字符串
8.5 指向函数的指针 8.6 返回指针值的函数 8.7 指针数组和多重指针 8.8 动态内存分配与指向它的指针变量

3 8.1地址和指针的概念 内存区的每一个字节有一个编号，这就是“地址” 。如果在程序中定义了一个变量，在对程序进行编译时，系统就会给这个变量分配内存单元。 １、按变量地址存取变量值的方式称为“直接访问”方式 ｐｒｉｎｔｆ（″％ｄ″，ｉ）； ｓｃａｎｆ（″％ｄ″，＆ｉ）； ｋ＝ｉ＋ｊ；

4

5 2. 另一种存取变量值的方式称为“间接访问”的方式。即，将变量ｉ的地址存放在另一个变量中。
在Ｃ语言中，指针是一种特殊的变量，它是存放地址的。

6 指针和指针变量的定义： 一个变量的地址称为该变量的“指针”。
例如，地址2000是变量ｉ的指针。如果有一个变量专门用来存放另一变量的地址（即指针），则它称为“指针变量”。上述的i_pointer就是一个指针变量。

7 8.2 变量的指针和指向变量的指针变量 8.２.1 怎样定义指针变量 定义指针变量的一般形式为 基类型 *指针变量名；

8 下面都是合法的定义： float *pointer_３； char *pointer_４； 可以用赋值语句使一个指针变量得到另一个变 量的地址，从而使它指向一个该变量。 例如： pointer_１＝＆ｉ； pointer_２＝＆ｊ；

9 在定义指针变量时要注意两点： 指针变量前面的“*”，表示该变量的类型为指针型变量。 例: float *pointer_1； 指针变量名是pointer_1 ，而不是* pointer_1 。 (2) 在定义指针变量时必须指定基类型。 需要特别注意的是，只有整型变量的地址才能放到指向整型变量的指针变量中。下面的赋值是错误的∶ float a; int * pointer_1; pointer_1=&a;

10 ⑴ 指针变量中只能存放地址（指针），不要将一个 整数赋给一个指针变量。
在对指针变量赋值时需要注意两点： ⑴ 指针变量中只能存放地址（指针），不要将一个 整数赋给一个指针变量。 例: * pointer_1＝１００； /* pointer_1是指针变量,１００是整数，不合法 */ (2) 赋给指针变量的变是量地址不能是任意的类型，而只能是与指针变量的基类型具有相同类型的变量的 地址。

11 8.2.2 怎样引用指针变量 在引用指针变量时，可能有三种情况： ⑴给指针变量赋值。如： p=&a; ⑵引用指针变量的值。如：
printf(“%o”,p); ⑶引用指针变量指向的变量。 有关的两个运算符： ＆ 取地址运算符。 &a是变量a的地址。 * 指针运算符 （或称“间接访问”运算符），*p是指针变量p指向的对象的值。

12 printf（″%ｄ，%ｄ\ｎ″,*pointer_１, *pointer_２）；
例8.１ 通过指针变量访问整型变量 #include <stdio.h> void　main ( ) ｛ int ａ，ｂ； int*pointer_１， *pointer_２； ａ＝１００；ｂ＝１０； pointer_１＝＆ａ； /*把变量ａ的地址赋给 pointer_1 */ pointer_２＝＆ｂ； /*把变量ｂ的地址赋给 pointer_２ */ printf（″%ｄ，%ｄ\ｎ″,ａ,ｂ）； printf（″%ｄ，%ｄ\ｎ″,*pointer_１, *pointer_２）； ｝

13

14 例8 . 2 输入ａ和ｂ两个整数，按先大后小的顺序输出
ａ和ｂ。 #include <stdio.h> void main（） ｛ int *ｐ1，*ｐ2，*ｐ，ａ，ｂ； 　 scanf（″％ｄ，％ｄ″，＆ａ，＆ｂ）； 　ｐ1＝＆ａ；ｐ２＝＆ｂ； 　 if（ａ＜ｂ） 　｛ｐ＝ｐ１；ｐ１＝ｐ２；ｐ２＝ｐ；｝ 　printf（″ａ=％ｄ,ｂ=％ｄ\ｎ\ｎ″,ａ,ｂ）； printf（″max=％ｄ,min=％ｄ\ｎ″,*ｐ1,*ｐ2）； ｝

15 运行情况如下： ５，９↙ ａ＝５，ｂ＝９ ｍａｘ＝９，ｍｉｎ＝５ 当输入ａ＝５，ｂ＝９时，由于ａ＜ｂ，将ｐ１和ｐ２交换。交换前的情况见图（ａ），交换后见图（ｂ）。

16

17 8.２.3 指针变量作为函数参数 例8 . 3 对输入的两个整数按大小顺序输出 #include <stdio.h>
例 对输入的两个整数按大小顺序输出 #include <stdio.h> void main（） ｛void swap（int *ｐ１，int *ｐ２）; 　int ａ，ｂ； 　int *pointer_１，*pointer_２； scanf（″％ｄ，％ｄ″，＆ａ，＆ｂ）； 　pointer_１ ＝＆ａ； pointer_2 ＝＆ｂ； 　 if（ａ＜ｂ＝　swap（ pointer_１ ， pointer_2 ）； 　printf（″\ｎ％ｄ，％ｄ\ｎ″，ａ，ｂ）； 　 ｝

18 void swap（int *ｐ１，int *ｐ２）
｛ int temp； temp＝*ｐ1； *ｐ１＝*ｐ２； *ｐ２＝temp； ｝

19

20 #include <stdio.h> void main（）
例8.４输入3个整数ａ,ｂ,ｃ，要求按大小顺序将它们输出。 用函数实现改变这3个变量的值。 #include <stdio.h> void main（） ｛ void exchange（int *ｑ1， int *ｑ2， int *ｑ3）; 　 int ａ，ｂ，ｃ，*ｐ１，*ｐ２，*ｐ３； 　 scanf（″%ｄ，%ｄ，%ｄ″，&ａ, &ｂ, &ｃ）； 　ｐ１＝＆ａ；ｐ２＝＆ｂ；ｐ３＝＆ｃ； 　 exchange （ｐ１，ｐ２，ｐ３）； 　 printf（″＼ｎ％ｄ,％ｄ,％ｄ＼ｎ″,ａ,ｂ,ｃ）； ｝

21 void exchange（int *ｑ１， int *ｑ２， int *ｑ３）
｛ void swap（int *ｐｔ１， int *ｐｔ２）; if（*ｑ１＜*ｑ２） swap（ｑ１，ｑ２）； 　　if（*ｑ１＜*ｑ３） swap（ｑ１，ｑ３）； 　　if（*ｑ２＜*ｑ３＝ swap（ｑ２，ｑ３）； ｝ void swap（int *ｐｔ１， int *ｐｔ２） ｛int temp； temp＝*ｐｔ１； *ｐｔ１＝*ｐｔ２； *ｐｔ２＝temp；

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

23 例如：ｉｎｔ ａ［１０］； (定义ａ为包含１０个整型数据的数组) ｉｎｔ *ｐ； (定义ｐ为指向整型变量的指针变量)
可以用一个指针变量指向一个数组元素。 例如：ｉｎｔ ａ［１０］； (定义ａ为包含１０个整型数据的数组) ｉｎｔ *ｐ； (定义ｐ为指向整型变量的指针变量) ｐ＝＆ａ［０］； (把ａ［０］元素的地址赋给指针变量ｐ) 也就是使ｐ指向ａ数组的第０号元素 。

24

25 两个指针相减，如p1-p2 (只有p1和p2都指向同一数组中的元素时才有意义)。
8.3.2 指针的运算 Ｃ语言规定在指针指向数组元素时，可以对指针进行以下运算： 加一个整数(用+或+=)，如p+1 减一个整数(用-或-=)，如p-1 自加运算，如p++，++p 自减运算，如p--，--p 两个指针相减，如p1-p2 (只有p1和p2都指向同一数组中的元素时才有意义)。

26 如果指针变量p已指向数组中的一个元素，则ｐ＋１ 指向同一数组中的下一个元素，ｐ-１指向同一数组中 的上一个元素。
分别说明如下： 如果指针变量p已指向数组中的一个元素，则ｐ＋１ 指向同一数组中的下一个元素，ｐ-１指向同一数组中 的上一个元素。 (2) 如果p原来指向a[0]，执行++p后p的值改变了，在p的原值基础上加d，这样p就指向数组的下一个元素a[1]。 (3) 如果ｐ的初值为＆ａ[０]，则ｐ＋ｉ和ａ＋ｉ就是数组元素ａ［ｉ］的地址，或者说，它们指向ａ数组的第 ｉ个元素 。 *（ｐ＋ｉ）或*（ａ＋ｉ）是ｐ＋ｉ或ａ＋ｉ所指向的数组元素，即ａ［ｉ］。 (5) 如果指针变量p1和p2都指向同一数组，如执行p2-p1，结果是两个地址之差除以数组元素的长度。

27 8.３.3 通过指针引用数组元素 引用一个数组元素，可以用： （１） 下标法，如ａ［ｉ］形式；
　　（１） 下标法，如ａ［ｉ］形式； 　　（２） 指针法，如*（ａ＋ｉ）或*（ｐ＋ｉ）。其中ａ是数组名，ｐ是指向数组元素的指针变量，其初值ｐ＝ａ。 例8.5 输出数组中的全部元素 假设有一个ａ数组，整型，有１０个元素。要输出各元素的值有三种方法：

28 (1)下标法 #include <stdio.h> void main（） ｛ int ａ［１０］； 　 int　ｉ； 　for（ｉ＝０；ｉ＜１０；ｉ＋＋） 　　scanf（″％ｄ″，＆ａ［ｉ］）； 　 printf（″＼ｎ″）； 　　printf（″％ｄ″，ａ［ｉ］）； ｝

29 (2) 通过数组名计算数组元素地址，找出元素的值。
#include <stdio.h> void　main（） ｛ int ａ［１０］； 　 int ｉ； 　for（ｉ＝０；ｉ＜１０；ｉ＋＋ ） 　　scanf（″％ｄ″，＆ａ［ｉ］）； 　　printf（″＼ｎ″）； 　 for（ｉ＝０；ｉ＜１０；ｉ＋＋） 　　 printf（″％ｄ″，*（ａ＋ｉ））； 　 ｝

30 (3) 用指针变量指向数组元素。 #include <stdio.h> void main（） ｛ int ａ［１０］； 　 int *ｐ，ｉ； 　 for（ｉ＝０；ｉ＜１０；ｉ＋＋） 　 　 scanf（″％ｄ″，＆ａ［ｉ］）； 　 printf（″＼ｎ″）； 　 for（ｐ＝ａ；ｐ＜（ａ＋１０）；ｐ＋＋） 　　 printf（″％ｄ ″，*ｐ）； ｝

31 例8.６ 通过指针变量输出ａ数组的１０个元素。 #include <stdio.h> void main（） ｛ int*ｐ，ｉ，ａ［１０］； 　ｐ＝ａ； 　for（ｉ＝０；ｉ＜１０；ｉ＋＋ ） 　scanf（″％ｄ″，ｐ＋＋）； printf（″＼ｎ″）； for（ｉ＝０；ｉ＜１０；ｉ＋＋，ｐ＋＋ ） 　 printf（″％ｄ″，*ｐ）； ｝ 程序运行情况： ↙ 显然输出的数值并不是ａ数组中各元素的值

32 #include <stdio.h>
void 　main（） ｛ int*ｐ，ｉ，ａ［１０］； 　ｐ＝ａ； 　for（ｉ＝０；ｉ＜１０；ｉ＋＋） 　scanf（″％ｄ″，ｐ＋＋）； printg（″＼ｎ″）； p=a; 　 for（ｉ＝０；ｉ＜１０；ｉ＋＋，ｐ＋＋ ） 　 printf（″％ｄ″，*ｐ）； ｝ 程序运行情况： ↙

33 8.3.4 用数组名作函数参数 在第7章中介绍过可以用数组名作函数的参数。 如： void main（）
用数组名作函数参数 在第7章中介绍过可以用数组名作函数的参数。 如： void main（） {iｆ（int arr[]，int ｎ）; int array［１０］； ┇ ｆ（array，１０）； ｝ void ｆ(int arr［　］，int ｎ) { }

34 例8．７ 将数组ａ中ｎ个整数按相反顺序存放

35 #include <stdio.h>
void main（） ｛ void inv（int ｘ［ ］，int ｎ）; int ｉ，ａ［１０］＝｛３，７，９，１１，０， ６，７，５，４，２｝； 　printf（″The original array:＼ｎ″）； 　for（ｉ＝０；ｉ＜１０；ｉ＋＋） 　printf （″％ｄ，″，ａ［ｉ］）； 　printf（″＼ｎ″）； 　 inv （ａ，１０）； 　printf（″The array has been in verted：\ｎ″）； 　 for（ｉ＝０；ｉ＜１０；ｉ＋＋） 　 printf （″％ｄ，″，ａ［ｉ］）； 　 printf （″＼ｎ″）； ｝

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

37

38 对刚才的程序可以作一些改动。将函数inv中的形参ｘ改成指针变量。
#include <stdio.h> void main（） ｛void inv（int *ｘ，int ｎ）; int ｉ，ａ［１０］＝｛３，７，９，１１，０， ６，７，５，４，２｝； 　 printf（ ″The original array:＼ｎ″ ）； 　　 for（ｉ＝０；ｉ＜１０；ｉ＋＋） 　 printf （″％ｄ，″，ａ［ｉ］）； 　 printf （″＼ｎ″）； 　　 inv（ａ，１０）； 　 printf （ ″The array has been in verted：\ｎ″ ）； 　printf （″％ｄ，″，ａ［ｉ］）； 　printf （″＼ｎ″）；｝

39 void inv（int *ｘ，int ｎ） /*形参x为指针变量*/
｛intｐ，temp，*ｉ，*ｊ，ｍ＝（ｎ－１）／２； ｉ＝ｘ；ｊ＝ｘ＋ｎ－１；ｐ＝ｘ＋ｍ； for（；ｉ＜＝ｐ；ｉ＋＋，ｊ－－） ｛ｔemp＝*ｉ；*ｉ＝*ｊ；*ｊ＝temp；｝ 　return； ｝

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

41

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

43

44 (4) 实参为指针变量，形参为数组名。如： void main（） void ｆ（int x[ ]，int ｎ） ｛ｉｎｔ ａ［１０］,*p=a； { ┇ ┇ ｆ（p，１０）； } ｝

45 例8．8 用实参指针变量改写例8.７。 #include <stdio.h> void main（） { void inv（int *ｘ，int ｎ）; int ｉ，ａｒｒ［１０］，*ｐ＝ａｒｒ； printf（″The original array:\n ″）； for（ｉ＝０；ｉ＜１０；ｉ＋＋，ｐ＋＋） 　scanf（″％ｄ″，ｐ）； 　printf（″＼ｎ″）； ｐ＝ａｒｒ； inv（ｐ，１０）； /* 实参为指针变量 */ printf（″The array has been inverted ：＼ｎ″）； for（ｐ＝ａｒｒ；ｐ＜ａｒｒ＋１０；ｐ＋＋ ） printf（″％ｄ″，*ｐ）； printf（″＼ｎ″）； 　 ｝

46 void inv（int *ｘ，int ｎ） ｛intｐ，ｍ，temp，*ｉ，*ｊ； 　ｍ＝（ｎ－１）／２； ｉ＝ｘ；ｊ＝ｘ＋ｎ－１；ｐ＝ｘ＋ｍ； 　for（；ｉ＜＝ｐ；ｉ＋＋，ｊ－－） ｛ｔemp＝*ｉ；*ｉ＝*ｊ；*ｊ＝temp；｝ 　return； ｝

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

48 void sort（int ｘ[ ]，int ｎ）
for（ｉ＝０；ｉ＜ｎ－１；ｉ＋＋） 　｛ｋ＝ｉ； 　　for（ｊ＝ｉ＋１；ｊ＜ｎ；ｊ＋＋） 　　ｉｆ（ｘ［ｊ］＞ｘ［ｋ］）　 ｋ＝ｊ； 　 ｉｆ（ｋ！＝ｉ） 　　｛ｔ＝ｘ［ｉ］； ｘ［ｉ］＝ｘ［ｋ］； ｘ［ｋ］＝ｔ；｝ 　 ｝ ｝

49 8.3.5 通过指针引用多维数组 用指针变量可以指向一维数组中的元素，也可以指向多维数组中的元素。但在概念上和使用上，多维数组的指针比一维数组的指针要复杂一些。 1. 多维数组元素的地址 先回顾一下多维数组的性质,可以认为二维数组是“数组的数组”，例 : 定义int a［3］［4］={{1，3，5，7}，｛９，１１，１３，１５｝，｛１７，１９，２１，２３｝}； 则二维数组a是由3个一维数组所组成的。设二维数组的首行的首地址为２０００ ，则

50 表 示 形 式 含义 地 址 a 二维数组名，指向一维数组a[0］，即0行首地址 2000 a[0］, *(a+0), *a 0行0列元素地址 a+1，&a［1］ 1行首地址 2008 a［1］,*(a+1) 1行0列元素a[1][0]的地址 A[1]+2, *(a+1)+2, &a[1][2] 1行2列元素a[1][2] 的地址 2012 *(a[1]+2), *(*(a+1)+2), a[1][2] 1行2列元素a［1］［2］的值 元素值为13

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

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

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

54 #include <sydio.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，２）；／*求序号为２的学生的成绩*／ ｝

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

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

57 例8.１3 在上题基础上，查找有一门以上课程不及格的学生，打印出他们的全部课程的成绩。
#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，３）； ｝

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

59 (1) 用字符数组存放一个字符串，然后输出该字符串。
8.４ 通过指针引用字符串 8.4.１字符串的表示形式 (1) 用字符数组存放一个字符串，然后输出该字符串。 例 定义一个字符数组，对它初始化， 然后输出该字符串 #include <stdio.h> void main（） ｛char string［］＝″I love China！″； printf（″％ｓ＼ｎ″，string）； ｝

60 (2) 用字符指针指向一个字符串 可以不定义字符数组，而定义一个字符指针。用字符指针指向字符串中的字符。 例8.15 定义字符指针，使它指向一个字符串。 #include <stdio.h> void main（） ｛charstring＝″ I love China！″； 　printf（″％ｓ＼ｎ″，ｓｔｒｉｎｇ）； ｝

61 例8.16 将字符串ａ复制为字符串ｂ #include <stdio.h> void ｍａｉｎ（） ｛char ａ[ ]＝″Ｉ am a boy．″，ｂ[20]； int ｉ； for（ｉ＝０；*（ａ＋ｉ）！＝′＼０′；ｉ＋＋） 　　*（ｂ＋ｉ）＝*（ａ＋ｉ）； 　 　*（ｂ＋ｉ）＝′＼０′； printf（″string a is ：％ｓ＼ｎ″，ａ）； printf（″string b is：″）； for（ｉ＝０；ｂ［ｉ］！＝′＼０′；ｉ＋＋） 　 printf（″％ｃ″，ｂ［ｉ］）； printf（″＼ｎ″）； ｝

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

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

64

65 8.4.2 字符指针作函数参数 (1) 用字符数组作参数 例8.18 用函数调用实现字符串的复制
(1) 用字符数组作参数 例 用函数调用实现字符串的复制 #include <stdio.h> void main() {void copy_string(char *from, char *to); char *a="I am a teacher."; char b[]="You are a student."; char *p=b; printf("string a=%s\nstring b=%s\n",a,p); printf("copy string a to string b:\n "); copy_string(a,p); printf("\nstring a=%s\nstring b=%s\n",a,b); }

66 void copy_string(char *from, char *to)
{ for(;*from!='\0';from++,to++) {*to=*from;} *to='\0'; } 程序运行结果如下： 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．

67 对ｃｏｐｙ_ｓｔｒｉｎｇ函数还可以改写得更精练一
些，请分析以下几种情况： 1、将copy_string函数改写为 void copy_string （char *from，char *ｔｏ） ｛while（（*ｔｏ＝*from）！＝′＼０′） ｛to＋＋；from＋＋；｝ ｝ 2、 copy_string函数的函数体还可改为 ｛ while（（*to＋＋＝*from＋＋）！＝′＼０′）； ｝

68 3、copy_string函数的函数体还可写成
{ while（*from！＝′＼０′） 　　*to＋＋＝*from＋＋； 　 *to＝′＼０′； ｝ 4、由于字符可以用其ＡＳＣＩＩ码来代替所以函数体可简化为: ｛ｗｈｉｌｅ（*ｆｒｏｍ） *ｔｏ＋＋＝*ｆｒｏｍ＋＋； *ｔｏ＝′＼０′； ｝

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

70 7、也可以用字符数组名作函数形参，在函数中另定义两个指针变量p1,p2。函数ｃｏｐｙ_ｓｔｒｉｎｇ可写为
void copy_string （char from［ ］，char ｔｏ［ ］） ｛char*ｐ１，*ｐ２； ｐ１＝from；ｐ２＝ｔｏ； 　while（（*p2＋＋＝*p1＋＋）！＝′＼０′）； ｝ 8.4.3 对使用字符指针变量和字符数组的讨论 字符数组和字符指针变量二者之间的区别主要有以下几点：

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

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

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

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

75 (6) 若字符指针变量p指向字符串，就可以用指针变 量带下标的形式引用所指的字符串中的字符。如有：
char *a=″I love China!″; (7) 字符数组中各元素的值是可以改变的(可以对它们再赋值)，但字符指针变量指向的字符串中的内容是不可以被取代的(不能对它们再赋值)。如： char a[]=”House”; char *b=” House”; a[2]=’r’; /* 合法，r取代u */ b[2]=’r’; /* 非法，字符串常量不能改变 */

76 8.５ 指向函数的指针 什么是函数指针 如果在程序中定义了一个函数，在编译时，编译系统为函数代码分配一段存储空间，这段存储空间的起始地址（又称入口地址）称为这个函数的指针。 可以定义一个指向函数的指针变量，用来存放某一函数的起始地址，这就意味着此指针变量指向该函数。

77 8.5.2 用函数指针变量调用函数 如果想调用一个函数，除了可以通过函数名调用以外，还可以通过指向函数的指针变量来调用该函数。
例8．20 用函数求ａ和ｂ中的大者。 （1）通过函数名调用函数。

78 #include <stdio.h>
void　main（） ｛ int max（int，int）； 　 int ａ，ｂ，ｃ； printf("please enter a and b:"); 　scanf（″％ｄ，％ｄ″，＆ａ，＆ｂ）； ｃ＝ｍａｘ（ａ，ｂ）； 　printf（″ａ＝％ｄ，ｂ＝％ｄ，ｍａｘ＝％ｄ ″，ａ，ｂ，ｃ）； ｝ int max（int ｘ，int ｙ） ｛ int ｚ； if（ｘ＞ｙ）ｚ＝ｘ； 　　else ｚ＝ｙ； return（ｚ）； 运行情况如下： please enter a and b:3,8↙ a=3,b=8,max=8

79 (2)通过指针变量来访问它指向的函数。 将 程序改写为 #include <stdio.h> void　main（） {int max(int,int); int (*p)(int,int); int a,b,c; p=max; printf("please enter a anb b:"); scanf("%d,%d",&a,&b); c=(*p)(a,b); printf("a=%d,b=%d,max=%d\n",a,b,c);} int max(int x,int y) {int z; if(x>y) z=x; else z=y; return(z);}

80 例8.21 输入两个整数，然后让用户选择1或2，选1时调用max函数，输出二者中的大数，选1时调用min函数，输出二者中的小数。
#include <stdio.h> void ｍａｉｎ（） {int max(int,int); int min(int ,int); int (*p)(int,int); int a,b,c,n; printf("please enter a and b:"); scanf("%d,%d",&a,&b); printf("please choose 1 or 2:"); scanf("%d",&n); if (n==1) p=max;

81 else if (n==2) p=min; c=(*p)(a,b);
printf("a=%d,b=%d,",a,b); if (n==1) printf("max=%d\n",c); else printf("min=%d\n",c); } int max(int x,int y) {int z; if(x>y) z=x; else z=y; return(z); } int min(int x,int y) if(x<y) z=x; return(z);} 运行情况如下： please enter a and b: 4,9↙ please choose 1 or 2:1↙ a=3,b=8,max=8 再运行一次： please choose 1 or 2:2↙ a=3,b=8,min=3

82 8.5.3 用指向函数的指针作函数参数 函数指针变量常用的用途之一是把指针作为参数传递到其他函数。指向函数的指针也可以作为参数，以实现函数地址的传递，这样就能够在被调用的函数中使用实参函数。

83 实参函数名 f 　 　ｆ２ 　 　　 ↓ ↓ void fun（int (*x1)(int)，int (*x2)(int,int)） ｛ int ａ，ｂ，ｉ，ｊ； ａ＝（*ｘ１）（ｉ）； ／*调用ｆ１函数*／ ｂ＝（*ｘ２）（ｉ，ｊ）；／*调用ｆ２函数*／ ｝

84 例8.22 有两个整数ａ和ｂ，由用户输入1,2或3。如输入1，程序就给出ａ和ｂ中大者，输入2，就给出ａ和ｂ中小者，输入3，则求ａ与ｂ之和。
#include <stdio.h> void main（） {int max(int,int); /* 函数声明 */ int min(int,int); /* 函数声明 */ int add(int,int); /* 函数声明 */ int fun(int x,int y, int (*p)(int,int)); /* 函数声明 */ int a=34,b=-21,n; printf("please choose 1,2 or 3:"); scanf("%d",&n); if (n==1) fun(a,b,max); else if (n==2) fun(a,b,min); else if (n==3) fun(a,b,add); }　

85 int min(int x,int y) {int z; if(x<y)z=x; else z=y; printf("min=%d"); return(z);} int add(int x,int y) z=x+y; printf("sum=%d"); int fun(int x,int y,int (*p)(int,int)) {int resout; resout=(*p)(x,y); printf("%d\n",resout); } 运行情况如下： ①please choose 1,2 or 3: 1↙ ｍａｘ＝34 ②please choose 1,2 or 3: 2↙ ｍｉｎ＝２1 ③please choose 1,2 or 3: 3↙ ｓｕｍ＝13

86 8.６ 返回指针值的函数 一个函数可以带回一个整型值、字符值、实型值等，也可以带回指针型的数据，即地址。其概念与以前类似，只是带回的值的类型是指针类型而已。 这种带回指针值的函数，一般定义形式为 类型名 *函数名（参数表列）; 例如： ｉｎｔ　*ａ（int ｘ，int ｙ）;

87 例8.23 有若干个学生的成绩（每个学生有４门课程），要求在用户输入学生序号以后，能输出该学生的全部成绩。用指针函数来实现。
#include <stdio.h> void main（） ｛float *score［ ］［4］={{60，70，80，90}， {56，89，67，88}，{34，78，90，66}}; float*search（float (*pointer)［4］，int n）； float*ｐ； int ｉ，ｍ； printf（″enter the number of student：″）； scanf（″％ｄ″，＆ｍ）； printf（″The scores of No．％ｄ are：\ｎ″，ｍ）；

88 ｐ＝search（ｓｃｏｒｅ，ｍ）； 　for（ｉ＝０；ｉ＜４；ｉ＋＋＝ 　printf（″％５．２ｆ＼ｔ″，*（ｐ＋ｉ））； ｝ float * search（float (*ｐｏｉｎｔｅｒ)［4］，int ｎ） ｛ float *ｐｔ； ｐｔ＝*（ｐｏｉｎｔｅｒ＋ｎ）； return（ｐｔ）； 运行情况如下： enter the number of student：１↙ The scores of No. １ are：

89 8.7 指针数组和多重指针 8.7.1 指针数组的概念 一个数组，若其元素均为指针类型数据，称为指针数组，也就是说，指针数组中的每一个元素都相当于一个指针变量。 一维指针数组的定义形式为: 类型名数组名［数组长度］； 例如： ｉｎｔ*ｐ[４]；

90

91 例8.24 将若干字符串按字母顺序（由小到大）输出。
例 将若干字符串按字母顺序（由小到大）输出。 #include <stdio.h> #include <string.h> void main（） ｛void sort（char *name［ ］，int n）； void printf（char *name［ ］，int n）； 　 char *name［ ］={"Follow me"，"BASIC"，"Great Wall″，"FORTRAN"，"Computer design"}; 　 int ｎ＝５； 　sort（ｎａｍｅ，ｎ）； print（ｎａｍｅ，ｎ）； ｝

92 void sort（char *ｎａｍｅ［ ］，int ｎ）
for（ｉ＝０；ｉ＜ｎ－１；ｉ＋＋＝ 　｛ｋ＝ｉ； 　 for（ｊ＝ｉ＋１；ｊ＜ｎ；ｊ＋＋＝ 　if（strcmp（name[ｋ]，name[ｊ]）>0）ｋ=ｊ； 　 if（ｋ!＝ｉ） 　temp=name［i］; name［i］=name［k］; name［k］=temp;｝ 　 ｝ ｝

93 void print（char *ｎａｍｅ［ ］，int ｎ）
｛ｉｎｔ ｉ； 　ｆｏｒ（ｉ＝０；ｉ＜ｎ；ｉ＋＋） 　　 printf（″％ｓ＼ｎ″，ｎａｍｅ［ｉ］）； } 运行结果为： ＢＡＳＩＣ Computer design FORTRAN Follow me Great Wall

94 8.7.2 指向指针数据的指针 定义一个指向指针数据的指针变量： ｃｈａｒ**ｐ；
指向指针数据的指针 定义一个指向指针数据的指针变量： ｃｈａｒ**ｐ； ｐ的前面有两个*号。*运算符的结合性是从右到左，因此**ｐ相当于*（*ｐ），显然*ｐ是指针变量的定义形式。如果没有最前面的*，那就是定义了一个指向字符数据的指针变量。现在它前面又有一个*号，表示指针变量ｐ是指向一个字符指针变量的。*ｐ就是ｐ所指向的另一个指针变量。

95 例 使用指向指针数据的指针变量 #include <stdio.h> void main（） ｛char *name［］={"Follow me"，"BASIC"，"Great Wall″，"FORTRAN"，"Computer design"}; char **ｐ； int ｉ； for（ｉ＝０；ｉ＜５；ｉ＋＋） 　｛ｐ＝ｎａｍｅ＋ｉ； 　　 printf（″％ｓ＼ｎ″，*ｐ）； ｝

96 例8.26 一个指针数组的元素指向整型数据的简单例子
例 一个指针数组的元素指向整型数据的简单例子 #include <stdio.h> void main（） ｛int ａ［５］＝｛１，３，５，７，９｝； int *num［5］=｛&a［0］，&a［1］， &a［2］，&a［3］，&a［4］｝； int **ｐ，ｉ； ｐ＝ｎｕｍ； 　for（ｉ＝０；ｉ＜５；ｉ＋＋＝ 　｛ printf（″％ｄ ″，**ｐ）； ｐ＋＋； ｝

97 8.8 动态内存分配与指向它的指针变量 8.8.1 什么是内存的动态分配
8.8 动态内存分配与指向它的指针变量 8.8.1 什么是内存的动态分配 前面介绍过全局变量和局部变量，全局变量是分配在内存中的静态存储区的，非静态的局部变量(包括形参)是分配在内存中的动态存储区的，这个存储区是一个称为栈(stack)的区域。除此以外，C语言还允许建立内存动态分配区域，以存放一些临时用的数据，这些数据是临时存放在一个的特别的自由存储区，称为堆(heap)区。

98 8.8.2 怎样建立内存的动态分配 对内存的动态分配是通过系统提供的库函数来实现的，主要有以下4个函数: (1) ｍａｌｌｏｃ函数
　 对内存的动态分配是通过系统提供的库函数来实现的，主要有以下4个函数: (1) ｍａｌｌｏｃ函数 函数原型为 void *malloc(unsigned int size); 作用是在内存的动态存储区中分配一个长度为ｓｉｚｅ的连续空间。 (2)ｃａｌｌｏｃ函数 void *calloc（unsigned ｎ，unsigned ｓｉｚｅ）; 作用是在内存的动态存储区中分配ｎ个长度为ｓｉｚｅ的连续空间。

99 8.8.2 怎样建立内存的动态分配 (3)ｆｒｅｅ函数 函数原型为 void free（void *p）;
作用是释放由指针变量ｐ指向的动态空间，使这部分空间能被其他变量使用。 (4) realloc函数 void *realloc(void *p,unsigned int size); 如果已经通过malloc函数或calloc函数获得了临时分配域，想改变函数其大小，可以用recalloc函数重分配。

100 8.8.3 void指针类型 ｖｏｉｄ指针类型，允许定义一个基类型为ｖｏｉｄ的指针变量，它不指向任何具体的数据。请注意：不要把“指向void类型”理解为能指向“任何的类型”的数据，而应理解为“指向空类型”或“不指向确定的类型”的数据。在将它的值赋给另一指针变量时要进行强制类型转换使之适合于被赋值的变量的类型。例如: int a=3; /* 定义a为整型变量 */ int *p1=&a; /* 基类型为int型 */ void *p2; /* 基类型为void型 */ p2=(void )p1; /* 转换为void*类型然后赋值 */ printf(“%d”,*p1); /* 合法，输出a的值 */ printf(“%d”,*p2); /* 错误，p2是无指向的，不能指 向a */

101 例8.27 建立动态数组，输入5个学生的成绩，另外用一个
函数检查其中有无低于60分的，输出不合格的成绩。 #include <stdio.h> #include <stdlib.h> void main() { void check(int *); int *p1,i; void *p2; p2=malloc(5*sizeof(int)); p1=(int *)p2; for(i=0;i<5;i++) scanf("%d",p1+i); check(p1); free(p2); }

102 void check(int *p) { int i; printf("They are fail:"); for(i=0;i<5;i++) if (p[i]<60) printf("%d ",p[i]); printf("\n"); }