指针【C语言课件】

《指针【C语言课件】》由会员分享，可在线阅读，更多相关《指针【C语言课件】（88页珍藏版）》请在金锄头文库上搜索。

1、指指 针针& 指针变量的声明和初始化指针变量的声明和初始化指针变量的声明和初始化指针变量的声明和初始化& 指针运算符指针运算符指针运算符指针运算符& 函数的传引用调用函数的传引用调用函数的传引用调用函数的传引用调用& 对指针使用对指针使用对指针使用对指针使用const const 限定符限定符限定符限定符& 使用传引用调用的泡沫排序法使用传引用调用的泡沫排序法使用传引用调用的泡沫排序法使用传引用调用的泡沫排序法& 指针表达式和指针的算术运算指针表达式和指针的算术运算指针表达式和指针的算术运算指针表达式和指针的算术运算& 指针和数组的关系指针和数组的关系指针和数组的关系指针和数组的关系& 指针数

2、组指针数组指针数组指针数组& 实例研究实例研究实例研究实例研究& 指向函数的指针指向函数的指针指向函数的指针指向函数的指针指针变量的声明和初始化指针变量的声明和初始化uu 本章要讨论本章要讨论本章要讨论本章要讨论C C 语言功能最强大的特点之一语言功能最强大的特点之一语言功能最强大的特点之一语言功能最强大的特点之一 指针。指针指针。指针指针。指针指针。指针是是是是C C 语言中最难掌握的概念语言中最难掌握的概念语言中最难掌握的概念语言中最难掌握的概念。指针能够模拟传引用调用，并指针能够模拟传引用调用，并指针能够模拟传引用调用，并指针能够模拟传引用调用，并且能够建立和操作动态数据结构（即能够增长

3、和缩小的数据且能够建立和操作动态数据结构（即能够增长和缩小的数据且能够建立和操作动态数据结构（即能够增长和缩小的数据且能够建立和操作动态数据结构（即能够增长和缩小的数据结构）。本章介绍指针的基本概念结构）。本章介绍指针的基本概念结构）。本章介绍指针的基本概念结构）。本章介绍指针的基本概念7 7countcount7 7countcountCount Count 直接直接直接直接引用一个值引用一个值引用一个值引用一个值为为为为7 7 的变量的变量的变量的变量 countPtrcountPtrcountPtr countPtr 间间间间接引用一个接引用一个接引用一个接引用一个值为值为值为值为 7

4、7 的变的变的变的变量量量量 图图图图7. 1 7. 1 直接和间接引用一个变量直接和间接引用一个变量直接和间接引用一个变量直接和间接引用一个变量uu 指针是把内存地址作为其指针是把内存地址作为其指针是把内存地址作为其指针是把内存地址作为其值的变量值的变量值的变量值的变量uu 变量通常直接包含一个具变量通常直接包含一个具变量通常直接包含一个具变量通常直接包含一个具体的值，而指针包含的是拥体的值，而指针包含的是拥体的值，而指针包含的是拥体的值，而指针包含的是拥有具体值的变量的地址。从有具体值的变量的地址。从有具体值的变量的地址。从有具体值的变量的地址。从这个意义上说这个意义上说这个意义上说这个意

5、义上说, , , ,变量名直接引变量名直接引变量名直接引变量名直接引用了一个值，而指针是间接用了一个值，而指针是间接用了一个值，而指针是间接用了一个值，而指针是间接地引用了一个值（见图地引用了一个值（见图地引用了一个值（见图地引用了一个值（见图7.17.1）。通过指针引用某个值称为）。通过指针引用某个值称为）。通过指针引用某个值称为）。通过指针引用某个值称为“ “间间间间接引用接引用接引用接引用” ”uu 和其他变量一样，指针（有时也称作和其他变量一样，指针（有时也称作和其他变量一样，指针（有时也称作和其他变量一样，指针（有时也称作指针变量指针变量指针变量指针变量）必须在使）必须在使）必须在使

6、）必须在使用前声明用前声明用前声明用前声明指针变量的声明和初始化指针变量的声明和初始化uu 声明语句声明语句声明语句声明语句uu int *countPtr, count; int *countPtr, count; int *countPtr, count; int *countPtr, count;uu声明了声明了声明了声明了int * int * int * int * 类型的的变量类型的的变量类型的的变量类型的的变量countPtr,countPtr,countPtr,countPtr,即声明了一个指向即声明了一个指向即声明了一个指向即声明了一个指向int int int int 型值

7、的指针在这里，型值的指针在这里，型值的指针在这里，型值的指针在这里，int int int int 是相应指针的基类型，读是相应指针的基类型，读是相应指针的基类型，读是相应指针的基类型，读法为法为法为法为“countPtr “countPtr “countPtr “countPtr 是一个指向是一个指向是一个指向是一个指向int int int int 型整数值的指针，或型整数值的指针，或型整数值的指针，或型整数值的指针，或“countPtr “countPtr “countPtr “countPtr 指向整数类型值指向整数类型值指向整数类型值指向整数类型值 。注意：出现在该语句中的。注意：出

8、现在该语句中的。注意：出现在该语句中的。注意：出现在该语句中的变量变量变量变量count count count count 被声明为是一个被声明为是一个被声明为是一个被声明为是一个int int int int 型变量，而不是指向型变量，而不是指向型变量，而不是指向型变量，而不是指向int int int int 型型型型整数值的指针，声明语句中的整数值的指针，声明语句中的整数值的指针，声明语句中的整数值的指针，声明语句中的* * * * 只用于只用于只用于只用于countPtrcountPtrcountPtrcountPtr。在声明语。在声明语。在声明语。在声明语句中以这种方式使用句中以这

9、种方式使用句中以这种方式使用句中以这种方式使用* * * *表示被声明的变量是一个指针表示被声明的变量是一个指针表示被声明的变量是一个指针表示被声明的变量是一个指针uu 指针可被声明为指向任何数据类型指针可被声明为指向任何数据类型指针可被声明为指向任何数据类型指针可被声明为指向任何数据类型uu 间接引用运算符间接引用运算符间接引用运算符间接引用运算符 * * * * 不针对声明语句中的所有变量。每一不针对声明语句中的所有变量。每一不针对声明语句中的所有变量。每一不针对声明语句中的所有变量。每一个指针都必须在其名字前面用前缀个指针都必须在其名字前面用前缀个指针都必须在其名字前面用前缀个指针都必须

10、在其名字前面用前缀* * * *声明声明声明声明uu 在指针变量名中包含字母在指针变量名中包含字母在指针变量名中包含字母在指针变量名中包含字母Ptr Ptr Ptr Ptr 可清晰地说明这些变量是指可清晰地说明这些变量是指可清晰地说明这些变量是指可清晰地说明这些变量是指针，对它们需要用适宜的方式进行处理针，对它们需要用适宜的方式进行处理针，对它们需要用适宜的方式进行处理针，对它们需要用适宜的方式进行处理指针变量的声明和初始化指针变量的声明和初始化uu 指针应当用声明语句或赋值语句初始化。可以把指针初始指针应当用声明语句或赋值语句初始化。可以把指针初始指针应当用声明语句或赋值语句初始化。可以把指

11、针初始指针应当用声明语句或赋值语句初始化。可以把指针初始化为化为化为化为0 0 0 0、NULL NULL NULL NULL 或某个地址。具有值或某个地址。具有值或某个地址。具有值或某个地址。具有值NULL NULL NULL NULL 的指针不指向任何值。的指针不指向任何值。的指针不指向任何值。的指针不指向任何值。NULL NULL NULL NULL 是在头文件是在头文件是在头文件是在头文件以及其它几个头文件中定义以及其它几个头文件中定义以及其它几个头文件中定义以及其它几个头文件中定义的符号常量。把一个指针初始化为的符号常量。把一个指针初始化为的符号常量。把一个指针初始化为的符号常量。把

12、一个指针初始化为0 0 0 0等价于把它初始化为等价于把它初始化为等价于把它初始化为等价于把它初始化为NULL, NULL, NULL, NULL, 但是，用但是，用但是，用但是，用NULL NULL NULL NULL 更好。更好。更好。更好。uu 当把当把当把当把0 0 0 0 赋给指针时，编译程序先把赋给指针时，编译程序先把赋给指针时，编译程序先把赋给指针时，编译程序先把0 0 0 0 转换为指向适宜数转换为指向适宜数转换为指向适宜数转换为指向适宜数据类型的指针据类型的指针据类型的指针据类型的指针uu 值值值值0 0 0 0 是唯一能够直接赋给指针变量的整数值是唯一能够直接赋给指针变量的

13、整数值是唯一能够直接赋给指针变量的整数值是唯一能够直接赋给指针变量的整数值uu 对指针初始化可防止相应程序运行时出现意想不到的结对指针初始化可防止相应程序运行时出现意想不到的结对指针初始化可防止相应程序运行时出现意想不到的结对指针初始化可防止相应程序运行时出现意想不到的结果果果果指针运算符指针运算符uu 运算符运算符运算符运算符& & & &或称为或称为或称为或称为“地址运算符是一个单目运算符，地址运算符是一个单目运算符，地址运算符是一个单目运算符，地址运算符是一个单目运算符，它返回其操作数的地址。例如，假定有声明语句它返回其操作数的地址。例如，假定有声明语句它返回其操作数的地址。例如，假定有

14、声明语句它返回其操作数的地址。例如，假定有声明语句uu int y = 5; int y = 5; int y = 5; int y = 5;uu int * yPtr; int * yPtr; int * yPtr; int * yPtr;uu那么语句那么语句那么语句那么语句uu yPtr = &y; yPtr = &y; yPtr = &y; yPtr = &y;uu把变量把变量把变量把变量y y y y 的地址赋给指针变量的地址赋给指针变量的地址赋给指针变量的地址赋给指针变量yPtryPtryPtryPtr。变量。变量。变量。变量yPtr yPtr yPtr yPtr 可称为可称为可称为

15、可称为“指指指指向变量向变量向变量向变量y y y y 。图。图。图。图7.2 7.2 7.2 7.2 用图解方式反映了执行完上述语句后的用图解方式反映了执行完上述语句后的用图解方式反映了执行完上述语句后的用图解方式反映了执行完上述语句后的内存现象内存现象内存现象内存现象y y5 5 yPtryPtr图图图图7. 2 7. 2 用图形表示指向内存中的某个整型变量的指针用图形表示指向内存中的某个整型变量的指针用图形表示指向内存中的某个整型变量的指针用图形表示指向内存中的某个整型变量的指针指针运算符指针运算符uu 假定变量假定变量假定变量假定变量y y 存储在内存单元存储在内存单元存储在内存单元存

16、储在内存单元600000 600000 中，变量中，变量中，变量中，变量yPtr yPtr 存储在内存储在内存储在内存储在内存单元存单元存单元存单元500000 500000 中中中中，yPtr yPtr 在内存中是如何表示的在内存中是如何表示的在内存中是如何表示的在内存中是如何表示的6000006000005 5500000500000600000600000yPtryPtry y图图图图7. 3 y 7. 3 y 和和和和 yPtr yPtr 在内存中的表示在内存中的表示在内存中的表示在内存中的表示uu 地址运算符的操作数必须是一个变量，不能把地址运算符地址运算符的操作数必须是一个变量，不

17、能把地址运算符地址运算符的操作数必须是一个变量，不能把地址运算符地址运算符的操作数必须是一个变量，不能把地址运算符用于常量、表达式或存储类别被声明为用于常量、表达式或存储类别被声明为用于常量、表达式或存储类别被声明为用于常量、表达式或存储类别被声明为register register register register 的变量上的变量上的变量上的变量上uu 运算符运算符运算符运算符* * * * 通常称为通常称为通常称为通常称为“间接引用运算符或间接引用运算符或间接引用运算符或间接引用运算符或“复引用运算复引用运算复引用运算复引用运算符符符符 ，它返回其操作数即一个指针所指向的对象的值。，它返

18、回其操作数即一个指针所指向的对象的值。，它返回其操作数即一个指针所指向的对象的值。，它返回其操作数即一个指针所指向的对象的值。例如，语句例如，语句例如，语句例如，语句uu printf printf printf printf%d%d%d%d, *yPtr, *yPtr, *yPtr, *yPtr; ; ; ;uu打印变量打印变量打印变量打印变量y y y y 的值即的值即的值即的值即5 5 5 5。* * * * 的这种用法称为的这种用法称为的这种用法称为的这种用法称为“指针的复引指针的复引指针的复引指针的复引用用用用指针运算符指针运算符uu 注意注意注意注意：如果被复引用的指针没有被正确地

19、初始化或：如果被复引用的指针没有被正确地初始化或：如果被复引用的指针没有被正确地初始化或：如果被复引用的指针没有被正确地初始化或没有指向具体的内存单元，都会导致没有指向具体的内存单元，都会导致没有指向具体的内存单元，都会导致没有指向具体的内存单元，都会导致致命的执行错误致命的执行错误致命的执行错误致命的执行错误或或或或意外地修改重要的数据意外地修改重要的数据意外地修改重要的数据意外地修改重要的数据。如果修改了重要的数据，虽然。如果修改了重要的数据，虽然。如果修改了重要的数据，虽然。如果修改了重要的数据，虽然程序能够完成运行，但是，程序运行所产生的结果是非程序能够完成运行，但是，程序运行所产生的

20、结果是非程序能够完成运行，但是，程序运行所产生的结果是非程序能够完成运行，但是，程序运行所产生的结果是非预期的，甚至是无法理解的预期的，甚至是无法理解的预期的，甚至是无法理解的预期的，甚至是无法理解的uu 图图图图7.47.47.47.4中的程序演示了指针运算符的用法。中的程序演示了指针运算符的用法。中的程序演示了指针运算符的用法。中的程序演示了指针运算符的用法。printf printf 的的的的转换说明符转换说明符转换说明符转换说明符%p p 以十六进制的整数形式输出内存地址以十六进制的整数形式输出内存地址以十六进制的整数形式输出内存地址以十六进制的整数形式输出内存地址。从从从从输出结果可

21、以看到，输出结果可以看到，输出结果可以看到，输出结果可以看到，a a 的地址和的地址和的地址和的地址和aPtr aPtr 的值是相等的的值是相等的的值是相等的的值是相等的，因因因因此，可以确信，此，可以确信，此，可以确信，此，可以确信，a a 的地址确实赋给了指针变量的地址确实赋给了指针变量的地址确实赋给了指针变量的地址确实赋给了指针变量aPtraPtruu 运算符运算符运算符运算符& & 和和和和 * * 互补互补互补互补，把这两个运算符以任意顺序连续把这两个运算符以任意顺序连续把这两个运算符以任意顺序连续把这两个运算符以任意顺序连续地用在地用在地用在地用在aPtr aPtr 上，上，上，上

22、，打印出的结果是相同的打印出的结果是相同的打印出的结果是相同的打印出的结果是相同的uu 表表表表7.1 7.1 中列出了迄今学过的运算符的优先级和结合性中列出了迄今学过的运算符的优先级和结合性中列出了迄今学过的运算符的优先级和结合性中列出了迄今学过的运算符的优先级和结合性 /* /* 运算符运算符运算符运算符& & 和和和和 * * 的用法的用法的用法的用法 */ */ # include # include main main（）（）（）（） int a; /* a int a; /* a 是一个整型变量是一个整型变量是一个整型变量是一个整型变量 */ */ int * aPtr; /* a

23、Ptr int * aPtr; /* aPtr 是一个指向是一个指向是一个指向是一个指向 int int 类型整数的指针类型整数的指针类型整数的指针类型整数的指针 */ */ a = 7; a = 7; aPtr = &a; aPtr = &a; printf printf（”The address of a is %p n”, &a”The address of a is %p n”, &a）; ; printf printf（”The value of aPtr is %p n n”, aPtr”The value of aPtr is %p n n”, aPtr）; ; printf p

24、rintf（”The value of a is %d n”, a”The value of a is %d n”, a）; ; printf printf（”The value of *aPtr is %d nn”, *aPtr”The value of *aPtr is %d nn”, *aPtr）; ; printf printf（”Proving that * and & are complements of”Proving that * and & are complements of” ” each other. n& *aPtr = %p n * &aPtr = %pn”, ”

25、each other. n& *aPtr = %p n * &aPtr = %pn”, & *aPtr, * & aPtr & *aPtr, * & aPtr）; ; return 0; return 0; 输出结果：输出结果：输出结果：输出结果： The address of a is FFF4 The address of a is FFF4 The value of aPtr is FFF4 The value of aPtr is FFF4 The value of a is 7 The value of a is 7 The value of *aPtr is 7 The value

26、 of *aPtr is 7 Proving that * and & are complements of each other. Proving that * and & are complements of each other. & *aPtr = FFF4 & *aPtr = FFF4 * &aPtr = FFF4 * &aPtr = FFF4图图图图 7. 4 7. 4 指针运算符指针运算符指针运算符指针运算符 & & 和和和和 * *表表表表7. 1 7. 1 运算符的优先级运算符的优先级运算符的优先级运算符的优先级 运运运运 算算算算 符符符符 结结结结 合合合合 性性性性 类

27、类类类 型型型型（）（）（）（） 从左到右从左到右从左到右从左到右 最高优先级最高优先级最高优先级最高优先级 + - + - ! * & + - + - ! * &（类型）（类型）（类型）（类型） 从右到左从右到左从右到左从右到左 单目运算符单目运算符单目运算符单目运算符* / % * / % 从左到右从左到右从左到右从左到右 乘法运算符乘法运算符乘法运算符乘法运算符+ - + - 从左到右从左到右从左到右从左到右 加法运算符加法运算符加法运算符加法运算符 = = 从左到右从左到右从左到右从左到右 关系运算符关系运算符关系运算符关系运算符= != = != 从左到右从左到右从左到右从左到右 相

28、等测试运算符相等测试运算符相等测试运算符相等测试运算符& & 从左到右从左到右从左到右从左到右 逻辑与逻辑与逻辑与逻辑与 | | 从左到右从左到右从左到右从左到右 逻辑或逻辑或逻辑或逻辑或? : ? : 从右到左从右到左从右到左从右到左 条件运算符条件运算符条件运算符条件运算符 = += -= *= /= %= = += -= *= /= %= 从右到左从右到左从右到左从右到左 赋值运算符赋值运算符赋值运算符赋值运算符 , , 从左到右从左到右从左到右从左到右 逗号运算符逗号运算符逗号运算符逗号运算符指针运算符指针运算符函数的传引用调用函数的传引用调用uu 给函数传递参数的方式有两种，即传值和

29、传引用。给函数传递参数的方式有两种，即传值和传引用。给函数传递参数的方式有两种，即传值和传引用。给函数传递参数的方式有两种，即传值和传引用。C C C C 语言语言语言语言中的所有函数调用都是传值调用。正如中的所有函数调用都是传值调用。正如中的所有函数调用都是传值调用。正如中的所有函数调用都是传值调用。正如“函数一章所介绍函数一章所介绍函数一章所介绍函数一章所介绍的那样，使用的那样，使用的那样，使用的那样，使用return return return return 语句可以把一个值从被调函数返回给主语句可以把一个值从被调函数返回给主语句可以把一个值从被调函数返回给主语句可以把一个值从被调函数返

30、回给主调函数或者从被调函数返回控制权而不传回一个值。许调函数或者从被调函数返回控制权而不传回一个值。许调函数或者从被调函数返回控制权而不传回一个值。许调函数或者从被调函数返回控制权而不传回一个值。许多函数要求能够修改主调函数中的一个或多个值，或能够传多函数要求能够修改主调函数中的一个或多个值，或能够传多函数要求能够修改主调函数中的一个或多个值，或能够传多函数要求能够修改主调函数中的一个或多个值，或能够传递指向大型对象的指针以防止开销很大的传值调用传值调递指向大型对象的指针以防止开销很大的传值调用传值调递指向大型对象的指针以防止开销很大的传值调用传值调递指向大型对象的指针以防止开销很大的传值调用

31、传值调用需要对被传送对象做一份拷贝用需要对被传送对象做一份拷贝用需要对被传送对象做一份拷贝用需要对被传送对象做一份拷贝uu C C C C 语言用指针和间接引用运算符模拟传引用调用。在调用语言用指针和间接引用运算符模拟传引用调用。在调用语言用指针和间接引用运算符模拟传引用调用。在调用语言用指针和间接引用运算符模拟传引用调用。在调用某个函数时，如果需要在被调函数中修改主调函数中作为实某个函数时，如果需要在被调函数中修改主调函数中作为实某个函数时，如果需要在被调函数中修改主调函数中作为实某个函数时，如果需要在被调函数中修改主调函数中作为实参的对象的值，应当给被调函数传递相应数据对象的地址参的对象的

32、值，应当给被调函数传递相应数据对象的地址参的对象的值，应当给被调函数传递相应数据对象的地址参的对象的值，应当给被调函数传递相应数据对象的地址uu 通常在需要修改值的变量的前面使用地址运算符通常在需要修改值的变量的前面使用地址运算符通常在需要修改值的变量的前面使用地址运算符通常在需要修改值的变量的前面使用地址运算符& & & & 实现这实现这实现这实现这一点。传递数组不需要使用运算符一点。传递数组不需要使用运算符一点。传递数组不需要使用运算符一点。传递数组不需要使用运算符&, &, &, &, 因为因为因为因为C C C C 自动传递数组起自动传递数组起自动传递数组起自动传递数组起始内存单元的地

33、址数组名与始内存单元的地址数组名与始内存单元的地址数组名与始内存单元的地址数组名与&arrayName0 &arrayName0 &arrayName0 &arrayName0 等价等价等价等价uu 当把变量的地址传递给被调函数时，可以在被调函数中当把变量的地址传递给被调函数时，可以在被调函数中当把变量的地址传递给被调函数时，可以在被调函数中当把变量的地址传递给被调函数时，可以在被调函数中用间接引用运算符用间接引用运算符用间接引用运算符用间接引用运算符* * * * 修改主调函数中相应变量的值修改主调函数中相应变量的值修改主调函数中相应变量的值修改主调函数中相应变量的值函数的传引用调用函数的传

34、引用调用uu 图图图图7.57.57.57.5和图和图和图和图7.67.67.67.6中的程序完成同样的功能，但它们调用完成中的程序完成同样的功能，但它们调用完成中的程序完成同样的功能，但它们调用完成中的程序完成同样的功能，但它们调用完成同样功能的函数使用了不同的参数传递机制，由此，可通过同样功能的函数使用了不同的参数传递机制，由此，可通过同样功能的函数使用了不同的参数传递机制，由此，可通过同样功能的函数使用了不同的参数传递机制，由此，可通过比照来了解它们间的差异比照来了解它们间的差异比照来了解它们间的差异比照来了解它们间的差异uu 在这两个程序中在这两个程序中在这两个程序中在这两个程序中,

35、, , ,都设置了求一个整数值立方的函数，分都设置了求一个整数值立方的函数，分都设置了求一个整数值立方的函数，分都设置了求一个整数值立方的函数，分别被命名为别被命名为别被命名为别被命名为cubeByValue cubeByValue cubeByValue cubeByValue 和和和和 cubeByReference cubeByReference cubeByReference cubeByReference ，它们虽然完，它们虽然完，它们虽然完，它们虽然完成相同的功能，但参数设置不同，由此使得主调函数引用它成相同的功能，但参数设置不同，由此使得主调函数引用它成相同的功能，但参数设置不同

36、，由此使得主调函数引用它成相同的功能，但参数设置不同，由此使得主调函数引用它们的方式有所不同们的方式有所不同们的方式有所不同们的方式有所不同uu 图图图图7.5 7.5 7.5 7.5 中的程序用传值调用方式把变量中的程序用传值调用方式把变量中的程序用传值调用方式把变量中的程序用传值调用方式把变量number number number number 的值传递的值传递的值传递的值传递给函数给函数给函数给函数cubeByValuecubeByValuecubeByValuecubeByValue。函数。函数。函数。函数cubeByValue cubeByValue cubeByValue cub

37、eByValue 计算了该参数的立方计算了该参数的立方计算了该参数的立方计算了该参数的立方并用并用并用并用return return return return 语句把结果传会给调用它的语句把结果传会给调用它的语句把结果传会给调用它的语句把结果传会给调用它的main main main main 函数，然后在函数，然后在函数，然后在函数，然后在main main main main 函数中将此结果赋给了变量函数中将此结果赋给了变量函数中将此结果赋给了变量函数中将此结果赋给了变量numbernumbernumbernumberuu number number number number 的值传递

38、给函数的值传递给函数的值传递给函数的值传递给函数cubeByReference cubeByReference cubeByReference cubeByReference ，通过作为参，通过作为参，通过作为参，通过作为参数的指针的作用，该函数以计算结果改变了数的指针的作用，该函数以计算结果改变了数的指针的作用，该函数以计算结果改变了数的指针的作用，该函数以计算结果改变了main main main main 函数中函数中函数中函数中number number number number 的值。的值。的值。的值。 /* /* 用传值方式求变量的立方用传值方式求变量的立方用传值方式求变量的立方

39、用传值方式求变量的立方 */ */ # include # include int cubeByValue int cubeByValue（intint）; ; main main（）（）（）（） int number = 5; int number = 5; printf printf（”The original value of number is %d n”, number”The original value of number is %d n”, number）; ; number = cubeByValue number = cubeByValue（numbernumber）; ;

40、 printf printf（”The new value of number is %d n”, number”The new value of number is %d n”, number）; ; return 0; return 0; int cubeByValue int cubeByValue（int nint n） return n * n * n; /* return n * n * n; /*计算局部变量计算局部变量计算局部变量计算局部变量n n 的立方的立方的立方的立方 */ */ 输出结果：输出结果：输出结果：输出结果： The original value of num

41、ber is 5 The original value of number is 5 The new value of number is 125 The new value of number is 125图图图图 7. 5 7. 5 用传值方式求变量的立方用传值方式求变量的立方用传值方式求变量的立方用传值方式求变量的立方 /* /* 用传引用方式计算变量的立方用传引用方式计算变量的立方用传引用方式计算变量的立方用传引用方式计算变量的立方 */ */ # include # include void cubeByReference void cubeByReference（int *int

42、*）; ; main main（）（）（）（） int number = 5; int number = 5; printf printf（ ”The original value of number is %d n”, number ”The original value of number is %d n”, number ） cubeByReference cubeByReference（&number&number）; ; printf printf（”The new value of number is %d n”, number”The new value of number is

43、 %d n”, number）; ; return 0; return 0; void cubeByReference void cubeByReference（int *nPtrint *nPtr） *nPtr = *nPtr * *nPtr * *nPtr ; /* *nPtr = *nPtr * *nPtr * *nPtr ; /* 计算计算计算计算main main 函数中变量的立方函数中变量的立方函数中变量的立方函数中变量的立方*/*/ 输出结果：输出结果：输出结果：输出结果： The original value of number is 5 The original value

44、of number is 5 The new value of number is 125 The new value of number is 125图图图图 7. 6 7. 6 用传引用方式计算变量的立方用传引用方式计算变量的立方用传引用方式计算变量的立方用传引用方式计算变量的立方mainmain（）（）（）（） int number = 5; int number = 5; number = cubeByValue number = cubeByValue（numbernumber）; ; 5 5numbernumbermainmain（）（）（）（） int number = 5; i

45、nt number = 5; number = cubeByValue number = cubeByValue（numbernumber）; ; 5 5numbernumbermainmain（）（）（）（） int number = 5; int number = 5; number = cubeByValue number = cubeByValue（numbernumber）; ; 5 5numbernumber int cubeByValue int cubeByValue（int nint n） return n * n * n; return n * n * n; 没有确定值没有

46、确定值没有确定值没有确定值n nmain main 调用调用调用调用cubeByValue cubeByValue 之前之前之前之前 main main 调用调用调用调用cubeByValue cubeByValue 之后之后之后之后 int cubeByValueint cubeByValue（int nint n） return n * n * n; return n * n * n; 5 5n nn * n * nn * n * n125125 int cubeByValue int cubeByValue（int nint n） return return 5 5n ncubeByVa

47、lue cubeByValue 函数计算了函数计算了函数计算了函数计算了n n 的立方之后的立方之后的立方之后的立方之后 mainmain（）（）（）（） int number = 5; int number = 5; number = number = 5 5numbernumbercubeByValuecubeByValue（numbernumber）; ;125125int cubeByValueint cubeByValue（int nint n） return n * n * n; return n * n * n; 没有确定值没有确定值没有确定值没有确定值n n没有确定值没有确定值

48、没有确定值没有确定值n nmainmain（）（）（）（） int number = 5; int number = 5; number = cubeByValue number = cubeByValue（numbernumber）; ; 125125numbernumberint cubeByValueint cubeByValue（int nint n） return n * n * n; return n * n * n; 从从从从cubeByValue cubeByValue 返回到返回到返回到返回到main main 后后后后main main 完成给完成给完成给完成给number

49、 number 赋值之后赋值之后赋值之后赋值之后图图图图7. 7 7. 7 典型的传值调用分析典型的传值调用分析典型的传值调用分析典型的传值调用分析函数的传引用调用函数的传引用调用 void cubeByReference void cubeByReference（int *nPtrint *nPtr） *nPtr = *nPtr * *nPtr * *nPtr ; *nPtr = *nPtr * *nPtr * *nPtr ; 不确定不确定不确定不确定nPtr nPtr mainmain（）（）（）（） int number = 5; int number = 5; cubeByRefere

50、nce cubeByReference（&number&number）; ; 5 5numbernumbermainmain（）（）（）（） int number = 5; int number = 5; cubeByReference cubeByReference（&number&number）; ; 5 5numbernumber void cubeByReference void cubeByReference（int *nPtrint *nPtr） *nPtr = *nPtr * *nPtr * *nPtr ; *nPtr = *nPtr * *nPtr * *nPtr ; nPtr

51、 nPtr 以传引用方式调用以传引用方式调用以传引用方式调用以传引用方式调用cubeByReference cubeByReference 之前之前之前之前以传引用方式调用以传引用方式调用以传引用方式调用以传引用方式调用cubeByReference cubeByReference 之后、计算之后、计算之后、计算之后、计算 *nPtr *nPtr 立方之前立方之前立方之前立方之前mainmain（）（）（）（） int number = 5; int number = 5; cubeByReference cubeByReference（&number&number）; ; 125125num

52、bernumber void cubeByReference void cubeByReference（int *nPtrint *nPtr） nPtr nPtr *nPtr = *nPtr * *nPtr * *nPtr; *nPtr = *nPtr * *nPtr * *nPtr; 125125计算完计算完计算完计算完 *nPtr *nPtr 的立方之后的立方之后的立方之后的立方之后图图图图 7. 8 7. 8 典型的传引用调用分析典型的传引用调用分析典型的传引用调用分析典型的传引用调用分析函数的传引用调用函数的传引用调用uu 把地址作为参数的函数必须定义一个接收地址的指针参数。把地址作为

53、参数的函数必须定义一个接收地址的指针参数。把地址作为参数的函数必须定义一个接收地址的指针参数。把地址作为参数的函数必须定义一个接收地址的指针参数。例如，函数例如，函数例如，函数例如，函数cubeByReference cubeByReference cubeByReference cubeByReference 的头部为的头部为的头部为的头部为uu void cubeByReference void cubeByReference void cubeByReference void cubeByReferenceint *nPtrint *nPtrint *nPtrint *nPtruu它说明

54、：函数它说明：函数它说明：函数它说明：函数cubeByReference cubeByReference cubeByReference cubeByReference 的参数要求接收一个整型的参数要求接收一个整型的参数要求接收一个整型的参数要求接收一个整型变量的地址，该地址存储在局部变量变量的地址，该地址存储在局部变量变量的地址，该地址存储在局部变量变量的地址，该地址存储在局部变量nPtr nPtr nPtr nPtr 中，并且函数没有中，并且函数没有中，并且函数没有中，并且函数没有返回值返回值返回值返回值 函数的传引用调用函数的传引用调用uu 函数函数函数函数cubeByReference

55、 cubeByReference cubeByReference cubeByReference 的原型在括号中包含了的原型在括号中包含了的原型在括号中包含了的原型在括号中包含了int *, int *, int *, int *, 为：为：为：为：uu void cubeByReference void cubeByReference void cubeByReference void cubeByReferenceint *int *int *int *; ; ; ;uu和其他变量类型一样，函数原型中也没有必要包含指针和其他变量类型一样，函数原型中也没有必要包含指针和其他变量类型一样，函数

56、原型中也没有必要包含指针和其他变量类型一样，函数原型中也没有必要包含指针名。编译程序会忽略因为阅读文档方便而在函数原型中包名。编译程序会忽略因为阅读文档方便而在函数原型中包名。编译程序会忽略因为阅读文档方便而在函数原型中包名。编译程序会忽略因为阅读文档方便而在函数原型中包含的名字含的名字含的名字含的名字uu 对要求用一个一维数组作为参数的函数来说，函数的头对要求用一个一维数组作为参数的函数来说，函数的头对要求用一个一维数组作为参数的函数来说，函数的头对要求用一个一维数组作为参数的函数来说，函数的头部和函数原型的参数列表中可以用指针表示一维数组。编部和函数原型的参数列表中可以用指针表示一维数组。

57、编部和函数原型的参数列表中可以用指针表示一维数组。编部和函数原型的参数列表中可以用指针表示一维数组。编译程序对函数是接收一个指针还是一个一维数组实不加区译程序对函数是接收一个指针还是一个一维数组实不加区译程序对函数是接收一个指针还是一个一维数组实不加区译程序对函数是接收一个指针还是一个一维数组实不加区分的。当遇到形如一维数组分的。当遇到形如一维数组分的。当遇到形如一维数组分的。当遇到形如一维数组int b int b int b int b 的函数参数时，编的函数参数时，编的函数参数时，编的函数参数时，编译程序把该参数转换为指针形式译程序把该参数转换为指针形式译程序把该参数转换为指针形式译程序

58、把该参数转换为指针形式int *b. int *b. int *b. int *b. 这两种形式是可这两种形式是可这两种形式是可这两种形式是可以互换的以互换的以互换的以互换的uu 建议：除非主调函数明确地要求被调函数修改主调函数建议：除非主调函数明确地要求被调函数修改主调函数建议：除非主调函数明确地要求被调函数修改主调函数建议：除非主调函数明确地要求被调函数修改主调函数环境中的参数变量，否那么，用传值调用给函数传递参数。环境中的参数变量，否那么，用传值调用给函数传递参数。环境中的参数变量，否那么，用传值调用给函数传递参数。环境中的参数变量，否那么，用传值调用给函数传递参数。即如上述问题，应尽量

59、采用图即如上述问题，应尽量采用图即如上述问题，应尽量采用图即如上述问题，应尽量采用图7.5 7.5 7.5 7.5 中的方式而不采用图中的方式而不采用图中的方式而不采用图中的方式而不采用图7.67.67.67.6中的方式，虽然它们能够到达相同的目的中的方式，虽然它们能够到达相同的目的中的方式，虽然它们能够到达相同的目的中的方式，虽然它们能够到达相同的目的对指针使用对指针使用const 限定符限定符uu const const const const 限定符通知编译程序禁止修改某个特定的变量。在限定符通知编译程序禁止修改某个特定的变量。在限定符通知编译程序禁止修改某个特定的变量。在限定符通知编译

60、程序禁止修改某个特定的变量。在早期版本的早期版本的早期版本的早期版本的C C C C语言中没有语言中没有语言中没有语言中没有const const const const 限定符，是后来添加的限定符，是后来添加的限定符，是后来添加的限定符，是后来添加的uu 使用使用使用使用const const const const 限定赋限制被调函数的行为有利于提高主调函限定赋限制被调函数的行为有利于提高主调函限定赋限制被调函数的行为有利于提高主调函限定赋限制被调函数的行为有利于提高主调函数与被调函数间的相对独立性，使程序易于修改和调试数与被调函数间的相对独立性，使程序易于修改和调试数与被调函数间的相对独

61、立性，使程序易于修改和调试数与被调函数间的相对独立性，使程序易于修改和调试uu 用用用用const const const const 作为被调函数的参数限定符有作为被调函数的参数限定符有作为被调函数的参数限定符有作为被调函数的参数限定符有6 6 6 6种可能的情况，种可能的情况，种可能的情况，种可能的情况， 两种用于传值调用，四种用于传引用调用。选择使用其中的两种用于传值调用，四种用于传引用调用。选择使用其中的两种用于传值调用，四种用于传引用调用。选择使用其中的两种用于传值调用，四种用于传引用调用。选择使用其中的哪一种用于确定的函数参数，要做多方面的考虑。在现代，哪一种用于确定的函数参数，要

62、做多方面的考虑。在现代，哪一种用于确定的函数参数，要做多方面的考虑。在现代，哪一种用于确定的函数参数，要做多方面的考虑。在现代，根本的指导性原那么应当是：为了完成指定的任务使被调根本的指导性原那么应当是：为了完成指定的任务使被调根本的指导性原那么应当是：为了完成指定的任务使被调根本的指导性原那么应当是：为了完成指定的任务使被调函数实现确定的功能，应授予函数以操作参数值的足够的函数实现确定的功能，应授予函数以操作参数值的足够的函数实现确定的功能，应授予函数以操作参数值的足够的函数实现确定的功能，应授予函数以操作参数值的足够的权限，但不给之以更多的权限最低访问权原那么权限，但不给之以更多的权限最低

63、访问权原那么权限，但不给之以更多的权限最低访问权原那么权限，但不给之以更多的权限最低访问权原那么uu 如果传递给函数的值没有或不应该在函数体中被修如果传递给函数的值没有或不应该在函数体中被修如果传递给函数的值没有或不应该在函数体中被修如果传递给函数的值没有或不应该在函数体中被修改，应当用改，应当用改，应当用改，应当用const const const const 声明相应参数以防止相应对象被函数被声明相应参数以防止相应对象被函数被声明相应参数以防止相应对象被函数被声明相应参数以防止相应对象被函数被调函数的执行所意外地修改。这样，如果函数试图修改用调函数的执行所意外地修改。这样，如果函数试图修改

64、用调函数的执行所意外地修改。这样，如果函数试图修改用调函数的执行所意外地修改。这样，如果函数试图修改用constconstconstconst声明的值，编译程序会捕捉到这种情况，并根据特定的声明的值，编译程序会捕捉到这种情况，并根据特定的声明的值，编译程序会捕捉到这种情况，并根据特定的声明的值，编译程序会捕捉到这种情况，并根据特定的编译程序或者给出警告信息或者给出错误消息编译程序或者给出警告信息或者给出错误消息编译程序或者给出警告信息或者给出错误消息编译程序或者给出警告信息或者给出错误消息对指针使用对指针使用const 限定符限定符uu 传值调用只能在主调函数中修改一个值。要在主调函数中传值调

65、用只能在主调函数中修改一个值。要在主调函数中传值调用只能在主调函数中修改一个值。要在主调函数中传值调用只能在主调函数中修改一个值。要在主调函数中修改多个值必须使用传引用调用修改多个值必须使用传引用调用修改多个值必须使用传引用调用修改多个值必须使用传引用调用uu 给函数传递的指针有如下给函数传递的指针有如下给函数传递的指针有如下给函数传递的指针有如下4 4 4 4种情况：指向非常量数据的非种情况：指向非常量数据的非种情况：指向非常量数据的非种情况：指向非常量数据的非常量指针，指向非常量数据的常量指针，指向常量数据的非常量指针，指向非常量数据的常量指针，指向常量数据的非常量指针，指向非常量数据的常

66、量指针，指向常量数据的非常量指针，指向非常量数据的常量指针，指向常量数据的非常量指针，指向常量数据的常量指针。每一种情况都有不同常量指针，指向常量数据的常量指针。每一种情况都有不同常量指针，指向常量数据的常量指针。每一种情况都有不同常量指针，指向常量数据的常量指针。每一种情况都有不同级别的访问权级别的访问权级别的访问权级别的访问权uu 指向非常量数据的非常量指针具有最高访问权。这种情况指向非常量数据的非常量指针具有最高访问权。这种情况指向非常量数据的非常量指针具有最高访问权。这种情况指向非常量数据的非常量指针具有最高访问权。这种情况允许通过指针复引用间接访问来修改数据并能够通过修允许通过指针复

67、引用间接访问来修改数据并能够通过修允许通过指针复引用间接访问来修改数据并能够通过修允许通过指针复引用间接访问来修改数据并能够通过修改指针使它指向其它数据项改指针使它指向其它数据项改指针使它指向其它数据项改指针使它指向其它数据项uu 把非常量指针传递给非常量数据不包含关键字把非常量指针传递给非常量数据不包含关键字把非常量指针传递给非常量数据不包含关键字把非常量指针传递给非常量数据不包含关键字constconstconstconst。这。这。这。这种指针可能会用来接收一个字符串参数一维数组种指针可能会用来接收一个字符串参数一维数组种指针可能会用来接收一个字符串参数一维数组种指针可能会用来接收一个字

68、符串参数一维数组convertToUppercase convertToUppercase convertToUppercase convertToUppercase 把参数声明为指向一个非常量数据把参数声明为指向一个非常量数据把参数声明为指向一个非常量数据把参数声明为指向一个非常量数据s s s schar *schar *schar *schar *s的非常量指针，函数用指针算法处理了字符串的非常量指针，函数用指针算法处理了字符串的非常量指针，函数用指针算法处理了字符串的非常量指针，函数用指针算法处理了字符串s s s s 中的每一个字符，中的每一个字符，中的每一个字符，中的每一个字符，

69、将其中的小写字母转化为大写字母在将其中的小写字母转化为大写字母在将其中的小写字母转化为大写字母在将其中的小写字母转化为大写字母在ASCII ASCII ASCII ASCII 码表中，两者间相差码表中，两者间相差码表中，两者间相差码表中，两者间相差32323232 /* /* 用指向非常量数据的非常量指针用指向非常量数据的非常量指针用指向非常量数据的非常量指针用指向非常量数据的非常量指针 */ */ /* /* 把字符串中的小写字母转换为大写把字符串中的小写字母转换为大写把字符串中的小写字母转换为大写把字符串中的小写字母转换为大写 */ */ # include # include void

70、convertToUppercase void convertToUppercase（char *char *）; ; main main（）（）（）（） char string = ”characters”; char string = ”characters”; printf printf（”The string before conversion is:%sn”, string”The string before conversion is:%sn”, string）; ; convertToUppercase convertToUppercase（stringstring）; ; pr

71、intf printf（”The string after conversion is: %sn”, string”The string after conversion is: %sn”, string）; ; return 0; return 0; 对指针使用对指针使用const 限定符限定符 void convertToUppercase void convertToUppercase（char * schar * s） while while（*s != 0*s != 0） if if（*s = a & *s = a & *s = z） *s -= 32; /* *s -= 32; /

72、* 把小写字母转换为大写字母把小写字母转换为大写字母把小写字母转换为大写字母把小写字母转换为大写字母 */ */ +s; /* +s; /* 把把把把s s 加加加加 1 1 使它指向下一个字符使它指向下一个字符使它指向下一个字符使它指向下一个字符 */ */ 输出结果：输出结果：输出结果：输出结果： The string before conversion is: characters The string before conversion is: characters The string after conversion is CHARACTERS The string after c

73、onversion is CHARACTERS图图图图 7. 9 7. 9 用指向非常量数据的非常量指针把字符串中的小写字母转换为大写用指向非常量数据的非常量指针把字符串中的小写字母转换为大写用指向非常量数据的非常量指针把字符串中的小写字母转换为大写用指向非常量数据的非常量指针把字符串中的小写字母转换为大写uu 可以修改可以修改可以修改可以修改指向常量数据指向常量数据指向常量数据指向常量数据的的的的非常量指针非常量指针非常量指针非常量指针使它指向具有合适类使它指向具有合适类使它指向具有合适类使它指向具有合适类型的任何数据项型的任何数据项型的任何数据项型的任何数据项, , , ,但是但是但是但是

74、, , , ,它所指向的数据是不能被修改的。这它所指向的数据是不能被修改的。这它所指向的数据是不能被修改的。这它所指向的数据是不能被修改的。这种指针可能会用来接收一个数组参数种指针可能会用来接收一个数组参数种指针可能会用来接收一个数组参数种指针可能会用来接收一个数组参数, , , ,然后让函数在不修改数然后让函数在不修改数然后让函数在不修改数然后让函数在不修改数据的情况下处理数组的每一个元素。例如据的情况下处理数组的每一个元素。例如据的情况下处理数组的每一个元素。例如据的情况下处理数组的每一个元素。例如, , , ,图图图图7.107.107.107.10中的函数中的函数中的函数中的函数pri

75、ntCharacters printCharacters 把参数把参数把参数把参数s s 声明为类型声明为类型声明为类型声明为类型const char *const char *（s s 是一个指是一个指是一个指是一个指向字符常量的指针）。函数用一个向字符常量的指针）。函数用一个向字符常量的指针）。函数用一个向字符常量的指针）。函数用一个for for 结构输出字符串中的每结构输出字符串中的每结构输出字符串中的每结构输出字符串中的每个字符个字符个字符个字符，指针指针指针指针s s 被在循环体中修改被在循环体中修改被在循环体中修改被在循环体中修改 /* /* 用指向常量数据的指针一次打印字符串中

76、的一个字符用指向常量数据的指针一次打印字符串中的一个字符用指向常量数据的指针一次打印字符串中的一个字符用指向常量数据的指针一次打印字符串中的一个字符 */ */ # include # include void printCharacters void printCharacters（const char *const char *）; ; main main（）（）（）（） char string = ”print characters of a string”; char string = ”print characters of a string”; printf printf（”The

77、 string is: n”The string is: n”）; ; printCharacters printCharacters（stringstring）; ; putchar putchar（nn）; ; return 0; return 0; 对指针使用对指针使用const 限定符限定符 void printCharacters void printCharacters（const char *sconst char *s） for for（; *s != 0; s+; *s != 0; s+）/* /* 无循环控制变量的初始化环节无循环控制变量的初始化环节无循环控制变量的初始化环

78、节无循环控制变量的初始化环节 */ */ putchar putchar（*s*s）; ; 输出结果：输出结果：输出结果：输出结果： The string is: The string is: print characters of a string print characters of a string图图图图 7. 10 7. 10 用指向常量数据的指针一次打印字符串中的一个字符用指向常量数据的指针一次打印字符串中的一个字符用指向常量数据的指针一次打印字符串中的一个字符用指向常量数据的指针一次打印字符串中的一个字符对指针使用对指针使用const 限定符限定符uu 在以指向常量数据的非常量

79、指针作为函数的参数时注意在以指向常量数据的非常量指针作为函数的参数时注意在以指向常量数据的非常量指针作为函数的参数时注意在以指向常量数据的非常量指针作为函数的参数时注意: : : :在这里，指针数据在被调函数中是可被修改的，它是非常量在这里，指针数据在被调函数中是可被修改的，它是非常量在这里，指针数据在被调函数中是可被修改的，它是非常量在这里，指针数据在被调函数中是可被修改的，它是非常量 /* /* 试图用指向常量数据的非常量指针修改数据试图用指向常量数据的非常量指针修改数据试图用指向常量数据的非常量指针修改数据试图用指向常量数据的非常量指针修改数据 */ */ #include #inclu

80、de void f void f（const int *const int *）; ; main main（）（）（）（） int y; int y; f f（&y&y）; /* ; /* 函数函数函数函数f f 试图非法地修改数据试图非法地修改数据试图非法地修改数据试图非法地修改数据 */ */ return 0; return 0; void f void f（const int *xconst int *x） *x = 100; /* *x = 100; /* 不能修改常量对象不能修改常量对象不能修改常量对象不能修改常量对象 */ */ 编译输出：编译输出：编译输出：编译输出： Comp

81、iling FIG7_11.C: Compiling FIG7_11.C: Error FIG7_11.C11: Cannot modify const object Error FIG7_11.C11: Cannot modify const object Warning FIG7_11.C12: Parameter x is never used Warning FIG7_11.C12: Parameter x is never used图图图图7.11 7.11 试图用指向常量数据的非常量指针修改数据试图用指向常量数据的非常量指针修改数据试图用指向常量数据的非常量指针修改数据试图用指向常

82、量数据的非常量指针修改数据对指针使用对指针使用const 限定符限定符uu 由前面的相关讨论可知，数组是用一个名字存储许多具有由前面的相关讨论可知，数组是用一个名字存储许多具有由前面的相关讨论可知，数组是用一个名字存储许多具有由前面的相关讨论可知，数组是用一个名字存储许多具有相同类型的相关数据项的聚合数据类型。后面相关章节将要相同类型的相关数据项的聚合数据类型。后面相关章节将要相同类型的相关数据项的聚合数据类型。后面相关章节将要相同类型的相关数据项的聚合数据类型。后面相关章节将要讨论的讨论的讨论的讨论的“结构结构结构结构 也称也称也称也称“结构体是另一种聚合数据类型，结构体是另一种聚合数据类型

83、，结构体是另一种聚合数据类型，结构体是另一种聚合数据类型，它能够用同一个名字存储许多不同类型的相关数据项，例如它能够用同一个名字存储许多不同类型的相关数据项，例如它能够用同一个名字存储许多不同类型的相关数据项，例如它能够用同一个名字存储许多不同类型的相关数据项，例如存储某高校每一个学生的信息存储某高校每一个学生的信息存储某高校每一个学生的信息存储某高校每一个学生的信息uu 当一个函数需要接收一个数组一维数组作为参数时，当一个函数需要接收一个数组一维数组作为参数时，当一个函数需要接收一个数组一维数组作为参数时，当一个函数需要接收一个数组一维数组作为参数时，由前面相关讨论可知：一方面，主调函数可以

84、用一个数组名由前面相关讨论可知：一方面，主调函数可以用一个数组名由前面相关讨论可知：一方面，主调函数可以用一个数组名由前面相关讨论可知：一方面，主调函数可以用一个数组名作为实参来实现函数调用；另一方面，编译程序会将被调函作为实参来实现函数调用；另一方面，编译程序会将被调函作为实参来实现函数调用；另一方面，编译程序会将被调函作为实参来实现函数调用；另一方面，编译程序会将被调函数接收数组的参数理解为一个指针如数接收数组的参数理解为一个指针如数接收数组的参数理解为一个指针如数接收数组的参数理解为一个指针如int *int *int *int *、char * char * char * char *

85、 等等等等等。此时，数组名即是一个指向非常量的常量指针在被等。此时，数组名即是一个指向非常量的常量指针在被等。此时，数组名即是一个指向非常量的常量指针在被等。此时，数组名即是一个指向非常量的常量指针在被调函数中，这个数组名是常量，不能改变其值；而其所指向调函数中，这个数组名是常量，不能改变其值；而其所指向调函数中，这个数组名是常量，不能改变其值；而其所指向调函数中，这个数组名是常量，不能改变其值；而其所指向的数组那么是非常量的，被调函数可以通过下标来改变相应的数组那么是非常量的，被调函数可以通过下标来改变相应的数组那么是非常量的，被调函数可以通过下标来改变相应的数组那么是非常量的，被调函数可以

86、通过下标来改变相应数组的元素值数组的元素值数组的元素值数组的元素值uu 相应的，当一个函数需要接收一个结构作为参数时，在相应的，当一个函数需要接收一个结构作为参数时，在相应的，当一个函数需要接收一个结构作为参数时，在相应的，当一个函数需要接收一个结构作为参数时，在 C C C C语言中，是以传值方式将结构的一份拷贝传递给被调函数的语言中，是以传值方式将结构的一份拷贝传递给被调函数的语言中，是以传值方式将结构的一份拷贝传递给被调函数的语言中，是以传值方式将结构的一份拷贝传递给被调函数的从后面有关章节可以了解这一点从后面有关章节可以了解这一点从后面有关章节可以了解这一点从后面有关章节可以了解这一点

87、对指针使用对指针使用const 限定符限定符uu 由于一个结构通常包括许多成员，在程序设计中，一种可由于一个结构通常包括许多成员，在程序设计中，一种可由于一个结构通常包括许多成员，在程序设计中，一种可由于一个结构通常包括许多成员，在程序设计中，一种可用的途径是在相应被调函数中使用指向结构的指针来作为接用的途径是在相应被调函数中使用指向结构的指针来作为接用的途径是在相应被调函数中使用指向结构的指针来作为接用的途径是在相应被调函数中使用指向结构的指针来作为接收结构的参数以减少函数调用时的数据传送量此时，相应收结构的参数以减少函数调用时的数据传送量此时，相应收结构的参数以减少函数调用时的数据传送量此

88、时，相应收结构的参数以减少函数调用时的数据传送量此时，相应主调函数中应取得指向相应结构的指针作为函数调用中的实主调函数中应取得指向相应结构的指针作为函数调用中的实主调函数中应取得指向相应结构的指针作为函数调用中的实主调函数中应取得指向相应结构的指针作为函数调用中的实参，这时，此指针也是一个指向非常量的常量指针类似参，这时，此指针也是一个指向非常量的常量指针类似参，这时，此指针也是一个指向非常量的常量指针类似参，这时，此指针也是一个指向非常量的常量指针类似于数组，被调函数不能改变这个指针值，但可以改变结构的于数组，被调函数不能改变这个指针值，但可以改变结构的于数组，被调函数不能改变这个指针值，但

89、可以改变结构的于数组，被调函数不能改变这个指针值，但可以改变结构的成员成员成员成员uu 以上是指向非常量的常量指针在实用程序设计中的典型应以上是指向非常量的常量指针在实用程序设计中的典型应以上是指向非常量的常量指针在实用程序设计中的典型应以上是指向非常量的常量指针在实用程序设计中的典型应用用用用uu如果单纯从计算机语言的角度来看，指向非常量数据的常如果单纯从计算机语言的角度来看，指向非常量数据的常如果单纯从计算机语言的角度来看，指向非常量数据的常如果单纯从计算机语言的角度来看，指向非常量数据的常量指针总是指向同一个内存单元，其中的数据可以通过该指量指针总是指向同一个内存单元，其中的数据可以通过

90、该指量指针总是指向同一个内存单元，其中的数据可以通过该指量指针总是指向同一个内存单元，其中的数据可以通过该指针修改，但指针本身不能被修改。声明为针修改，但指针本身不能被修改。声明为针修改，但指针本身不能被修改。声明为针修改，但指针本身不能被修改。声明为const const const const 的指针必须的指针必须的指针必须的指针必须在声明时初始化如果它是函数的参数，用传递给函数的指在声明时初始化如果它是函数的参数，用传递给函数的指在声明时初始化如果它是函数的参数，用传递给函数的指在声明时初始化如果它是函数的参数，用传递给函数的指针初始化。图针初始化。图针初始化。图针初始化。图7.12 7

91、.12 7.12 7.12 中中中中, , , , 指针指针指针指针ptr ptr ptr ptr 被声明为被声明为被声明为被声明为int * const int * const int * const int * const 类类类类型读法：指针型读法：指针型读法：指针型读法：指针ptr ptr ptr ptr 是一个指向某整数的常量指针。程序是一个指向某整数的常量指针。程序是一个指向某整数的常量指针。程序是一个指向某整数的常量指针。程序中试图修改它，编译程序给出了相应的错误信息中试图修改它，编译程序给出了相应的错误信息中试图修改它，编译程序给出了相应的错误信息中试图修改它，编译程序给出了相

92、应的错误信息 /* /* 试图修改指向非常量数据的常量指针试图修改指向非常量数据的常量指针试图修改指向非常量数据的常量指针试图修改指向非常量数据的常量指针 */ */ # include # include main main（）（）（）（） int x, y; int x, y; int * const ptr = &x; int * const ptr = &x; ptr = &y; ptr = &y; return 0; return 0; 编译输出：编译输出：编译输出：编译输出： Compiling FIG7_12.C: Compiling FIG7_12.C: Error FIG7_

93、12.C 9: Cannot modify a const objiect Error FIG7_12.C 9: Cannot modify a const objiect Warning FIG7_12.C11:ptr is assigned a value that is Warning FIG7_12.C11:ptr is assigned a value that is never used never used Warning FIG7_12.C11:y is declared but never used Warning FIG7_12.C11:y is declared but

94、never used图图图图7. 12 7. 12 试图修改指向非常量数据的常量指针试图修改指向非常量数据的常量指针试图修改指向非常量数据的常量指针试图修改指向非常量数据的常量指针对指针使用对指针使用const 限定符限定符uu 应当注意，对于指向非常量的常量指针，指针所指的对象应当注意，对于指向非常量的常量指针，指针所指的对象应当注意，对于指向非常量的常量指针，指针所指的对象应当注意，对于指向非常量的常量指针，指针所指的对象对于相应的函数来说是可以修改的例如，函数可以通过使对于相应的函数来说是可以修改的例如，函数可以通过使对于相应的函数来说是可以修改的例如，函数可以通过使对于相应的函数来说是

95、可以修改的例如，函数可以通过使用下标来修改指针所指向的数组的元素，因为指针本身虽然用下标来修改指针所指向的数组的元素，因为指针本身虽然用下标来修改指针所指向的数组的元素，因为指针本身虽然用下标来修改指针所指向的数组的元素，因为指针本身虽然是常量，不能被改变，但其所指向的对象是非常量的，是可是常量，不能被改变，但其所指向的对象是非常量的，是可是常量，不能被改变，但其所指向的对象是非常量的，是可是常量，不能被改变，但其所指向的对象是非常量的，是可修改的修改的修改的修改的uu 指向常量数据的常量指针具有最低访问权。对于相应函数指向常量数据的常量指针具有最低访问权。对于相应函数指向常量数据的常量指针具

96、有最低访问权。对于相应函数指向常量数据的常量指针具有最低访问权。对于相应函数来说，不仅指针是常量，其值是不可改变的；指针所指向的来说，不仅指针是常量，其值是不可改变的；指针所指向的来说，不仅指针是常量，其值是不可改变的；指针所指向的来说，不仅指针是常量，其值是不可改变的；指针所指向的对象也是常量，其值也是不可改变的。然而，按照相应的指对象也是常量，其值也是不可改变的。然而，按照相应的指对象也是常量，其值也是不可改变的。然而，按照相应的指对象也是常量，其值也是不可改变的。然而，按照相应的指针去读取其所指向的对象是可以的针去读取其所指向的对象是可以的针去读取其所指向的对象是可以的针去读取其所指向的

97、对象是可以的uu 指向常量的常量指针在实用程序设计中典型的用法是：一指向常量的常量指针在实用程序设计中典型的用法是：一指向常量的常量指针在实用程序设计中典型的用法是：一指向常量的常量指针在实用程序设计中典型的用法是：一个函数需要通过一个指针型参数如数组的第一个元素的地个函数需要通过一个指针型参数如数组的第一个元素的地个函数需要通过一个指针型参数如数组的第一个元素的地个函数需要通过一个指针型参数如数组的第一个元素的地址来接收一个数组或结构，但函数并不改变数组元素址来接收一个数组或结构，但函数并不改变数组元素址来接收一个数组或结构，但函数并不改变数组元素址来接收一个数组或结构，但函数并不改变数组元

98、素的值或结构的成员，仅简单地使用相应的数据项值的值或结构的成员，仅简单地使用相应的数据项值的值或结构的成员，仅简单地使用相应的数据项值的值或结构的成员，仅简单地使用相应的数据项值uuconst int * const const int * const const int * const const int * const 类型的指针变量类型的指针变量类型的指针变量类型的指针变量ptrptrptrptr，但程序试图修，但程序试图修，但程序试图修，但程序试图修改改改改ptr ptr ptr ptr 的值和其指向的数据，因此，编译程序给出了相应的的值和其指向的数据，因此，编译程序给出了相应的的值和

99、其指向的数据，因此，编译程序给出了相应的的值和其指向的数据，因此，编译程序给出了相应的错误信息错误信息错误信息错误信息 /* /* 试图修改指向常量数据的常量指针试图修改指向常量数据的常量指针试图修改指向常量数据的常量指针试图修改指向常量数据的常量指针 */ */ # include # include main main（）（）（）（） int x = 5, y; int x = 5, y; const int * const ptr = &x; const int * const ptr = &x; *ptr = 7; *ptr = 7; ptr = &y; ptr = &y; retur

100、n 0; return 0; 编译输出：编译输出：编译输出：编译输出： Compiling FIG7_13.C: Compiling FIG7_13.C: Error FIG7_13.C8: Cannot modify a const object Error FIG7_13.C8: Cannot modify a const object Error FIG7_13.C9: Cannot modify a const objiect Error FIG7_13.C9: Cannot modify a const objiect Warning FIG7_13.C11:ptr is assig

101、ned a value that is Warning FIG7_13.C11:ptr is assigned a value that is never used never used Warning FIG7_13.C11:y is deciared but never used Warning FIG7_13.C11:y is deciared but never used图图图图7. 13 7. 13 试图修改指向常量数据的常量指针试图修改指向常量数据的常量指针试图修改指向常量数据的常量指针试图修改指向常量数据的常量指针使用传引用调用的泡沫排序法使用传引用调用的泡沫排序法uu 下面用两

102、个函数下面用两个函数下面用两个函数下面用两个函数bubbleSort bubbleSort bubbleSort bubbleSort 和和和和swap swap swap swap 修改图修改图修改图修改图6.14 6.14 6.14 6.14 中的泡中的泡中的泡中的泡沫排序法程序。函数沫排序法程序。函数沫排序法程序。函数沫排序法程序。函数bubbleSort bubbleSort bubbleSort bubbleSort 用来排序数组，它调用函数用来排序数组，它调用函数用来排序数组，它调用函数用来排序数组，它调用函数swap swap swap swap 交换数组元素交换数组元素交换数组

103、元素交换数组元素arrayj arrayj arrayj arrayj 和和和和arrayj + 1 arrayj + 1 arrayj + 1 arrayj + 1 见图见图见图见图7.147.147.147.14。因为函数之间的信息是相互隐藏的因为函数之间的信息是相互隐藏的因为函数之间的信息是相互隐藏的因为函数之间的信息是相互隐藏的, , , , 所以所以所以所以swap swap swap swap 无权访问无权访问无权访问无权访问bubbleSort bubbleSort bubbleSort bubbleSort 中的单个数组元素中的单个数组元素中的单个数组元素中的单个数组元素uu

104、由于由于由于由于bubbleSort bubbleSort bubbleSort bubbleSort 要让函数要让函数要让函数要让函数swap swap swap swap 访问要交换的数组元素，访问要交换的数组元素，访问要交换的数组元素，访问要交换的数组元素，因此因此因此因此bubbleSort bubbleSort bubbleSort bubbleSort 把数组元素通过传引用的方式传递给函数把数组元素通过传引用的方式传递给函数把数组元素通过传引用的方式传递给函数把数组元素通过传引用的方式传递给函数swapswapswapswap即明确地传递数组元素的地址。尽管整个数组可自即明确地传递

105、数组元素的地址。尽管整个数组可自即明确地传递数组元素的地址。尽管整个数组可自即明确地传递数组元素的地址。尽管整个数组可自动以传引用方式传递，动以传引用方式传递，动以传引用方式传递，动以传引用方式传递， 但数组元素是标量，通常以传值方式但数组元素是标量，通常以传值方式但数组元素是标量，通常以传值方式但数组元素是标量，通常以传值方式传递。故此，传递。故此，传递。故此，传递。故此，bubbleSort bubbleSort bubbleSort bubbleSort 在调用在调用在调用在调用swap swap swap swap 时对数组元素使用地时对数组元素使用地时对数组元素使用地时对数组元素使用

106、地址运算符址运算符址运算符址运算符& & & &，从而实现了传引用调用：，从而实现了传引用调用：，从而实现了传引用调用：，从而实现了传引用调用：uu swap swap swap swap&arrayj, &arrayj + 1&arrayj, &arrayj + 1&arrayj, &arrayj + 1&arrayj, &arrayj + 1; ; ; ;uu函数函数函数函数swap swap swap swap 用指针用指针用指针用指针element1Ptr element1Ptr element1Ptr element1Ptr 接收接收接收接收&arrayj &arrayj &arra

107、yj &arrayj 。尽管。尽管。尽管。尽管swap swap swap swap 不知道数组元素的名字不知道数组元素的名字不知道数组元素的名字不知道数组元素的名字arrayj arrayj arrayj arrayj ，但通过间接引用，但通过间接引用，但通过间接引用，但通过间接引用*element1Ptr,*element1Ptr,*element1Ptr,*element1Ptr,它实际上访问了它实际上访问了它实际上访问了它实际上访问了bubbleSort bubbleSort bubbleSort bubbleSort 中的中的中的中的arrayj arrayj arrayj arra

108、yj 使用传引用调用的泡沫排序法使用传引用调用的泡沫排序法uu 尽管函数尽管函数尽管函数尽管函数swap swap swap swap 中不允许使用如下语句：中不允许使用如下语句：中不允许使用如下语句：中不允许使用如下语句：uu temp = arrayj; temp = arrayj; temp = arrayj; temp = arrayj;uu arrayj = arrayj + 1; arrayj = arrayj + 1; arrayj = arrayj + 1; arrayj = arrayj + 1;uu arrayj +1 = temp; arrayj +1 = temp; a

109、rrayj +1 = temp; arrayj +1 = temp;uu来实现来实现来实现来实现arrayj arrayj arrayj arrayj 值与值与值与值与arrayj + 1 arrayj + 1 arrayj + 1 arrayj + 1 值的交换，但是，使值的交换，但是，使值的交换，但是，使值的交换，但是，使用下面的语句可到达同样的效果见图用下面的语句可到达同样的效果见图用下面的语句可到达同样的效果见图用下面的语句可到达同样的效果见图7.147.147.147.14: : : :uu temp = *element1Ptr ; temp = *element1Ptr ; te

110、mp = *element1Ptr ; temp = *element1Ptr ;uu *element1Ptr = *element2Ptr ; *element1Ptr = *element2Ptr ; *element1Ptr = *element2Ptr ; *element1Ptr = *element2Ptr ;uu *element2Ptr = temp; *element2Ptr = temp; *element2Ptr = temp; *element2Ptr = temp;uu在这里，由于指针变量在这里，由于指针变量在这里，由于指针变量在这里，由于指针变量element1P

111、tr element1Ptr element1Ptr element1Ptr 中保存的是主调函数中保存的是主调函数中保存的是主调函数中保存的是主调函数传送给它的传送给它的传送给它的传送给它的&arrayj &arrayj &arrayj &arrayj ，指针变量，指针变量，指针变量，指针变量element2Ptr element2Ptr element2Ptr element2Ptr 中保存的是中保存的是中保存的是中保存的是主调函数传送给它的主调函数传送给它的主调函数传送给它的主调函数传送给它的&arrayj + 1 &arrayj + 1 &arrayj + 1 &arrayj + 1 ，

112、因此，因此，因此，因此，*element1Ptr *element1Ptr *element1Ptr *element1Ptr 就等价于就等价于就等价于就等价于arrayj arrayj arrayj arrayj ， *element2Ptr *element2Ptr *element2Ptr *element2Ptr 就等价于就等价于就等价于就等价于arrayj + 1 arrayj + 1 arrayj + 1 arrayj + 1 ，由此实现了，由此实现了，由此实现了，由此实现了arrayj arrayj arrayj arrayj 与与与与arrayj + 1 arrayj + 1

113、arrayj + 1 arrayj + 1 间的值交换间的值交换间的值交换间的值交换使用传引用调用的泡沫排序法使用传引用调用的泡沫排序法uu 函数函数函数函数bubbleSort bubbleSort bubbleSort bubbleSort 有几个特点应该引起注意：有几个特点应该引起注意：有几个特点应该引起注意：有几个特点应该引起注意：uu 函数的头部把函数的头部把函数的头部把函数的头部把ayyay ayyay ayyay ayyay 声明为声明为声明为声明为int *array int *array int *array int *array 而不是而不是而不是而不是int array

114、int array int array int array 这两种写法是可以互换的，说明该参数接收一个这两种写法是可以互换的，说明该参数接收一个这两种写法是可以互换的，说明该参数接收一个这两种写法是可以互换的，说明该参数接收一个int int int int 型型型型的一维数组的一维数组的一维数组的一维数组uu 为使参数为使参数为使参数为使参数size size size size 不在函数体中被修改，参数不在函数体中被修改，参数不在函数体中被修改，参数不在函数体中被修改，参数size size size size 用用用用const const const const 予以声明。尽管予以声明

115、。尽管予以声明。尽管予以声明。尽管size size size size 接收接收接收接收main main main main 中某个值的拷贝，且修改这个中某个值的拷贝，且修改这个中某个值的拷贝，且修改这个中某个值的拷贝，且修改这个值不能改变值不能改变值不能改变值不能改变main main main main 中相应的值，但是中相应的值，但是中相应的值，但是中相应的值，但是bubbleSort bubbleSort bubbleSort bubbleSort 为完成其任务为完成其任务为完成其任务为完成其任务并不需要修改并不需要修改并不需要修改并不需要修改size, size, size, s

116、ize, 数组的大小在执行数组的大小在执行数组的大小在执行数组的大小在执行bubbleSort bubbleSort bubbleSort bubbleSort 的过程中的过程中的过程中的过程中无需也不能被修改。因此，为保证无需也不能被修改。因此，为保证无需也不能被修改。因此，为保证无需也不能被修改。因此，为保证size size size size 的值不被修改，的值不被修改，的值不被修改，的值不被修改，size size size size 被声明为被声明为被声明为被声明为constconstconstconstuu 由于只有函数由于只有函数由于只有函数由于只有函数bubbleSort b

117、ubbleSort bubbleSort bubbleSort 函数调用函数函数调用函数函数调用函数函数调用函数swap, swap, swap, swap, 故将故将故将故将swap swap swap swap 的函数原型放在的函数原型放在的函数原型放在的函数原型放在bubbleSort bubbleSort bubbleSort bubbleSort 的函数体中，从而保证了只能在的函数体中，从而保证了只能在的函数体中，从而保证了只能在的函数体中，从而保证了只能在bubbleSort bubbleSort bubbleSort bubbleSort 中才能正确地调用中才能正确地调用中才能正

118、确地调用中才能正确地调用swapswapswapswapuu 把函数原型放在其它函数定义中可保证只在出现函数原型把函数原型放在其它函数定义中可保证只在出现函数原型把函数原型放在其它函数定义中可保证只在出现函数原型把函数原型放在其它函数定义中可保证只在出现函数原型的函数中才能正确地调用该函数的函数中才能正确地调用该函数的函数中才能正确地调用该函数的函数中才能正确地调用该函数 /* /* 本程序把存储在数组中的值按升序排序，并打印排序后的数组本程序把存储在数组中的值按升序排序，并打印排序后的数组本程序把存储在数组中的值按升序排序，并打印排序后的数组本程序把存储在数组中的值按升序排序，并打印排序后的

119、数组 */ */ # include # include # define SIZE 10 # define SIZE 10 void bubbleSort void bubbleSort（int *, const intint *, const int）; ; main main（）（）（）（） int i, aSIZE = 2, 6, 4, 8, 10, 12, 89, 68, 45, 37; int i, aSIZE = 2, 6, 4, 8, 10, 12, 89, 68, 45, 37; printf printf（”Data items in original order n”Da

120、ta items in original order n”）; ; for for（i = 0; i = SIZE 1; i+i = 0; i = SIZE 1; i+） printf printf（”%4d”, ai”%4d”, ai）; ; bubbleSort bubbleSort（a, SIZEa, SIZE）; /* ; /* 数组排序数组排序数组排序数组排序 */ */ printf printf（”nData items in ascending order n”nData items in ascending order n”）; ; for for（i = 0; i = SI

121、ZE 1; i+i = 0; i = SIZE 1; i+） printf printf（”%4d”, ai”%4d”, ai）; ; printf printf（”n”n”）; ; return 0; return 0; void bubbleSort void bubbleSort（int *array, const int sizeint *array, const int size） int pass, j; int pass, j; void swap void swap（int *, int *int *, int *）; ; for for（pass = 1; pass = si

122、ze 1; pass+pass = 1; pass = size 1; pass+） for for（j = 0; j = size 2; j+j = 0; j arrayj + 1arrayj arrayj + 1） swap swap（&arrayj, &arrayj + 1&arrayj, &arrayj + 1）; ; void swap void swap（int *element1Ptr, int *element2Ptrint *element1Ptr, int *element2Ptr） int temp; int temp; temp = *element1Ptr ; tem

123、p = *element1Ptr ; *element1Ptr = *element2Ptr ; *element1Ptr = *element2Ptr ; *element2Ptr = temp; *element2Ptr = temp; 输出结果：输出结果：输出结果：输出结果： Data items in original order Data items in original order 2 6 4 8 10 12 89 68 45 37 2 6 4 8 10 12 89 68 45 37 Data items in ascending order Data items in asce

124、nding order 2 4 6 8 10 12 37 45 68 89 2 4 6 8 10 12 37 45 68 89图图图图 7.14 7.14 用传引用调用实现泡沫排序用传引用调用实现泡沫排序用传引用调用实现泡沫排序用传引用调用实现泡沫排序uu 为了排序数组，函数为了排序数组，函数为了排序数组，函数为了排序数组，函数bubbleSort bubbleSort 必须知道数组的大小，所必须知道数组的大小，所必须知道数组的大小，所必须知道数组的大小，所以把数组大小作为其参数之一。在把数组传递给某个函数的以把数组大小作为其参数之一。在把数组传递给某个函数的以把数组大小作为其参数之一。在把数

125、组传递给某个函数的以把数组大小作为其参数之一。在把数组传递给某个函数的时候，数组第一个元素的内存地址也就传递给了函数。该地时候，数组第一个元素的内存地址也就传递给了函数。该地时候，数组第一个元素的内存地址也就传递给了函数。该地时候，数组第一个元素的内存地址也就传递给了函数。该地址没有给函数提供关于数组元素个数的任何信息，因此编程址没有给函数提供关于数组元素个数的任何信息，因此编程址没有给函数提供关于数组元素个数的任何信息，因此编程址没有给函数提供关于数组元素个数的任何信息，因此编程人员必须给函数提供数组的大小人员必须给函数提供数组的大小人员必须给函数提供数组的大小人员必须给函数提供数组的大小u

126、u 程序明确地把数组大小传递给函数程序明确地把数组大小传递给函数程序明确地把数组大小传递给函数程序明确地把数组大小传递给函数bubbleSortbubbleSort。这样做有这样做有这样做有这样做有两个好处，一是增强了函数的相对独立性，二是使实现函数两个好处，一是增强了函数的相对独立性，二是使实现函数两个好处，一是增强了函数的相对独立性，二是使实现函数两个好处，一是增强了函数的相对独立性，二是使实现函数的程序的质量得以改善。这种函数可以被任何程序用来排序的程序的质量得以改善。这种函数可以被任何程序用来排序的程序的质量得以改善。这种函数可以被任何程序用来排序的程序的质量得以改善。这种函数可以被任

127、何程序用来排序一维一维一维一维int int 型数组，其数组可以是任意大小型数组，其数组可以是任意大小型数组，其数组可以是任意大小型数组，其数组可以是任意大小uu 在给函数传递数组时也传递数组大小。这可以使函数具有在给函数传递数组时也传递数组大小。这可以使函数具有在给函数传递数组时也传递数组大小。这可以使函数具有在给函数传递数组时也传递数组大小。这可以使函数具有更好的通用性。通用的函数经常能够用于许多程序中更好的通用性。通用的函数经常能够用于许多程序中更好的通用性。通用的函数经常能够用于许多程序中更好的通用性。通用的函数经常能够用于许多程序中使用传引用调用的泡沫排序法使用传引用调用的泡沫排序法

128、uu 也可以把数组的大小存储在某个能够被整个程序访问到的也可以把数组的大小存储在某个能够被整个程序访问到的也可以把数组的大小存储在某个能够被整个程序访问到的也可以把数组的大小存储在某个能够被整个程序访问到的全局变量中，由于不需要把数组大小的拷贝传递个函数，所全局变量中，由于不需要把数组大小的拷贝传递个函数，所全局变量中，由于不需要把数组大小的拷贝传递个函数，所全局变量中，由于不需要把数组大小的拷贝传递个函数，所以效率更高。但是，其它需要排序以效率更高。但是，其它需要排序以效率更高。但是，其它需要排序以效率更高。但是，其它需要排序int int int int 型数组的程序可能并型数组的程序可能

129、并型数组的程序可能并型数组的程序可能并没有同样的全局变量，这样也就限制了函数的通用性没有同样的全局变量，这样也就限制了函数的通用性没有同样的全局变量，这样也就限制了函数的通用性没有同样的全局变量，这样也就限制了函数的通用性uu 全局变量的存在降低了函数的相对独立性，有违人们所提全局变量的存在降低了函数的相对独立性，有违人们所提全局变量的存在降低了函数的相对独立性，有违人们所提全局变量的存在降低了函数的相对独立性，有违人们所提倡的最低访问权原那么，因而在现代程序开发中不提倡使用倡的最低访问权原那么，因而在现代程序开发中不提倡使用倡的最低访问权原那么，因而在现代程序开发中不提倡使用倡的最低访问权原

130、那么，因而在现代程序开发中不提倡使用uu 设置全局变量所带来的好处是减少了参数传递所带来的有设置全局变量所带来的好处是减少了参数传递所带来的有设置全局变量所带来的好处是减少了参数传递所带来的有设置全局变量所带来的好处是减少了参数传递所带来的有关时空资源开销尽管这在现代计算机应用中通常是微缺乏关时空资源开销尽管这在现代计算机应用中通常是微缺乏关时空资源开销尽管这在现代计算机应用中通常是微缺乏关时空资源开销尽管这在现代计算机应用中通常是微缺乏道的道的道的道的uu 数组的大小也可以直接在函数体中指定。但这样做限制数组的大小也可以直接在函数体中指定。但这样做限制数组的大小也可以直接在函数体中指定。但这

131、样做限制数组的大小也可以直接在函数体中指定。但这样做限制了函数的通用性了函数的通用性了函数的通用性了函数的通用性uu 为了在编译时确定数组或其它数据类型的大小所占为了在编译时确定数组或其它数据类型的大小所占为了在编译时确定数组或其它数据类型的大小所占为了在编译时确定数组或其它数据类型的大小所占字节数字节数字节数字节数C C C C 语言提供了专门的单目运算符语言提供了专门的单目运算符语言提供了专门的单目运算符语言提供了专门的单目运算符sizeofsizeofsizeofsizeof。在用于数。在用于数。在用于数。在用于数组名时见图组名时见图组名时见图组名时见图7.157.157.157.15中

132、的程序中的程序中的程序中的程序, sizeof , sizeof , sizeof , sizeof 运算符以整数形式返运算符以整数形式返运算符以整数形式返运算符以整数形式返回数组占用的字节数回数组占用的字节数回数组占用的字节数回数组占用的字节数float float float float 变量：变量：变量：变量：4 4 4 4 字节字节字节字节 /* sizeof /* sizeof 运算符用于数组名时返回数组占用的字节数运算符用于数组名时返回数组占用的字节数运算符用于数组名时返回数组占用的字节数运算符用于数组名时返回数组占用的字节数 */ */ # include # include m

133、ain main（）（）（）（） float array20; float array20; printf printf（”The number of bytes in the array is %d n”,”The number of bytes in the array is %d n”, sizeof sizeof（arrayarray）; ; return 0; return 0; 输出结果：输出结果：输出结果：输出结果： The number of bytes in the array is 80 The number of bytes in the array is 80 图图图图

134、 7.15 sizeof 7.15 sizeof 运算符用于数组名时返回数组占用的字节数运算符用于数组名时返回数组占用的字节数运算符用于数组名时返回数组占用的字节数运算符用于数组名时返回数组占用的字节数使用传引用调用的泡沫排序法使用传引用调用的泡沫排序法使用传引用调用的泡沫排序法使用传引用调用的泡沫排序法uu PC PC PC PC 兼容机用来存储每一种标准数据类型的字节数兼容机用来存储每一种标准数据类型的字节数兼容机用来存储每一种标准数据类型的字节数兼容机用来存储每一种标准数据类型的字节数uu 存储特定数据类型的字节数是随计算机系统的变化存储特定数据类型的字节数是随计算机系统的变化存储特定数

135、据类型的字节数是随计算机系统的变化存储特定数据类型的字节数是随计算机系统的变化而变化的。在编写依赖于数据类型大小的程序和要在多而变化的。在编写依赖于数据类型大小的程序和要在多而变化的。在编写依赖于数据类型大小的程序和要在多而变化的。在编写依赖于数据类型大小的程序和要在多种系统上运行的程序时，种系统上运行的程序时，种系统上运行的程序时，种系统上运行的程序时，sizeof sizeof sizeof sizeof 确定用来存储某种类确定用来存储某种类确定用来存储某种类确定用来存储某种类型数据的字节数型数据的字节数型数据的字节数型数据的字节数uu 运算符运算符运算符运算符sizeof sizeof

136、sizeof sizeof 可用于任何变量名、变量类型和常可用于任何变量名、变量类型和常可用于任何变量名、变量类型和常可用于任何变量名、变量类型和常量量量量uu sizeof sizeof sizeof sizeof 在用于变量名非数组名或常量时，返在用于变量名非数组名或常量时，返在用于变量名非数组名或常量时，返在用于变量名非数组名或常量时，返回用来存储特定变量类型或常量所占计算机内存的字节回用来存储特定变量类型或常量所占计算机内存的字节回用来存储特定变量类型或常量所占计算机内存的字节回用来存储特定变量类型或常量所占计算机内存的字节数数数数uu 注意：如果操作数是类型名，注意：如果操作数是类型

137、名，注意：如果操作数是类型名，注意：如果操作数是类型名，sizeof sizeof sizeof sizeof 的圆括号时的圆括号时的圆括号时的圆括号时必需的，省略圆括号会导致语法错误；如果操作数是变必需的，省略圆括号会导致语法错误；如果操作数是变必需的，省略圆括号会导致语法错误；如果操作数是变必需的，省略圆括号会导致语法错误；如果操作数是变量名，量名，量名，量名，sizeof sizeof sizeof sizeof 的圆括号不是必需的的圆括号不是必需的的圆括号不是必需的的圆括号不是必需的 /* /* 演示演示演示演示 sizeof sizeof 运算符运算符运算符运算符 */ */ # i

138、nclude # include main main（）（）（）（） printf printf（” sizeof” sizeof（charchar）= %d n”, sizeof= %d n”, sizeof（charchar）; ; printf printf（” sizeof” sizeof（shortshort）= %d n”, sizeof= %d n”, sizeof（shortshort）; ; printf printf（” sizeof” sizeof（intint）= %d n”, sizeof= %d n”, sizeof（intint）; ; printf printf

139、（” sizeof” sizeof（longlong）= %d n”, sizeof= %d n”, sizeof（longlong）; ; printf printf（” sizeof” sizeof（floatfloat）= %d n”, sizeof= %d n”, sizeof（floatfloat）; ; printf printf（” sizeof” sizeof（doubledouble）= %d n”, sizeof= %d n”, sizeof（doubledouble）; ; printf printf（” sizeof” sizeof（long doublelong do

140、uble）= %d n”, sizeof= %d n”, sizeof（long doublelong double）; ; return 0; return 0; 输出结果：输出结果：输出结果：输出结果： sizeof sizeof（charchar） = 1 = 1 sizeof sizeof（shortshort） = 2 = 2 sizeof sizeof（intint） = 2 = 2 sizeof sizeof（longlong） = 4 = 4 sizeof sizeof（floatfloat） = 4 = 4 sizeof sizeof（doubledouble） = 8 =

141、8 sizeof sizeof（long doublelong double） = 10 = 10图图图图 7. 16 7. 16 用用用用 sizeof sizeof 运算符确定标准数据类型的大小运算符确定标准数据类型的大小运算符确定标准数据类型的大小运算符确定标准数据类型的大小指针表达式和指针的算术运算指针表达式和指针的算术运算uu 在算术表达式、赋值表达式和比较表达式关系表达式、在算术表达式、赋值表达式和比较表达式关系表达式、在算术表达式、赋值表达式和比较表达式关系表达式、在算术表达式、赋值表达式和比较表达式关系表达式、逻辑表达式中，指针是合法的操作数。但是，并非所有的逻辑表达式中，指针

142、是合法的操作数。但是，并非所有的逻辑表达式中，指针是合法的操作数。但是，并非所有的逻辑表达式中，指针是合法的操作数。但是，并非所有的运算符在与指针变量一起使用时都是合法的。本节介绍能够运算符在与指针变量一起使用时都是合法的。本节介绍能够运算符在与指针变量一起使用时都是合法的。本节介绍能够运算符在与指针变量一起使用时都是合法的。本节介绍能够把指针作为操作数的运算符以及怎样使用这些运算符把指针作为操作数的运算符以及怎样使用这些运算符把指针作为操作数的运算符以及怎样使用这些运算符把指针作为操作数的运算符以及怎样使用这些运算符uu 可以对指针进行有限的算术运算，包括自增运算可以对指针进行有限的算术运算

143、，包括自增运算可以对指针进行有限的算术运算，包括自增运算可以对指针进行有限的算术运算，包括自增运算+ + + + +、自减运算自减运算自减运算自减运算- - - - -、加上一个整数或、加上一个整数或、加上一个整数或、加上一个整数或 += += += +=、减去一个整、减去一个整、减去一个整、减去一个整数或数或数或数或 -= -= -= -=以及减去另一个指针以及减去另一个指针以及减去另一个指针以及减去另一个指针uu 假定声明了数组假定声明了数组假定声明了数组假定声明了数组int v10, int v10, int v10, int v10, 其第一个元素的存储单元为其第一个元素的存储单元为其

144、第一个元素的存储单元为其第一个元素的存储单元为3000300030003000，指针，指针，指针，指针vPtr vPtr vPtr vPtr 被初始化为指向被初始化为指向被初始化为指向被初始化为指向 v0 v0 v0 v0 即即即即vPtr vPtr vPtr vPtr 的值为的值为的值为的值为3000300030003000。3000 3000 v0v0 v1v1 v2v2 v3v3 v4v43004 3004 3008 3008 3012 3012 3016 3016 存储单元存储单元存储单元存储单元 指针变量指针变量指针变量指针变量vPtr vPtr 图图图图7. 17 7. 17 数组

145、数组数组数组v v 和指向和指向和指向和指向 v v 的指针变量的指针变量的指针变量的指针变量 vPtr vPtr图图图图7.17 7.17 图示了图示了图示了图示了这些变量在这些变量在这些变量在这些变量在int int 型数占型数占型数占型数占4 4个个个个字节的计算机字节的计算机字节的计算机字节的计算机中的内存映象中的内存映象中的内存映象中的内存映象指针表达式和指针的算术运算指针表达式和指针的算术运算uu 用如下任意一条语句都可以把用如下任意一条语句都可以把用如下任意一条语句都可以把用如下任意一条语句都可以把vPtr vPtr 初始化为指向数组初始化为指向数组初始化为指向数组初始化为指向数

146、组v:v: vPtr vPtr = v;= v; vPtr vPtr = &v0;= &v0;uu 当今大多数计算机都是用当今大多数计算机都是用当今大多数计算机都是用当今大多数计算机都是用2 2 2 2个字节或个字节或个字节或个字节或4 4 4 4个字节存储个字节存储个字节存储个字节存储int int 型数型数型数型数据。某些较新的计算机用据。某些较新的计算机用据。某些较新的计算机用据。某些较新的计算机用8 8个字节存储个字节存储个字节存储个字节存储int int 型数据型数据型数据型数据。因为指针因为指针因为指针因为指针算术运算的结果依赖于指针所指向对象的大小，所以，指针算术运算的结果依赖于

147、指针所指向对象的大小，所以，指针算术运算的结果依赖于指针所指向对象的大小，所以，指针算术运算的结果依赖于指针所指向对象的大小，所以，指针算术运算算术运算算术运算算术运算与机器有关与机器有关与机器有关与机器有关3000 3000 v0v0 v1v1 v2v2 v3v3 v4v43004 3004 3008 3008 3012 3012 3016 3016 存储单元存储单元存储单元存储单元 指针变量指针变量指针变量指针变量vPtr vPtr 图图图图7. 18 7. 18 经过算术运算后的指针经过算术运算后的指针经过算术运算后的指针经过算术运算后的指针 vPtr vPtruu 在常规的算术运算中，

148、在常规的算术运算中，在常规的算术运算中，在常规的算术运算中，3000+23000+23000+23000+2的结果为的结果为的结果为的结果为3002300230023002，但是，但是，但是，但是，指针算术运算通常不是这种指针算术运算通常不是这种指针算术运算通常不是这种指针算术运算通常不是这种情况。当一个指针加上或减情况。当一个指针加上或减情况。当一个指针加上或减情况。当一个指针加上或减去一个整数时，并非简单地去一个整数时，并非简单地去一个整数时，并非简单地去一个整数时，并非简单地加上或减去该整数值，而是加上或减去该整数值，而是加上或减去该整数值，而是加上或减去该整数值，而是加减该整数与指针引

149、用的对加减该整数与指针引用的对加减该整数与指针引用的对加减该整数与指针引用的对象的大小的乘积象的大小的乘积象的大小的乘积象的大小的乘积指针表达式和指针的算术运算指针表达式和指针的算术运算uu 也就是说，当把一个指针变量的值与一个整数相加减也就是说，当把一个指针变量的值与一个整数相加减也就是说，当把一个指针变量的值与一个整数相加减也就是说，当把一个指针变量的值与一个整数相加减时，其结果随指针所指对象的大小所占内存单元的字节数时，其结果随指针所指对象的大小所占内存单元的字节数时，其结果随指针所指对象的大小所占内存单元的字节数时，其结果随指针所指对象的大小所占内存单元的字节数的不同而不同。对象的大小

150、字节数取决于对象的数据的不同而不同。对象的大小字节数取决于对象的数据的不同而不同。对象的大小字节数取决于对象的数据的不同而不同。对象的大小字节数取决于对象的数据类型。例如，语句类型。例如，语句类型。例如，语句类型。例如，语句uu vPtr += 2; vPtr += 2; vPtr += 2; vPtr += 2;uu当一个整数在内存中占当一个整数在内存中占当一个整数在内存中占当一个整数在内存中占4 4 4 4个字节时，结果为个字节时，结果为个字节时，结果为个字节时，结果为30083008300830083000+2*43000+2*43000+2*43000+2*4，vPtr vPtr vP

151、tr vPtr 指向了数组中的指向了数组中的指向了数组中的指向了数组中的v2 v2 v2 v2 见图见图见图见图7.187.187.187.18。当一个整数。当一个整数。当一个整数。当一个整数在内存中占在内存中占在内存中占在内存中占2 2 2 2个字节时，上述计算结果使指针指向存储单元个字节时，上述计算结果使指针指向存储单元个字节时，上述计算结果使指针指向存储单元个字节时，上述计算结果使指针指向存储单元30043004300430043000+2*23000+2*23000+2*23000+2*2。如果数组是其它数据类型。如果数组是其它数据类型。如果数组是其它数据类型。如果数组是其它数据类型,

152、 , , , 上述语句就上述语句就上述语句就上述语句就会把指针加上该数据类型的一个对象所占内存字节数的两倍会把指针加上该数据类型的一个对象所占内存字节数的两倍会把指针加上该数据类型的一个对象所占内存字节数的两倍会把指针加上该数据类型的一个对象所占内存字节数的两倍uu 如果如果如果如果vPtr vPtr vPtr vPtr 已经被增加到已经被增加到已经被增加到已经被增加到3016301630163016指向指向指向指向v4v4v4v4，语句，语句，语句，语句uu vPtr -= 4; vPtr -= 4; vPtr -= 4; vPtr -= 4;uu就会把就会把就会把就会把vPtr vPtr

153、vPtr vPtr 设置为设置为设置为设置为3000300030003000数组的起始地址，即指向数组数组的起始地址，即指向数组数组的起始地址，即指向数组数组的起始地址，即指向数组元素元素元素元素v0v0v0v0指针表达式和指针的算术运算指针表达式和指针的算术运算uu 如果要把指针加如果要把指针加如果要把指针加如果要把指针加1 1 1 1或减或减或减或减1 1 1 1，这时可使用自增运算符，这时可使用自增运算符，这时可使用自增运算符，这时可使用自增运算符+ + + + +或自减运算符或自减运算符或自减运算符或自减运算符- - - - -。语句。语句。语句。语句uu +vPtr; +vPtr;

154、+vPtr; +vPtr;uu vPtr+; vPtr+; vPtr+; vPtr+;uu都把指针指向数组中的下一个元素。语句都把指针指向数组中的下一个元素。语句都把指针指向数组中的下一个元素。语句都把指针指向数组中的下一个元素。语句uu -vPtr; -vPtr; -vPtr; -vPtr;uu vPtr-; vPtr-; vPtr-; vPtr-;uu都把指针指向数组中的上一个元素都把指针指向数组中的上一个元素都把指针指向数组中的上一个元素都把指针指向数组中的上一个元素uu 可以从指针变量中减去另一个指针变量。例如，如果可以从指针变量中减去另一个指针变量。例如，如果可以从指针变量中减去另一

155、个指针变量。例如，如果可以从指针变量中减去另一个指针变量。例如，如果vPtr vPtr vPtr vPtr 包含存储单元地址包含存储单元地址包含存储单元地址包含存储单元地址3000300030003000指向数组元素指向数组元素指向数组元素指向数组元素v0v0v0v0，而，而，而，而v2Ptr v2Ptr v2Ptr v2Ptr 包包包包含存储单元地址含存储单元地址含存储单元地址含存储单元地址3008300830083008指向数组元素指向数组元素指向数组元素指向数组元素v2 v2 v2 v2 ，那么语句，那么语句，那么语句，那么语句uu x = v2Ptr vPtr; x = v2Ptr v

156、Ptr; x = v2Ptr vPtr; x = v2Ptr vPtr;uu把从把从把从把从vPtr vPtr vPtr vPtr 到到到到v2Ptrv2Ptrv2Ptrv2Ptr的数组元素的个数赋给变量的数组元素的个数赋给变量的数组元素的个数赋给变量的数组元素的个数赋给变量x x x x本例为本例为本例为本例为2 2 2 2指针表达式和指针的算术运算指针表达式和指针的算术运算uu 注意，除了数组组元素外，不能认为两个相同类型的变量注意，除了数组组元素外，不能认为两个相同类型的变量注意，除了数组组元素外，不能认为两个相同类型的变量注意，除了数组组元素外，不能认为两个相同类型的变量是在内存中连续

157、存储的，所以，指针算术运算除了用于数组是在内存中连续存储的，所以，指针算术运算除了用于数组是在内存中连续存储的，所以，指针算术运算除了用于数组是在内存中连续存储的，所以，指针算术运算除了用于数组外没有什么意义外没有什么意义外没有什么意义外没有什么意义uu 在涉及指针算术运算的程序处理时更准确地讲是在编程在涉及指针算术运算的程序处理时更准确地讲是在编程在涉及指针算术运算的程序处理时更准确地讲是在编程在涉及指针算术运算的程序处理时更准确地讲是在编程时，容易出现的错误是：时，容易出现的错误是：时，容易出现的错误是：时，容易出现的错误是：uu 对不指向数组的指针进行算术运算对不指向数组的指针进行算术运

158、算对不指向数组的指针进行算术运算对不指向数组的指针进行算术运算uu 把不指向同一个数组的两个指针相减或比较把不指向同一个数组的两个指针相减或比较把不指向同一个数组的两个指针相减或比较把不指向同一个数组的两个指针相减或比较uu 指针算术运算的结果超出了数组的范围指针算术运算的结果超出了数组的范围指针算术运算的结果超出了数组的范围指针算术运算的结果超出了数组的范围uu 如果两个指针类型相同即它们指向相同类型的数据对象如果两个指针类型相同即它们指向相同类型的数据对象如果两个指针类型相同即它们指向相同类型的数据对象如果两个指针类型相同即它们指向相同类型的数据对象，那么可以把一个指针变量的值赋给另一个指

159、针变量。否，那么可以把一个指针变量的值赋给另一个指针变量。否，那么可以把一个指针变量的值赋给另一个指针变量。否，那么可以把一个指针变量的值赋给另一个指针变量。否那么，必须用强制类型转换运算符把赋值运算符右边指针的那么，必须用强制类型转换运算符把赋值运算符右边指针的那么，必须用强制类型转换运算符把赋值运算符右边指针的那么，必须用强制类型转换运算符把赋值运算符右边指针的类型转换为赋值运算符左边指针的类型。指向类型转换为赋值运算符左边指针的类型。指向类型转换为赋值运算符左边指针的类型。指向类型转换为赋值运算符左边指针的类型。指向void void void void 类型的指类型的指类型的指类型的指

160、针即针即针即针即void *void *void *void *是例外，它可以表示任何类型的指针。任何是例外，它可以表示任何类型的指针。任何是例外，它可以表示任何类型的指针。任何是例外，它可以表示任何类型的指针。任何类型的指针都可赋给指向类型的指针都可赋给指向类型的指针都可赋给指向类型的指针都可赋给指向void void void void 类型的指针，指向类型的指针，指向类型的指针，指向类型的指针，指向void void void void 类型类型类型类型的指针也可赋给任何类型的指针，两者都不需要强制类型转的指针也可赋给任何类型的指针，两者都不需要强制类型转的指针也可赋给任何类型的指针，两

161、者都不需要强制类型转的指针也可赋给任何类型的指针，两者都不需要强制类型转换换换换指针表达式和指针的算术运算指针表达式和指针的算术运算uu 不能复引用间接访问指向不能复引用间接访问指向不能复引用间接访问指向不能复引用间接访问指向void void void void 类型的指针。例如，类型的指针。例如，类型的指针。例如，类型的指针。例如，在整数在整数在整数在整数int int int int 类型占类型占类型占类型占4 4 4 4个字节的机器上，编译程序知道指向个字节的机器上，编译程序知道指向个字节的机器上，编译程序知道指向个字节的机器上，编译程序知道指向int int int int 类型的指

162、针引用了内存的类型的指针引用了内存的类型的指针引用了内存的类型的指针引用了内存的4 4 4 4个字节，但是一个指向个字节，但是一个指向个字节，但是一个指向个字节，但是一个指向void void void void 类型的指针仅仅包含了不知道数据类型的地址，编译程序不类型的指针仅仅包含了不知道数据类型的地址，编译程序不类型的指针仅仅包含了不知道数据类型的地址，编译程序不类型的指针仅仅包含了不知道数据类型的地址，编译程序不知道该指针到底要引用多少字节数。编译程序必须知道数据知道该指针到底要引用多少字节数。编译程序必须知道数据知道该指针到底要引用多少字节数。编译程序必须知道数据知道该指针到底要引用多

163、少字节数。编译程序必须知道数据类型后才能确定某个特定的指针要复引用的字节数。因此，类型后才能确定某个特定的指针要复引用的字节数。因此，类型后才能确定某个特定的指针要复引用的字节数。因此，类型后才能确定某个特定的指针要复引用的字节数。因此，对于对于对于对于void void void void 类型的指针，编译程序不能根据类型确定它引用的类型的指针，编译程序不能根据类型确定它引用的类型的指针，编译程序不能根据类型确定它引用的类型的指针，编译程序不能根据类型确定它引用的字节数字节数字节数字节数uu 把一种类型的指针赋给另一种类型的指针，而当这两种把一种类型的指针赋给另一种类型的指针，而当这两种把一

164、种类型的指针赋给另一种类型的指针，而当这两种把一种类型的指针赋给另一种类型的指针，而当这两种指针都不是指针都不是指针都不是指针都不是void void void void 类型时，这是一种语法错误。复引用类型时，这是一种语法错误。复引用类型时，这是一种语法错误。复引用类型时，这是一种语法错误。复引用void * void * void * void * 指针，也是一种语法错误指针，也是一种语法错误指针，也是一种语法错误指针，也是一种语法错误uu 可以用相等测试运算符和关系运算符比较两个指针，但是，可以用相等测试运算符和关系运算符比较两个指针，但是，可以用相等测试运算符和关系运算符比较两个指针，

165、但是，可以用相等测试运算符和关系运算符比较两个指针，但是，除非它们是指向同一个数组，否那么，这种比较是没有意义除非它们是指向同一个数组，否那么，这种比较是没有意义除非它们是指向同一个数组，否那么，这种比较是没有意义除非它们是指向同一个数组，否那么，这种比较是没有意义的。比较两个指针实际上是比较所存储的地址。例如，比较的。比较两个指针实际上是比较所存储的地址。例如，比较的。比较两个指针实际上是比较所存储的地址。例如，比较的。比较两个指针实际上是比较所存储的地址。例如，比较两个指向同一数组的指针反映了指针所指向元素的先后顺序。两个指向同一数组的指针反映了指针所指向元素的先后顺序。两个指向同一数组的

166、指针反映了指针所指向元素的先后顺序。两个指向同一数组的指针反映了指针所指向元素的先后顺序。指针比较常用来判断某个指针是否是指针比较常用来判断某个指针是否是指针比较常用来判断某个指针是否是指针比较常用来判断某个指针是否是NULLNULLNULLNULL指针和数组的关系指针和数组的关系uu C C C C 语言中的指针和数组有着密切的关系。数组名可以认为语言中的指针和数组有着密切的关系。数组名可以认为语言中的指针和数组有着密切的关系。数组名可以认为语言中的指针和数组有着密切的关系。数组名可以认为是一个常量指针，指针可用来完成涉及数组下标的操作是一个常量指针，指针可用来完成涉及数组下标的操作是一个常

167、量指针，指针可用来完成涉及数组下标的操作是一个常量指针，指针可用来完成涉及数组下标的操作uu 由于数组下标在编译的时候要被转换成指针表示法，因此由于数组下标在编译的时候要被转换成指针表示法，因此由于数组下标在编译的时候要被转换成指针表示法，因此由于数组下标在编译的时候要被转换成指针表示法，因此用指针编写数组下标表达式可节省编译时间用指针编写数组下标表达式可节省编译时间用指针编写数组下标表达式可节省编译时间用指针编写数组下标表达式可节省编译时间uu 然而，在操作数组时最好用下标表示法而不使用指针表示然而，在操作数组时最好用下标表示法而不使用指针表示然而，在操作数组时最好用下标表示法而不使用指针表

168、示然而，在操作数组时最好用下标表示法而不使用指针表示法。因为，尽管下标表示法在源程序编译时要稍微多花点时法。因为，尽管下标表示法在源程序编译时要稍微多花点时法。因为，尽管下标表示法在源程序编译时要稍微多花点时法。因为，尽管下标表示法在源程序编译时要稍微多花点时间，但程序的可读性通常会更好间，但程序的可读性通常会更好间，但程序的可读性通常会更好间，但程序的可读性通常会更好uu 假定已经声明了假定已经声明了假定已经声明了假定已经声明了int int int int 型数组型数组型数组型数组b5 b5 b5 b5 和和和和int * int * int * int * 类型的指针变类型的指针变类型的

169、指针变类型的指针变量量量量bPtrbPtrbPtrbPtr。由于数组名不带下标是指向数组第一个元素的。由于数组名不带下标是指向数组第一个元素的。由于数组名不带下标是指向数组第一个元素的。由于数组名不带下标是指向数组第一个元素的指针，因此，指针，因此，指针，因此，指针，因此， 可用如下语句使可用如下语句使可用如下语句使可用如下语句使bPtr bPtr bPtr bPtr 指向等于数组指向等于数组指向等于数组指向等于数组b b b b 的的的的第一个元素的地址：第一个元素的地址：第一个元素的地址：第一个元素的地址：uu bPtr = b; bPtr = b; bPtr = b; bPtr = b;

170、uu该语句等价于取数组第一个元素的地址：该语句等价于取数组第一个元素的地址：该语句等价于取数组第一个元素的地址：该语句等价于取数组第一个元素的地址：uu bPtr = &b0; bPtr = &b0; bPtr = &b0; bPtr = &b0;指针和数组的关系指针和数组的关系uu 如下的指针表达式引用了数组元素如下的指针表达式引用了数组元素如下的指针表达式引用了数组元素如下的指针表达式引用了数组元素b3:b3:b3:b3:uu * * * *bPtr + 3bPtr + 3bPtr + 3bPtr + 3uu表达式中的表达式中的表达式中的表达式中的3 3 3 3是相对于指针的偏移量。当该指

171、针指向数是相对于指针的偏移量。当该指针指向数是相对于指针的偏移量。当该指针指向数是相对于指针的偏移量。当该指针指向数组的起始位置时，偏移量说明了引用哪一个数组元素，它组的起始位置时，偏移量说明了引用哪一个数组元素，它组的起始位置时，偏移量说明了引用哪一个数组元素，它组的起始位置时，偏移量说明了引用哪一个数组元素，它等于数组的下标。上述表示法称为等于数组的下标。上述表示法称为等于数组的下标。上述表示法称为等于数组的下标。上述表示法称为“指针指针指针指针/ / / / 偏移量表示法偏移量表示法偏移量表示法偏移量表示法 。因为。因为。因为。因为 * * * * 的优先级高于的优先级高于的优先级高于的

172、优先级高于 + + + + 的优先级，所以圆括号是的优先级，所以圆括号是的优先级，所以圆括号是的优先级，所以圆括号是必需的。如果没有圆括号，上述表达式就会把必需的。如果没有圆括号，上述表达式就会把必需的。如果没有圆括号，上述表达式就会把必需的。如果没有圆括号，上述表达式就会把3 3 3 3 和表达式和表达式和表达式和表达式*bPtr *bPtr *bPtr *bPtr 的值相加假定的值相加假定的值相加假定的值相加假定bPtr bPtr bPtr bPtr 指向数组的起始位置，表达指向数组的起始位置，表达指向数组的起始位置，表达指向数组的起始位置，表达式就把式就把式就把式就把3 3 3 3 和和

173、和和b0 b0 b0 b0 相加相加相加相加uu 就象能够用指针表达式引用数组元素一样，也可用指就象能够用指针表达式引用数组元素一样，也可用指就象能够用指针表达式引用数组元素一样，也可用指就象能够用指针表达式引用数组元素一样，也可用指针表达式针表达式针表达式针表达式uu bPtr + 3 bPtr + 3 bPtr + 3 bPtr + 3uu引用地址引用地址引用地址引用地址uu &b3 &b3 &b3 &b3 指针和数组的关系指针和数组的关系uu 数组名本身就是一个指针，可用在指针算术运算中。例如，数组名本身就是一个指针，可用在指针算术运算中。例如，数组名本身就是一个指针，可用在指针算术运算

174、中。例如，数组名本身就是一个指针，可用在指针算术运算中。例如，表达式表达式表达式表达式uu * * * *b + 3b + 3b + 3b + 3uu也引用了数组元素也引用了数组元素也引用了数组元素也引用了数组元素b3 b3 b3 b3 。通常，所有带有数组下标的表达。通常，所有带有数组下标的表达。通常，所有带有数组下标的表达。通常，所有带有数组下标的表达式都可以用指针和偏移量表示，这时要把数组名作为指针。式都可以用指针和偏移量表示，这时要把数组名作为指针。式都可以用指针和偏移量表示，这时要把数组名作为指针。式都可以用指针和偏移量表示，这时要把数组名作为指针。注意，上述语句没有修改数组名，注意

175、，上述语句没有修改数组名，注意，上述语句没有修改数组名，注意，上述语句没有修改数组名，b b b b 仍然指向数组的第一个仍然指向数组的第一个仍然指向数组的第一个仍然指向数组的第一个元素。元素。元素。元素。uu 指针也可以象数组一样带下标。例如，表达式指针也可以象数组一样带下标。例如，表达式指针也可以象数组一样带下标。例如，表达式指针也可以象数组一样带下标。例如，表达式uu bPtr1 bPtr1 bPtr1 bPtr1uu引用了数组元素引用了数组元素引用了数组元素引用了数组元素b1 b1 b1 b1 。这种表示方法称为。这种表示方法称为。这种表示方法称为。这种表示方法称为“指针指针指针指针/

176、 / / /下标表下标表下标表下标表示法示法示法示法uu 切记，数组名实际上是一个常量指针，它总是指向数组的切记，数组名实际上是一个常量指针，它总是指向数组的切记，数组名实际上是一个常量指针，它总是指向数组的切记，数组名实际上是一个常量指针，它总是指向数组的起始位置。因此，表达式起始位置。因此，表达式起始位置。因此，表达式起始位置。因此，表达式uu b += 3 b += 3 b += 3 b += 3uu是不正确的，因为它试图用指针算术运算修改数组名的值是不正确的，因为它试图用指针算术运算修改数组名的值是不正确的，因为它试图用指针算术运算修改数组名的值是不正确的，因为它试图用指针算术运算修改

177、数组名的值指针和数组的关系指针和数组的关系uu 试图用指针算术运算修改数组名是一种语法错误试图用指针算术运算修改数组名是一种语法错误试图用指针算术运算修改数组名是一种语法错误试图用指针算术运算修改数组名是一种语法错误uu 由此可见，在由此可见，在由此可见，在由此可见，在C C C C 语言中，引用一个确定数组的数组元语言中，引用一个确定数组的数组元语言中，引用一个确定数组的数组元语言中，引用一个确定数组的数组元素可有四种方法：素可有四种方法：素可有四种方法：素可有四种方法：uu 下标表示法使用带下标的数组元素名下标表示法使用带下标的数组元素名下标表示法使用带下标的数组元素名下标表示法使用带下标

178、的数组元素名uu 把数组名作为指针的指针把数组名作为指针的指针把数组名作为指针的指针把数组名作为指针的指针/ / / /偏移量表示法如前面已见偏移量表示法如前面已见偏移量表示法如前面已见偏移量表示法如前面已见到的到的到的到的 * * * *b+3b+3b+3b+3uu 指针指针指针指针/ / / /下标表示法下标表示法下标表示法下标表示法uu 使用指针变量的指针使用指针变量的指针使用指针变量的指针使用指针变量的指针/ / / /偏移量表示法偏移量表示法偏移量表示法偏移量表示法uuint int int int 型数组型数组型数组型数组b b b b 中的四个元素中的四个元素中的四个元素中的四个

179、元素 /* /* 用下标和指针操作数组用下标和指针操作数组用下标和指针操作数组用下标和指针操作数组 */ */ # include # include main main（）（）（）（） int i, offset, b = 10, 20, 30, 40 ; int i, offset, b = 10, 20, 30, 40 ; int * bPtr = b; /* int * bPtr = b; /* 使使使使bPtr bPtr 指向数组指向数组指向数组指向数组b */b */ printf printf（”Array b printed with: n Array subscript no

180、tation n”Array b printed with: n Array subscript notation n”）; ; for for（i = 0; i = 3; i+i = 0; i = 3; i+） printf printf（”b%d = %d n”, i, bi”b%d = %d n”, i, bi）; ; printf printf（”nPointer/offset notation where n ”nPointer/offset notation where n ” ”the pointer is the array name n” ”the pointer is th

181、e array name n”）; ; for for（offset = 0; offset = 3; offset+offset = 0; offset = 3; offset+） printf printf（” *” *（b + %db + %d）= %d n”, offset, *= %d n”, offset, *（b + offsetb + offset）; ; printf printf（”nPointer subscript notation n”nPointer subscript notation n”）; ; for for（i = 0; i = 3; i+i = 0; i

182、 = 3; i+） printf printf（”bPtr%d = %d n”, i, bPtri”bPtr%d = %d n”, i, bPtri）; ; printf printf（”nPointer/offset notation n”nPointer/offset notation n”）; ; for for（offset = 0; offset = 3; offset+offset = 0; offset = 3; offset+） printf printf（” *” *（bPtr + %dbPtr + %d）= %d n”, offset, *= %d n”, offset,

183、*（bPtr + offsetbPtr + offset）; ; return 0; return 0; 输出结果：输出结果：输出结果：输出结果： Array b printed with: Array b printed with: array subscript notation array subscript notation b0 = 10 b0 = 10 b1 = 20 b1 = 20 b2 = 30 b2 = 30 b3 = 40 b3 = 40 Pointer / offset notation where Pointer / offset notation where the

184、pointer is the array name the pointer is the array name * *（b + 0b + 0） = 10 = 10 * *（b + 1b + 1） = 20 = 20 * *（b + 2b + 2） = 30 = 30 * *（b + 3b + 3） = 40 = 40 Pointer subscript notation Pointer subscript notation bPtr0 = 10 bPtr0 = 10 bPtr1 = 20 bPtr1 = 20 bPtr2 = 30 bPtr2 = 30 bPtr3 = 40 bPtr3 = 4

185、0 Pointer / offset notation Pointer / offset notation * *（bPtr + 0bPtr + 0） = 10 = 10 * *（bPtr + 1bPtr + 1） = 20 = 20 * *（bPtr + 2bPtr + 2） = 30 = 30 * *（bPtr + 3bPtr + 3） = 40 = 40图图图图 7. 19 7. 19 用四种方法引用数组元素用四种方法引用数组元素用四种方法引用数组元素用四种方法引用数组元素指针和数组的关系指针和数组的关系uu 为进一步说明数组和指针的互换性为进一步说明数组和指针的互换性为进一步说明数组和

186、指针的互换性为进一步说明数组和指针的互换性, , , , 我们讨论一以下图我们讨论一以下图我们讨论一以下图我们讨论一以下图7.20 7.20 7.20 7.20 的程序中的两个字符串拷贝函数的程序中的两个字符串拷贝函数的程序中的两个字符串拷贝函数的程序中的两个字符串拷贝函数copy1 copy1 copy1 copy1 和和和和 copy2 copy2 copy2 copy2。这两。这两。这两。这两个函数都把一个字符串可能是一个字符数组拷贝到一个个函数都把一个字符串可能是一个字符数组拷贝到一个个函数都把一个字符串可能是一个字符数组拷贝到一个个函数都把一个字符串可能是一个字符数组拷贝到一个字符数

187、组中。比较这两个函数的函数原型可以发现，其形式字符数组中。比较这两个函数的函数原型可以发现，其形式字符数组中。比较这两个函数的函数原型可以发现，其形式字符数组中。比较这两个函数的函数原型可以发现，其形式是相同的。虽然这两个函数完成同样的功能，但它们的的实是相同的。虽然这两个函数完成同样的功能，但它们的的实是相同的。虽然这两个函数完成同样的功能，但它们的的实是相同的。虽然这两个函数完成同样的功能，但它们的的实现过程是不同的现过程是不同的现过程是不同的现过程是不同的uu 函数函数函数函数copy1 copy1 copy1 copy1 用数组下标表示法把用数组下标表示法把用数组下标表示法把用数组下标

188、表示法把s2 s2 s2 s2 中的字符串拷贝到字中的字符串拷贝到字中的字符串拷贝到字中的字符串拷贝到字符数组符数组符数组符数组s1 s1 s1 s1 中。函数中声明了一个用作数组下标的中。函数中声明了一个用作数组下标的中。函数中声明了一个用作数组下标的中。函数中声明了一个用作数组下标的int int int int 型计数型计数型计数型计数器变量器变量器变量器变量i i i i 。for for for for 结构的头部完成了整个拷贝操作结构的头部完成了整个拷贝操作结构的头部完成了整个拷贝操作结构的头部完成了整个拷贝操作for for for for 结构结构结构结构体是空语句。此体是空语

189、句。此体是空语句。此体是空语句。此for for for for 结构的头部把结构的头部把结构的头部把结构的头部把i i i i 初始化为初始化为初始化为初始化为0 0 0 0， 并在每并在每并在每并在每次循环后把次循环后把次循环后把次循环后把i i i i递增递增递增递增1 1 1 1，条件，条件，条件，条件s1i = s2i s1i = s2i s1i = s2i s1i = s2i 执行拷贝操作，即执行拷贝操作，即执行拷贝操作，即执行拷贝操作，即把把把把s2 s2 s2 s2 中的字符拷贝到中的字符拷贝到中的字符拷贝到中的字符拷贝到s1 s1 s1 s1 中，直到遇见中，直到遇见中，直到

190、遇见中，直到遇见0 0 0 0 止止止止 uu 函数函数函数函数copy2 copy2 copy2 copy2 用指针和指针算术运算把用指针和指针算术运算把用指针和指针算术运算把用指针和指针算术运算把s2 s2 s2 s2 中的字符拷贝到中的字符拷贝到中的字符拷贝到中的字符拷贝到s1 s1 s1 s1 中。中。中。中。for for for for 结构的头部也完成了整个拷贝操作。头部没有包结构的头部也完成了整个拷贝操作。头部没有包结构的头部也完成了整个拷贝操作。头部没有包结构的头部也完成了整个拷贝操作。头部没有包含变量的初始化含变量的初始化含变量的初始化含变量的初始化指针和数组的关系指针和数

191、组的关系uu 和函数和函数和函数和函数copy1 copy1 copy1 copy1 一样，在函数一样，在函数一样，在函数一样，在函数copy2 copy2 copy2 copy2 中，拷贝操作是中，拷贝操作是中，拷贝操作是中，拷贝操作是在条件在条件在条件在条件*s1 = *s2*s1 = *s2*s1 = *s2*s1 = *s2中完成的，即复引用指针中完成的，即复引用指针中完成的，即复引用指针中完成的，即复引用指针s2 s2 s2 s2 并把并把并把并把结果赋给复引用指针结果赋给复引用指针结果赋给复引用指针结果赋给复引用指针s1s1s1s1，直到遇见，直到遇见，直到遇见，直到遇见0 0 0

192、 0 止止止止 uu 为了能够容纳第二个参数中的字符串，函数为了能够容纳第二个参数中的字符串，函数为了能够容纳第二个参数中的字符串，函数为了能够容纳第二个参数中的字符串，函数copy1 copy1 copy1 copy1 和和和和copy2 copy2 copy2 copy2 的第一个数组参数必须足够大，以能够容纳第的第一个数组参数必须足够大，以能够容纳第的第一个数组参数必须足够大，以能够容纳第的第一个数组参数必须足够大，以能够容纳第二参数给出的字符串，否那么，将会导致严重的运行错二参数给出的字符串，否那么，将会导致严重的运行错二参数给出的字符串，否那么，将会导致严重的运行错二参数给出的字符串

193、，否那么，将会导致严重的运行错误误误误uu 鉴于这两个函数在实现其功能时没有必要对第二个鉴于这两个函数在实现其功能时没有必要对第二个鉴于这两个函数在实现其功能时没有必要对第二个鉴于这两个函数在实现其功能时没有必要对第二个参数所指定的字符串进行修改，为了防止编程导致的对参数所指定的字符串进行修改，为了防止编程导致的对参数所指定的字符串进行修改，为了防止编程导致的对参数所指定的字符串进行修改，为了防止编程导致的对相应字符串可能的修改，第二个参数被设计成指向常量相应字符串可能的修改，第二个参数被设计成指向常量相应字符串可能的修改，第二个参数被设计成指向常量相应字符串可能的修改，第二个参数被设计成指向

194、常量数据的非常量指针指针是非常量的，相应函数的函数数据的非常量指针指针是非常量的，相应函数的函数数据的非常量指针指针是非常量的，相应函数的函数数据的非常量指针指针是非常量的，相应函数的函数体中可对之进行修改；而指针所指向的数据是常量，在体中可对之进行修改；而指针所指向的数据是常量，在体中可对之进行修改；而指针所指向的数据是常量，在体中可对之进行修改；而指针所指向的数据是常量，在相应函数的函数体中不能对之加以改变，假设函数的相应函数的函数体中不能对之加以改变，假设函数的相应函数的函数体中不能对之加以改变，假设函数的相应函数的函数体中不能对之加以改变，假设函数的函数体中存在对相应字符串进行改变的语

195、句，编译程序函数体中存在对相应字符串进行改变的语句，编译程序函数体中存在对相应字符串进行改变的语句，编译程序函数体中存在对相应字符串进行改变的语句，编译程序就会发出错误信息就会发出错误信息就会发出错误信息就会发出错误信息 /* /* 用数组表示法和指针表示法拷贝字符串用数组表示法和指针表示法拷贝字符串用数组表示法和指针表示法拷贝字符串用数组表示法和指针表示法拷贝字符串 */ */ # include # include void copy1 void copy1（char * , const char *char * , const char *）; ; void copy2 void cop

196、y2（char * , const char *char * , const char *）; ; main main（）（）（）（） char string110, *string2 = ”Hello”, char string110, *string2 = ”Hello”, string310, string4 = ”Good Bye”; string310, string4 = ”Good Bye”; copy1 copy1（string1, string2string1, string2）; ; printf printf（”string1 = %s n”, string1”strin

197、g1 = %s n”, string1）; ; copy2 copy2（string3, string4string3, string4）; ; printf printf（”string3 = %s n”, string3”string3 = %s n”, string3）; ; return 0; return 0; /* /* 用数组表示法把用数组表示法把用数组表示法把用数组表示法把s2 s2 拷贝到拷贝到拷贝到拷贝到s1 s1 中中中中 */ */ void copy1 void copy1（char *s1, const char *s2char *s1, const char *s

198、2） int i; int i; for for（i = 0; s1i = s2i; i+i = 0; s1i = s2i; i+） ; /* ; /* 函数体中没有任何动作函数体中没有任何动作函数体中没有任何动作函数体中没有任何动作 */ */ /* /* 用指针表示法把用指针表示法把用指针表示法把用指针表示法把s2 s2 拷贝到拷贝到拷贝到拷贝到s1 s1 中中中中 */ */ void copy2 void copy2 （char *s1, const char *s2char *s1, const char *s2） for for（; *s1 = *s2; s1+, s2+; *s1

199、 = *s2; s1+, s2+） ; /* ; /* 函数体中没有任何动作函数体中没有任何动作函数体中没有任何动作函数体中没有任何动作 */ */ 输出结果：输出结果：输出结果：输出结果： string1 = Hello string1 = Hello string3 = Good Bye string3 = Good Bye图图图图 7. 20 7. 20 用数组表示法和指针表示法拷贝字符串用数组表示法和指针表示法拷贝字符串用数组表示法和指针表示法拷贝字符串用数组表示法和指针表示法拷贝字符串指针数组指针数组uu 数组中可能会包含指针。这种数据结构常用来构造字符串数组中可能会包含指针。这种数

200、据结构常用来构造字符串数组中可能会包含指针。这种数据结构常用来构造字符串数组中可能会包含指针。这种数据结构常用来构造字符串数组数组数组数组uu 字符串数组中的每一元素都是一个字符串。但是字符串数组中的每一元素都是一个字符串。但是字符串数组中的每一元素都是一个字符串。但是字符串数组中的每一元素都是一个字符串。但是, , , ,因为在因为在因为在因为在C C C C 语言中，字符串实际上是指向字符串第一个字符的指针，所语言中，字符串实际上是指向字符串第一个字符的指针，所语言中，字符串实际上是指向字符串第一个字符的指针，所语言中，字符串实际上是指向字符串第一个字符的指针，所以字符串数组中的每一个字符

201、串实际上是指向字符串第一个以字符串数组中的每一个字符串实际上是指向字符串第一个以字符串数组中的每一个字符串实际上是指向字符串第一个以字符串数组中的每一个字符串实际上是指向字符串第一个字符的指针。以如下的字符串数组字符的指针。以如下的字符串数组字符的指针。以如下的字符串数组字符的指针。以如下的字符串数组suit suit suit suit 的声明为例的声明为例的声明为例的声明为例suit suit suit suit 代表一副牌的四种花色：代表一副牌的四种花色：代表一副牌的四种花色：代表一副牌的四种花色：uu char *suit4 = char *suit4 = char *suit4 =

202、char *suit4 = HeartsHeartsHeartsHearts, , , , DiamondsDiamondsDiamondsDiamonds, , , , ClubsClubsClubsClubs, , , , SpadesSpadesSpadesSpades;uu该声明语句中的该声明语句中的该声明语句中的该声明语句中的suit4 suit4 suit4 suit4 说明数组有说明数组有说明数组有说明数组有4 4 4 4 个元素，个元素，个元素，个元素，char * char * char * char * 说说说说明数组明数组明数组明数组suit suit suit suit

203、 的每一个元素是指向的每一个元素是指向的每一个元素是指向的每一个元素是指向char char char char 类型的指针类型的指针类型的指针类型的指针uu 放在数组中的四个值是放在数组中的四个值是放在数组中的四个值是放在数组中的四个值是“Hearts“Hearts“Hearts“Hearts 、“Diamonds“Diamonds“Diamonds“Diamonds 、“Clubs“Clubs“Clubs“Clubs和和和和“Spades“Spades“Spades“Spades ，每一个值都是以，每一个值都是以，每一个值都是以，每一个值都是以NULL NULL NULL NULL 字符终

204、止的字符终止的字符终止的字符终止的字符串，长度比引号之间的字符个数大字符串，长度比引号之间的字符个数大字符串，长度比引号之间的字符个数大字符串，长度比引号之间的字符个数大1 1 1 1uu 尽管这些字符串好似是存储在尽管这些字符串好似是存储在尽管这些字符串好似是存储在尽管这些字符串好似是存储在suit suit suit suit 数组中的，但数组中数组中的，但数组中数组中的，但数组中数组中的，但数组中实际上只存储了指针实际上只存储了指针实际上只存储了指针实际上只存储了指针HH eeaarrtt00ss DD iiaamm oonnddss00CC lluubbss00SSppaaddeess

205、00 suit 0 suit 0 suit 2 suit 2 suit 1 suit 1 suit 3 suit 3 图图图图 7. 21 7. 21 数组数组数组数组suit suit 的图示的图示的图示的图示uu 数组数组数组数组suitsuit中的每一个指针都指向其对应的字符串的第一个中的每一个指针都指向其对应的字符串的第一个中的每一个指针都指向其对应的字符串的第一个中的每一个指针都指向其对应的字符串的第一个字符。因此，尽管数组字符。因此，尽管数组字符。因此，尽管数组字符。因此，尽管数组suit suit 的大小是固定的，的大小是固定的，的大小是固定的，的大小是固定的， 但是它访问的但是

206、它访问的但是它访问的但是它访问的字符串可以是任意长度字符串可以是任意长度字符串可以是任意长度字符串可以是任意长度。这种灵活性是这种灵活性是这种灵活性是这种灵活性是C C语言强大的数据构语言强大的数据构语言强大的数据构语言强大的数据构造能力的一个例证造能力的一个例证造能力的一个例证造能力的一个例证指针数组指针数组uu 也可以将字符串数组存放在二维数组中。数组中的每一行也可以将字符串数组存放在二维数组中。数组中的每一行也可以将字符串数组存放在二维数组中。数组中的每一行也可以将字符串数组存放在二维数组中。数组中的每一行保存一个字符串，每一列保存字符串的一个字符。这种数据保存一个字符串，每一列保存字符

207、串的一个字符。这种数据保存一个字符串，每一列保存字符串的一个字符。这种数据保存一个字符串，每一列保存字符串的一个字符。这种数据结构的每一行得有固定的列数，并且列数要能够容纳最长的结构的每一行得有固定的列数，并且列数要能够容纳最长的结构的每一行得有固定的列数，并且列数要能够容纳最长的结构的每一行得有固定的列数，并且列数要能够容纳最长的字符串。因此，如果其它的字符串都比最长的的字符串短得字符串。因此，如果其它的字符串都比最长的的字符串短得字符串。因此，如果其它的字符串都比最长的的字符串短得字符串。因此，如果其它的字符串都比最长的的字符串短得多的时候就会浪费大量的内存多的时候就会浪费大量的内存多的时

208、候就会浪费大量的内存多的时候就会浪费大量的内存实例研究实例研究uu 本节要用随机数开发一个洗牌和发牌模拟程序本节要用随机数开发一个洗牌和发牌模拟程序本节要用随机数开发一个洗牌和发牌模拟程序本节要用随机数开发一个洗牌和发牌模拟程序。出于教学出于教学出于教学出于教学的考虑，该程序未采用优化的洗牌和发牌算法的考虑，该程序未采用优化的洗牌和发牌算法的考虑，该程序未采用优化的洗牌和发牌算法的考虑，该程序未采用优化的洗牌和发牌算法uu 下面用自顶向下逐步求精的方法来开发这个程序下面用自顶向下逐步求精的方法来开发这个程序下面用自顶向下逐步求精的方法来开发这个程序下面用自顶向下逐步求精的方法来开发这个程序 红

209、心红心红心红心 0 0方块方块方块方块 1 1草花草花草花草花 2 2黑心黑心黑心黑心 3 3AceAceDeuceDeuceThreeThreeFourFourFiveFiveSix Six SevenSevenEightEightNineNineTenTenJackJackQueenQueenKing King 0 01 12 23 34 45 56 67 78 89 9101011111212代表草花代表草花代表草花代表草花“K”“K”2 212 12 草花草花草花草花KingKing图图图图 7. 22 7. 22 表示一副牌的二维数组表示一副牌的二维数组表示一副牌的二维数组表示一副牌

210、的二维数组实例研究实例研究uu 我们用我们用我们用我们用413 413 413 413 的二维数组的二维数组的二维数组的二维数组deck deck deck deck 表示一副牌见图表示一副牌见图表示一副牌见图表示一副牌见图7.227.227.227.22。行与花色对应行与花色对应行与花色对应行与花色对应: : : :第第第第0 0 0 0行代表红心、第行代表红心、第行代表红心、第行代表红心、第1 1 1 1行代表方块、第行代表方块、第行代表方块、第行代表方块、第2 2 2 2行代表行代表行代表行代表草花、第草花、第草花、第草花、第3 3 3 3行代表黑心。列代表牌的面值：第行代表黑心。列代表

211、牌的面值：第行代表黑心。列代表牌的面值：第行代表黑心。列代表牌的面值：第0 0 0 0列到第列到第列到第列到第9 9 9 9列对应列对应列对应列对应于于于于“A“A“A“A到到到到“9“9“9“9 ，第，第，第，第10101010列到第列到第列到第列到第12121212列对应于列对应于列对应于列对应于“J“J“J“J 、“Q“Q“Q“Q和和和和“K“K“K“K 。字符串数组。字符串数组。字符串数组。字符串数组suit suit suit suit 代表四种花色，字符串数组代表四种花色，字符串数组代表四种花色，字符串数组代表四种花色，字符串数组face face face face 代表代表代表

212、代表13131313张牌的面值张牌的面值张牌的面值张牌的面值uu 洗牌的模拟步骤如下。首先，把数组洗牌的模拟步骤如下。首先，把数组洗牌的模拟步骤如下。首先，把数组洗牌的模拟步骤如下。首先，把数组deck deck deck deck 清为清为清为清为0 0 0 0 ；然后，；然后，；然后，；然后，随机地从随机地从随机地从随机地从0 0 0 03 3 3 3 中选择一行中选择一行中选择一行中选择一行rowrowrowrow，从，从，从，从0 0 0 012121212列中选择一列列中选择一列列中选择一列列中选择一列columncolumncolumncolumn。把数。把数。把数。把数1 1 1

213、 1 插入到数组元素插入到数组元素插入到数组元素插入到数组元素deckrowcolumn deckrowcolumn deckrowcolumn deckrowcolumn 中表中表中表中表示这张牌将是从洗好的牌中发出的第一张牌。继续这个过程，示这张牌将是从洗好的牌中发出的第一张牌。继续这个过程，示这张牌将是从洗好的牌中发出的第一张牌。继续这个过程，示这张牌将是从洗好的牌中发出的第一张牌。继续这个过程，把数把数把数把数2 2 2 2、3 3 3 3、52 52 52 52 随机地插入到数组中表示从洗好的牌中发随机地插入到数组中表示从洗好的牌中发随机地插入到数组中表示从洗好的牌中发随机地插入到数

214、组中表示从洗好的牌中发出的第出的第出的第出的第2 2 2 2、第、第、第、第3 3 3 3、第、第、第、第52 52 52 52 张牌。在把发牌序号插入到数组张牌。在把发牌序号插入到数组张牌。在把发牌序号插入到数组张牌。在把发牌序号插入到数组deck deck deck deck 的过程中，一张牌被选择两次是可能的，即选中它时，的过程中，一张牌被选择两次是可能的，即选中它时，的过程中，一张牌被选择两次是可能的，即选中它时，的过程中，一张牌被选择两次是可能的，即选中它时，deckrowcolumn deckrowcolumn deckrowcolumn deckrowcolumn 非非非非0 0

215、 0 0 ；这种选择被忽略，而是反复地随；这种选择被忽略，而是反复地随；这种选择被忽略，而是反复地随；这种选择被忽略，而是反复地随机选择其它的机选择其它的机选择其它的机选择其它的row row row row 和和和和columncolumncolumncolumn，直到发现没有被选中过的牌为，直到发现没有被选中过的牌为，直到发现没有被选中过的牌为，直到发现没有被选中过的牌为止。牌的序号止。牌的序号止。牌的序号止。牌的序号1 1 1 1到到到到52525252最终会分给数组最终会分给数组最终会分给数组最终会分给数组deck deck deck deck 中的中的中的中的52525252张牌。这

216、时，张牌。这时，张牌。这时，张牌。这时，这副牌就算完全洗好了这副牌就算完全洗好了这副牌就算完全洗好了这副牌就算完全洗好了实例研究实例研究uu 如果反复随机选中已经洗好的牌，洗牌算法可能会执行如果反复随机选中已经洗好的牌，洗牌算法可能会执行如果反复随机选中已经洗好的牌，洗牌算法可能会执行如果反复随机选中已经洗好的牌，洗牌算法可能会执行无数次。这种现象称为无数次。这种现象称为无数次。这种现象称为无数次。这种现象称为“无限延迟无限延迟无限延迟无限延迟 可通过优化算法解可通过优化算法解可通过优化算法解可通过优化算法解决决决决“无限延迟问题无限延迟问题无限延迟问题无限延迟问题uu 以顺乎自然的方式制定的

217、算法有时存在诸如无限延迟等以顺乎自然的方式制定的算法有时存在诸如无限延迟等以顺乎自然的方式制定的算法有时存在诸如无限延迟等以顺乎自然的方式制定的算法有时存在诸如无限延迟等等的微妙的性能问题。应选择不存在无限延迟现象的算法等的微妙的性能问题。应选择不存在无限延迟现象的算法等的微妙的性能问题。应选择不存在无限延迟现象的算法等的微妙的性能问题。应选择不存在无限延迟现象的算法uu 要发第一张牌就从数组中查找等于要发第一张牌就从数组中查找等于要发第一张牌就从数组中查找等于要发第一张牌就从数组中查找等于1 1 1 1的数组元素的数组元素的数组元素的数组元素deckrowcolumn deckrowcolu

218、mn deckrowcolumn deckrowcolumn 。这是用嵌套的。这是用嵌套的。这是用嵌套的。这是用嵌套的for for for for 循环完成的，循环完成的，循环完成的，循环完成的，for for for for 循环中的变量循环中的变量循环中的变量循环中的变量row row row row 从从从从0 0 0 0变化到变化到变化到变化到3 3 3 3、column column column column 从从从从0 0 0 0 变化到变化到变化到变化到12121212。怎。怎。怎。怎样表示发出的每一张牌呢？因为数组样表示发出的每一张牌呢？因为数组样表示发出的每一张牌呢？因为

219、数组样表示发出的每一张牌呢？因为数组suit suit suit suit 已经预载入了四已经预载入了四已经预载入了四已经预载入了四种花色，种花色，种花色，种花色， 所以通过打印字符串所以通过打印字符串所以通过打印字符串所以通过打印字符串suitrowsuitrowsuitrowsuitrow可获得花色。同可获得花色。同可获得花色。同可获得花色。同样，打印字符串样，打印字符串样，打印字符串样，打印字符串facecolumnfacecolumnfacecolumnfacecolumn可获得牌的面值。我们还打可获得牌的面值。我们还打可获得牌的面值。我们还打可获得牌的面值。我们还打印出字符串印出字符

220、串印出字符串印出字符串“of“of“of“of 。以正确的顺序打印这些信息可以打印。以正确的顺序打印这些信息可以打印。以正确的顺序打印这些信息可以打印。以正确的顺序打印这些信息可以打印出每一张牌，如打印出出每一张牌，如打印出出每一张牌，如打印出出每一张牌，如打印出“King of Clubs“King of Clubs“King of Clubs“King of Clubs 、“Ace of “Ace of “Ace of “Ace of DiamondsDiamondsDiamondsDiamondsuu 下面用自顶向下逐步求精的方法描述洗牌和发牌的算法下面用自顶向下逐步求精的方法描述洗牌和

221、发牌的算法下面用自顶向下逐步求精的方法描述洗牌和发牌的算法下面用自顶向下逐步求精的方法描述洗牌和发牌的算法实例研究实例研究uu 算法的顶层是简单的，即算法的顶层是简单的，即算法的顶层是简单的，即算法的顶层是简单的，即uu Shuffle and deal 52 cards Shuffle and deal 52 cards Shuffle and deal 52 cards Shuffle and deal 52 cardsuu 第一次求精得出的结果为：第一次求精得出的结果为：第一次求精得出的结果为：第一次求精得出的结果为：uu Initialize the suit array Initia

222、lize the suit array Initialize the suit array Initialize the suit arrayuu Initialize the face array Initialize the face array Initialize the face array Initialize the face arrayuu Initialize the deck array Initialize the deck array Initialize the deck array Initialize the deck arrayuu Shuffle the de

223、ck Shuffle the deck Shuffle the deck Shuffle the deck洗牌洗牌洗牌洗牌uu Deal 52 cards Deal 52 cards Deal 52 cards Deal 52 cards发牌发牌发牌发牌uu “ “ “ “洗牌过程求精的结果为：洗牌过程求精的结果为：洗牌过程求精的结果为：洗牌过程求精的结果为：uu For each of the 52 cards For each of the 52 cards For each of the 52 cards For each of the 52 cardsuu Place card num

224、ber in randomly Place card number in randomly Place card number in randomly Place card number in randomly selected selected selected selected uu unoccupied slot of deck unoccupied slot of deck unoccupied slot of deck unoccupied slot of deckuu 把发牌序号插入到随机选出来的未选把发牌序号插入到随机选出来的未选把发牌序号插入到随机选出来的未选把发牌序号插入到随

225、机选出来的未选中过的牌中中过的牌中中过的牌中中过的牌中实例研究实例研究uu “ “ “ “发牌过程的求精结果为：发牌过程的求精结果为：发牌过程的求精结果为：发牌过程的求精结果为：uu For each of the 52 cards For each of the 52 cards For each of the 52 cards For each of the 52 cardsuu Find card number in deck array and Find card number in deck array and Find card number in deck array and F

226、ind card number in deck array and print face and suit of cardprint face and suit of cardprint face and suit of cardprint face and suit of carduu 在数组在数组在数组在数组deckdeckdeckdeck中查找发牌序号并打印出该张中查找发牌序号并打印出该张中查找发牌序号并打印出该张中查找发牌序号并打印出该张牌的面值和花色牌的面值和花色牌的面值和花色牌的面值和花色uu把上述两个求精过程合并起来就得到第二步求精的结果：把上述两个求精过程合并起来就得到第二步求

227、精的结果：把上述两个求精过程合并起来就得到第二步求精的结果：把上述两个求精过程合并起来就得到第二步求精的结果：uu Initialize the suit array Initialize the suit array Initialize the suit array Initialize the suit arrayuu Initialize the face array Initialize the face array Initialize the face array Initialize the face arrayuu Initialize the deck array Init

228、ialize the deck array Initialize the deck array Initialize the deck arrayuu For each of the 52 cards For each of the 52 cards For each of the 52 cards For each of the 52 cardsuu Place card number in randomly selected Place card number in randomly selected Place card number in randomly selected Place

229、 card number in randomly selected unoccupied slot of deckunoccupied slot of deckunoccupied slot of deckunoccupied slot of deckuu For each of the 52 cards For each of the 52 cards For each of the 52 cards For each of the 52 cardsuu Find card number in deck array and print Find card number in deck arr

230、ay and print Find card number in deck array and print Find card number in deck array and print face and suit of cardface and suit of cardface and suit of cardface and suit of card实例研究实例研究uu 对对对对“把发牌序号插入到随机选出来的未选中过的牌中继把发牌序号插入到随机选出来的未选中过的牌中继把发牌序号插入到随机选出来的未选中过的牌中继把发牌序号插入到随机选出来的未选中过的牌中继续求精得续求精得续求精得续求精得u

231、u Choose slot of deck randomly Choose slot of deck randomly Choose slot of deck randomly Choose slot of deck randomly随机地选出一张随机地选出一张随机地选出一张随机地选出一张牌牌牌牌uu While chosen slot of deck has While chosen slot of deck has While chosen slot of deck has While chosen slot of deck has previously chosenpreviously

232、chosenpreviously chosenpreviously chosenuu 选中的牌曾经被选中过选中的牌曾经被选中过选中的牌曾经被选中过选中的牌曾经被选中过uu Choose slot of deck randomly Choose slot of deck randomly Choose slot of deck randomly Choose slot of deck randomly随随随随机地选出一张牌机地选出一张牌机地选出一张牌机地选出一张牌uu Place card number in chosen slot deck Place card number in chose

233、n slot deck Place card number in chosen slot deck Place card number in chosen slot deckuu 为选中的牌设置发牌序号为选中的牌设置发牌序号为选中的牌设置发牌序号为选中的牌设置发牌序号uu 对对对对“在数组在数组在数组在数组deckdeckdeckdeck中查找发牌序号并打印出该张牌的面值和中查找发牌序号并打印出该张牌的面值和中查找发牌序号并打印出该张牌的面值和中查找发牌序号并打印出该张牌的面值和花色继续求精得到：花色继续求精得到：花色继续求精得到：花色继续求精得到：uu For each slot of th

234、e deck array For each slot of the deck array For each slot of the deck array For each slot of the deck arrayuu if slot contains card number if slot contains card number if slot contains card number if slot contains card numberuu 假设这张牌包含该发牌序号假设这张牌包含该发牌序号假设这张牌包含该发牌序号假设这张牌包含该发牌序号 uu Print the face and

235、the suit of the Print the face and the suit of the Print the face and the suit of the Print the face and the suit of the cardcardcardcarduu 打印这张牌的面值和花色打印这张牌的面值和花色打印这张牌的面值和花色打印这张牌的面值和花色实例研究实例研究uu 把上述两步求精过程合并到总的算法中就得到了第三步求把上述两步求精过程合并到总的算法中就得到了第三步求把上述两步求精过程合并到总的算法中就得到了第三步求把上述两步求精过程合并到总的算法中就得到了第三步求精结果精结

236、果精结果精结果 ：uu Initialize the suit array Initialize the suit array Initialize the suit array Initialize the suit arrayuu Initialize the face array Initialize the face array Initialize the face array Initialize the face arrayuu Initialize the deck array Initialize the deck array Initialize the deck arra

237、y Initialize the deck arrayuu For each of the 52 cards For each of the 52 cards For each of the 52 cards For each of the 52 cardsuu Choose slot of deck randomly Choose slot of deck randomly Choose slot of deck randomly Choose slot of deck randomlyuu While chosen slot of deck has While chosen slot of

238、 deck has While chosen slot of deck has While chosen slot of deck has previously chosenpreviously chosenpreviously chosenpreviously chosenuu Choose slot of deck Choose slot of deck Choose slot of deck Choose slot of deck randomlyrandomlyrandomlyrandomly随机地选出一张牌随机地选出一张牌随机地选出一张牌随机地选出一张牌uu Place card n

239、umber in chosen slot Place card number in chosen slot Place card number in chosen slot Place card number in chosen slot deckdeckdeckdeckuu For each of the 52 cards For each of the 52 cards For each of the 52 cards For each of the 52 cardsuu For each slot of the deck array For each slot of the deck a

240、rray For each slot of the deck array For each slot of the deck arrayuu if slot contains card number if slot contains card number if slot contains card number if slot contains card numberuu Print the face and the Print the face and the Print the face and the Print the face and the suit of the cardsui

241、t of the cardsuit of the cardsuit of the card实例研究实例研究uu 上面完成了求精的过程。注意，如果把洗牌和发牌的算法上面完成了求精的过程。注意，如果把洗牌和发牌的算法上面完成了求精的过程。注意，如果把洗牌和发牌的算法上面完成了求精的过程。注意，如果把洗牌和发牌的算法合并起来，能够在洗牌的同时发牌，程序的效率会更高合并起来，能够在洗牌的同时发牌，程序的效率会更高合并起来，能够在洗牌的同时发牌，程序的效率会更高合并起来，能够在洗牌的同时发牌，程序的效率会更高uu 注意函数注意函数注意函数注意函数printf printf printf printf 中

242、用来打印字符串的转换说明符中用来打印字符串的转换说明符中用来打印字符串的转换说明符中用来打印字符串的转换说明符%s %s %s %s 的用的用的用的用法，相应的参数必须是指向法，相应的参数必须是指向法，相应的参数必须是指向法，相应的参数必须是指向char char char char 类型或类型或类型或类型或char char char char 类型数组类型数组类型数组类型数组的指针。的指针。的指针。的指针。uu 在函数在函数在函数在函数deal deal deal deal 中，中，中，中，“%5s of %-8s“%5s of %-8s“%5s of %-8s“%5s of %-8s 先

243、打印先打印先打印先打印5 5 5 5个字符域宽个字符域宽个字符域宽个字符域宽的右对齐字符串，然后打印的右对齐字符串，然后打印的右对齐字符串，然后打印的右对齐字符串，然后打印“of“of“of“of和和和和8 8 8 8个字符域宽的左对齐字个字符域宽的左对齐字个字符域宽的左对齐字个字符域宽的左对齐字符串；符串；符串；符串；“%-8s“%-8s“%-8s“%-8s中的减号表示字符串在中的减号表示字符串在中的减号表示字符串在中的减号表示字符串在8 8 8 8个字符的域宽内左对个字符的域宽内左对个字符的域宽内左对个字符的域宽内左对齐齐齐齐uu 发牌算法有一点缺乏之处。在查找与发牌序号匹配的牌时，发牌算

244、法有一点缺乏之处。在查找与发牌序号匹配的牌时，发牌算法有一点缺乏之处。在查找与发牌序号匹配的牌时，发牌算法有一点缺乏之处。在查找与发牌序号匹配的牌时，即使在第一轮找到这张牌，内嵌的两个即使在第一轮找到这张牌，内嵌的两个即使在第一轮找到这张牌，内嵌的两个即使在第一轮找到这张牌，内嵌的两个for for for for 循环也会继续在循环也会继续在循环也会继续在循环也会继续在deck deck deck deck 中查找剩下的牌中查找剩下的牌中查找剩下的牌中查找剩下的牌 /* /* 发牌程序发牌程序发牌程序发牌程序 */ */ # include # include # include # inc

245、lude # include # include void shuffle void shuffle（int 13int 13）; ; void deal void deal（const int 13, const char * , const char * const int 13, const char * , const char * ）; ; main main（）（）（）（） char *suit4 = ”Hearts”,”Diamonds”,”Clubs”,”Spades”; char *suit4 = ”Hearts”,”Diamonds”,”Clubs”,”Spades”; c

246、har *face13 = ”Ace”,”Deuce”,”Three”,”Four”,”Five”,”Six”, char *face13 = ”Ace”,”Deuce”,”Three”,”Four”,”Five”,”Six”, ”Seven”,”Eight”,”Nine”,”Ten”,”Jack”,”Queen”,”King”; ”Seven”,”Eight”,”Nine”,”Ten”,”Jack”,”Queen”,”King”; int deck413 = 0; int deck413 = 0; srand srand（timetime（NULLNULL）; ; shuffle shuff

247、le（deckdeck）; /* ; /* 洗牌洗牌洗牌洗牌*/*/ deal deal（deck, face, suitdeck, face, suit）; /* ; /* 发牌发牌发牌发牌 */ */ return 0; return 0; void shuffle void shuffle（int wDeck 13int wDeck 13） /* /* 洗牌函数的函数定义洗牌函数的函数定义洗牌函数的函数定义洗牌函数的函数定义 */ */ int card, row, column; int card, row, column; for for（card = 1; card = 52; c

248、ard+card = 1; card = 52; card+） row = rand row = rand（）（）（）（）% 4; /* % 4; /* 取随机数取随机数取随机数取随机数0 0 3 */3 */ column = rand column = rand（）（）（）（）% 13; /* % 13; /* 取随机数取随机数取随机数取随机数 0 0 12 */ 12 */ while while（wDeckrowcolumn != 0wDeckrowcolumn != 0） row = rand row = rand（）（）（）（）% 4; % 4; column = rand col

249、umn = rand（）（）（）（）% 13;% 13; wDeckrowcolumn = card; wDeckrowcolumn = card; /* /* 发牌函数的函数定义发牌函数的函数定义发牌函数的函数定义发牌函数的函数定义 */ */ void deal void deal（const int wDeck 13, const char *wFace , const int wDeck 13, const char *wFace , const char *wSuit const char *wSuit ） int card, row, column; int card, row,

250、column; for for（card = 1; card = 52; card+card = 1; card = 52; card+） for for（row = 0; row = 3; row+row = 0; row = 3; row+） for for（column = 0; column = 12; column+column = 0; column workcount + 1 workcount workcount + 1 workcount workcount + 1 workcount workcount + 1uu那么那么那么那么if if if if 的条件为的条件为的条

251、件为的条件为“真真真真 ，执行两个数组元素的交换，执行两个数组元素的交换，执行两个数组元素的交换，执行两个数组元素的交换uu当用户选择当用户选择当用户选择当用户选择2 2 2 2时，数组将按降序排序，假设时，数组将按降序排序，假设时，数组将按降序排序，假设时，数组将按降序排序，假设uu workcount workcount + 1 workcount workcount + 1 workcount workcount + 1 workcount workcount + 1uu那么那么那么那么if if if if 的条件为的条件为的条件为的条件为“真真真真 ，执行两个数组元素的交换，执行两个

252、数组元素的交换，执行两个数组元素的交换，执行两个数组元素的交换 /* /* 使用函数指针的多用途排序程序使用函数指针的多用途排序程序使用函数指针的多用途排序程序使用函数指针的多用途排序程序 */ */ # include # include # define SIZE 10 # define SIZE 10 void bubble void bubble（int *, const int, intint *, const int, int（* *）（）（）（）（int, intint, int）; ; int ascending int ascending（const int, const i

253、ntconst int, const int）; ; int descending int descending （const int, const intconst int, const int）; ; main main（）（）（）（） int aSIZE = 2, 6, 4, 8, 10, 12, 89, 68, 45, 37 ; int aSIZE = 2, 6, 4, 8, 10, 12, 89, 68, 45, 37 ; int counter, order; int counter, order; printf printf（”Enter 1 to sort in ascendi

254、ng order, n”Enter 1 to sort in ascending order, n”）; ; printf printf（”Enter 2 to sort in descending order: n” ”Enter 2 to sort in descending order: n” ）; ; scanf scanf（”%d”, &order”%d”, &order）; ; printf printf（”nData items in original order n”nData items in original order n”）; ; for for（counter = 0

255、; counter = SIZE 1; counter+counter = 0; counter = SIZE 1; counter+） printf printf（”%4d”, acounter”%4d”, acounter）; ; if if（order = 1order = 1） bubble bubble（a, SIZE, ascendinga, SIZE, ascending）; ; printf printf（”nData items in ascending order n”nData items in ascending order n”）; ; else else bubbl

256、e bubble（a, SIZE, descendinga, SIZE, descending）; ; printf printf（”nData items in descending order n”nData items in descending order n”）; ; for for（counter = 0; counter = SIZE 1; counter+counter = 0; counter = SIZE 1; counter+） printf printf（” %4d”, acounter” %4d”, acounter）; ; printf printf（”n”n”）;

257、 ; return 0; return 0; void bubble void bubble（int *work, const int size, intint *work, const int size, int（*compare*compare）（）（）（）（int, intint, int） int pass, count; int pass, count; void swap void swap（int *, int *int *, int *）; ; for for（pass = 1; pass = size 1; pass+pass = 1; pass = size 1; pass

258、+） for for（count = 0; count = size 2; count+count = 0; count = size 2; count+） if if（*compare*compare）（）（）（）（workcount, workcount + 1 workcount, workcount + 1 ） swap swap（&workcount, &workcount + 1&workcount, &workcount + 1） void swap void swap（int *element1Ptr, int *element2Ptrint *element1Ptr, int

259、 *element2Ptr） int temp; int temp; temp = *element1Ptr; temp = *element1Ptr; *element1Ptr = *element2Ptr; *element1Ptr = *element2Ptr; *element2Ptr = temp; *element2Ptr = temp; int ascending int ascending（const int a , const int bconst int a , const int b） return b a; return b a; return b a; 图图图图 7.

260、 25 7. 25 时用函数指针的多用途排序函数时用函数指针的多用途排序函数时用函数指针的多用途排序函数时用函数指针的多用途排序函数指向函数的指针指向函数的指针Enter 1 to sort in ascending order,Enter 1 to sort in ascending order,Enter 2 to sort in descending order: Enter 2 to sort in descending order: 1 1Data items in original orderData items in original order 2 6 4 8 10 12 89

261、 68 45 37 2 6 4 8 10 12 89 68 45 37Data items in ascending orderData items in ascending order 2 4 6 8 10 12 37 45 68 89 2 4 6 8 10 12 37 45 68 89Enter 1 to sort in ascending order,Enter 1 to sort in ascending order,Enter 2 to sort in descending order: Enter 2 to sort in descending order: 2 2Data ite

262、ms in original orderData items in original order 2 6 4 8 10 12 89 68 45 37 2 6 4 8 10 12 89 68 45 37Data items in ascending orderData items in ascending order 2 4 6 8 10 12 37 45 68 89 2 4 6 8 10 12 37 45 68 89图图图图 7. 26 7. 26 图图图图7.25 7.25 中的泡沫排序法程序的输出中的泡沫排序法程序的输出中的泡沫排序法程序的输出中的泡沫排序法程序的输出指向函数的指针指向函数

263、的指针指向函数的指针指向函数的指针uu 函数指针常用在所谓的菜单驱动系统中。程序提示用户从函数指针常用在所谓的菜单驱动系统中。程序提示用户从函数指针常用在所谓的菜单驱动系统中。程序提示用户从函数指针常用在所谓的菜单驱动系统中。程序提示用户从菜单中选择一个选项，每一个选项都有一个不同的函数来完成菜单中选择一个选项，每一个选项都有一个不同的函数来完成菜单中选择一个选项，每一个选项都有一个不同的函数来完成菜单中选择一个选项，每一个选项都有一个不同的函数来完成其功能。指向每一个函数的指针存储在一个指向函数的指针数其功能。指向每一个函数的指针存储在一个指向函数的指针数其功能。指向每一个函数的指针存储在一

264、个指向函数的指针数其功能。指向每一个函数的指针存储在一个指向函数的指针数组中。用户的选择被作为数组下标以选择函数指针组中。用户的选择被作为数组下标以选择函数指针组中。用户的选择被作为数组下标以选择函数指针组中。用户的选择被作为数组下标以选择函数指针uu。所定义的函数有。所定义的函数有。所定义的函数有。所定义的函数有function1function1function1function1、function2 function2 function2 function2 和和和和function3function3function3function3，它，它，它，它们都用一个整数作为参数并且没有返回

265、值。指向这三个函数的们都用一个整数作为参数并且没有返回值。指向这三个函数的们都用一个整数作为参数并且没有返回值。指向这三个函数的们都用一个整数作为参数并且没有返回值。指向这三个函数的指针存储在数组指针存储在数组指针存储在数组指针存储在数组f f f f 中，该数组被声明为：中，该数组被声明为：中，该数组被声明为：中，该数组被声明为：uu void void void void *f 3*f 3*f 3*f 3intintintint= function1= function1= function1= function1，function2 function2 function2 functio

266、n2 ， function3;function3;function3;function3;uu该数组声明的读法为：该数组声明的读法为：该数组声明的读法为：该数组声明的读法为：f f f f 是包含三个指向函数的指针的数组，是包含三个指向函数的指针的数组，是包含三个指向函数的指针的数组，是包含三个指向函数的指针的数组，函数带有一个函数带有一个函数带有一个函数带有一个int int int int 类型的参数，返回类型为类型的参数，返回类型为类型的参数，返回类型为类型的参数，返回类型为voidvoidvoidvoid。该数组用三。该数组用三。该数组用三。该数组用三个函数名初始化。当用户键入个函数名

267、初始化。当用户键入个函数名初始化。当用户键入个函数名初始化。当用户键入0 0 0 0到到到到2 2 2 2之间的值时，该值就用作指之间的值时，该值就用作指之间的值时，该值就用作指之间的值时，该值就用作指向函数的指针数组的下标。函数的调用方式如下：向函数的指针数组的下标。函数的调用方式如下：向函数的指针数组的下标。函数的调用方式如下：向函数的指针数组的下标。函数的调用方式如下：uu *f choice*f choice*f choice*f choicechoicechoicechoicechoice; ; ; ;uu其中，其中，其中，其中，f choicef choicef choicef c

268、hoice选中相应的指针，复引用该指针调用相应选中相应的指针，复引用该指针调用相应选中相应的指针，复引用该指针调用相应选中相应的指针，复引用该指针调用相应函数，并以函数，并以函数，并以函数，并以choice choice choice choice 作为实参作为实参作为实参作为实参 /* /* 演示指向函数的指针数组演示指向函数的指针数组演示指向函数的指针数组演示指向函数的指针数组 */ */ # include # include void function1 void function1（intint）; ; void function2 void function2（intint）; ;

269、 void function3 void function3（intint）; ; main main（）（）（）（） void void （*f 3*f 3）（）（）（）（intint）= function1, function2, function3 ;= function1, function2, function3 ; int choice; int choice; printf printf（”Enter a number between 0 and 2, 3 to end: ”Enter a number between 0 and 2, 3 to end: ”）; ; scanf

270、 scanf（” %d ”, &choice” %d ”, &choice）; ; while while（choice = 0 & choice = 0 & choice 3） （*f choice*f choice）（）（）（）（choicechoice）; ; printf printf（”Enter a number between 0 and 2, 3 to end: ”Enter a number between 0 and 2, 3 to end: ”）; ; scanf scanf（” %d ”, &choice” %d ”, &choice）; ; printf printf

271、（”You entered 3 to end n”You entered 3 to end n”）; ; return 0; return 0; void function1 void function1（int aint a） printf printf（”You entered %d so function1 was called nn”, a”You entered %d so function1 was called nn”, a）; ; void function2 void function2（int aint a） printf printf（”You entered %d so

272、 function2 was called nn”, a”You entered %d so function2 was called nn”, a）; ; void function3 void function3（int aint a） printf printf（”You entered %d so function3 was called nn”, a”You entered %d so function3 was called nn”, a）; ; 输出结果：输出结果：输出结果：输出结果： Enter a number between 0 and 2, 3 to end: Enter

273、 a number between 0 and 2, 3 to end: 0 0 You entered 0 so function1 was called You entered 0 so function1 was called Enter a number between 0 and 2, 3 to end: Enter a number between 0 and 2, 3 to end: 1 1 You entered 1 so function2 was called You entered 1 so function2 was called Enter a number betw

274、een 0 and 2, 3 to end: Enter a number between 0 and 2, 3 to end: 2 2 You entered 2 so function1 You entered 2 so function1、3 was called3 was called Enter a number between 0 and 2, 3 to end: Enter a number between 0 and 2, 3 to end: 3 3 You entered 3 to end You entered 3 to end图图图图 7. 27 7. 27 演示指向函数的指针数组演示指向函数的指针数组演示指向函数的指针数组演示指向函数的指针数组指向函数的指针指向函数的指针