第5章 指针 5.1 指针与指针变量 5.2 指针运算符 5.3 指针与一维数组 5.4 指向指针的指针 5.5 指针与结构

Presentation on theme: "第5章 指针 5.1 指针与指针变量 5.2 指针运算符 5.3 指针与一维数组 5.4 指向指针的指针 5.5 指针与结构"— Presentation transcript:

1 第5章 指针 5.1 指针与指针变量 5.2 指针运算符 5.3 指针与一维数组 5.4 指向指针的指针 5.5 指针与结构 5.6 指向共用体和枚举型的指针 5.7 指针小结

2 第5章 指针 指针是Ｃ语言的精华，是Ｃ语言最重要的内容之一，也是最难掌握的部分。在程序中可以使用指针来处理数据、变量、数组、字符串、函数、结构体、文件及动态分配内存等。正确地使用指针，可以使程序精简、灵活、高效。指针的概念比较复杂，如果误用指针，程序运行将出现意想不到的错误，这是初学指针应注意的问题。因此指针是Ｃ语言的重点和难点。 本章讲述的主要内容包括:变量的地址和变量的值、指针的基本概念；指针变量的定义、赋值；指针基本运算 (包括取地址运算，存取指针所指的内容，移动指针，指针相减等)；指针与一维数组的关系，数组名与地址的关系，使用指针存取数组元素；使用指针处理字符串；二维数组与指针的关系、二维数组与数组指针的关系；指向指针的指针的概念；使用指针变量存取结构体变量成员数据、指针与共用体变量的关系以及指针与枚举型变量的关系。建议本章授课8学时，上机6学时，自学10学时 返回目录

3 5.1 指针变量与数组 教学内容： 5.1.1 指针与指针变量 5.1.2 指针变量的定义 5.1.3 指针变量的赋值 返回目录

4 5.1.1 指针的基本概念 在第二章的2.1.3节中讲述了内存地址的概念，计算机内存是由一片连续的存储单元组成，操作系统给每个单元一个编号，这个编号称为内存单元的地址（简称地址），每个存储单元占内存一个字节。定义一个变量，不仅规定了该变量的类型、名称，而且还在内存中为该变量分配了一块（连续的）存储单元，我们把这块存储单元的首地址称为该变量的指针（也称为变量的地址）。例如定义变量float f; 假设系统为变量f分配到地址为1500、1501、1502、1503的4个连续存储单元，则地址1500就称为变量f的指针（也称变量f的地址是1500）。因此变量的地址就是变量的指针。变量的值和变量的地址是不同的概念，变量的值是该变量在内存单元中的数据。 返回目录

5 5.1.1 指针的基本概念 下面用一个卡片管理系统来说明如何存取变量的值。
一个卡片系统由许多张卡片组成。要快速存取每张卡片上的数据，需要给每张卡片编号（标明每张卡片的地址）；为了方便存取卡片上的数据，便于人们记忆，还需要给每张卡片取一个名字，并把名字与编号一一对应起来。这样卡片有了编号和名字，就能高效、方便地管理整个卡片系统了。如图5.1 所示，可以通过卡片的名字存取卡片上的数据，例如只要指出卡片的名字f，就可以取出与之相对应的编号1500处的数据 。有一类很特殊的卡片，它的内容专门存放其它卡片的编号（地址）。如图5.1中，卡片p上的数据是1500，是卡片f的编号。通过卡片p也可以间接地存取卡片f的数据，先取到卡片p上的数据1500，再到1500编号处存取数据。 返回目录

6 5.1.1 指针的基本概念 变量值的存取与卡片数据的存取极为相似。每个变量都有名字和地址。程序员在编写程序时，使用变量名来存取该变量的值。与之相对应，计算机系统使用变量的地址来存取该变量的值。这是因为程序经过编译系统编译后，每个变量都分配了相应的存储单元，每个变量名都变成了与之相对应的地址。假设float类型的变量f的地址是1500，若执行语句 f= ; 计算机系统就把 存入到地址为1500开始的四个存储单元中（单精度实型占内存４字节）；若执行语句printf("%f\n",f);则从地址1500开始的四个存储单元中取出数据 输出到屏幕。对于计算机而言，变量名都被翻译成了地址，系统按变量地址存取变量的值，这称为“直接存取”方式 返回目录

7 5.1.1 指针的基本概念 有一类特殊的变量，它的内容专门存放其它变量的地址，这样的变量称为指针变量。如图5.2中指针变量p的值为1500，是变量f的地址。通过变量p可以间接地存取变量f的数据，先取出p的值“地址1500”，再到“地址1500”处存取数据，这种通过变量p间接得到变量f的地址，然后再存取变量f的值的方式称为“间接存取”方式，见图5.2。 返回目录

8 5.1.1 指针的基本概念 用来存放指针（地址)的变量就称作指针变量。上述变量p就是一个指针变量。若把变量f的地址赋值给指针变量p，则称指针变量p指向变量f（见图5.3）。 返回目录

9 5.1.2 指针变量的定义 定义指针变量的一般形式为： 类型名 *标识符；
类型名 *标识符； 其中“标识符”是指针变量名，标识符前加“*”号表示该变量是指针变量，用于存放地址，“类型名”表示该指针变量所指向变量的类型。例如： int i, *ip, *jp; /* 定义ip与jp 两个指针变量，它们可以指向int类型的变量*/ float f, *p; /* 定义p为指针变量，它可以指向float类型的变量*/ 若 ip=&i; 则称指针变量ip指向整型变量i，因为把变量i的地址赋值给了ip。赋值语句ip=&f; 是非法的，一个指针变量只能指向类型相同的变量，一个指向整型变量的指针变量不允许指向实型变量 返回目录

10 5.1.3 指针变量的赋值 指针变量可以通过不同的方法获得一个地址值。 １．通过地址运算“&”赋值 地址运算符“&”是单目运算符，运算对象放在地址运算符“&” 的右边，用于求出运算对象的地址。通过地址运算“&”可以把一 个变量的地址赋给指针变量。若有语句 float f, *p; p=&f; 　 执行后把变量f的地址赋值给指针变量p，指针变量p就指向了变量f. ２．指针变量的初始化与动态变量的初值一样，在定义了一个（动 态的）指针变量之后，其初值也是一个不确定的值。可以在定义变 量时给指针变量赋初值，如float f, *p=&f; 则把变量f的地址赋值给 指针变量p，此语句相当于 float f, *p; p=&f;　这两条语句。 返回目录

11 5.1.3 指针变量的赋值 ３．通过其它指针变量赋值 可以通过赋值运算符，把一个指针变量的地址值赋给另一个指针变量，
这样两个指针变量均指向同一地址。例如，有如下程序段: int i, *p1=&i, *p2; p2=p1; 执行后指针变量p1与p2都指向整型变量i。 注意，当把一个指针变量的地址值赋给另一个指针变量时，赋值号两 边指针变量所指的数据类型必须相同。例如： int i, *pi=&i; float *pf; 则语句pf=pi；是非法的，因为pf只能指向实型变量，而不能指向型 变量。 返回目录

12 5.1.3 指针变量的赋值 ４．用NULL给指针变量赋空值 除了给指针变量赋地址值外，还可以给指针变量赋空值，如： p=NULL;
ＮULL是在stdio.h头文件中定义的预定义标识符，因此在使用NULL时，应该在程序中加上文件包含#include "stdio.h"。在stdio.h头文件中NULL被定义成符号常量，与整数０对应。执行以上的赋值语句后，称p为空指针，在Ｃ语言中当指针值为NULL时，指针不指向任何有效数据，因此在程序中为了防止错误地使用指针来存取数据，常常在指针未使用之前，先赋初值为NULL。由于NULL与整数0相对应，所以下面三条语句等价： p=NULL; 或 p=0; 或 p='\0'; 但通常都使用p=NULL；的形式，因为这条语句的可读性好。NULL可以赋值给指向任何类型的指针变量。 返回目录

13 5.1.3 指针变量的赋值 ５．通过调用标准函数赋值 可以调用库函数malloc和calloc在内存中开辟动态存储单元，并把所开 辟的动态存储单元的首地址赋给指针变量，由于这两个函数返回的是 “void*”无类型指针类型，因此将它们的返回值赋值给指针变量时要 进行强制类型转换。 　　（１）malloc函数 调用该函数，在内存的动态存储区中分配一个指定长度 (以字节 为单位)的连续存储空间，如果调用该函数成功，则返回所分配空间 的首地址，如果分配不成功，则返回NULL。调用形式为： malloc(表达式) 返回目录

14 5.1.3 指针变量的赋值 其中表达式的值表示所要分配存储空间的字节数。例如： int *p; p=(int*)malloc(sizeof(10*int)); 执行上述程序段，将在内存的动态存储区中分配izeof(10*int) 即20个字节的连续存储单元块，并把这块连续存储单元的首地址 赋值给指针变量p。其中用了（int*）强制类型转换，将 (void*)类型转换成(int*)类型。 返回目录

15 5.1.3 指针变量的赋值 （２）calloc函数 调用该函数，在内存动态存储区中分配一块连续的存储空间。函数调用 形式为： calloc (n，size) 分配n个长度为size(以字节为单位)的连续空间。如果调用该函数成功， 则返回所分配空间的首地址，如果分配不成功，则返回NULL。 （３）free函数 调用该函数，用来释放由malloc或calloc函数分配的存储空间，调用该函 数不返回任何值。函数调用形式为: free(指针变量) 返回目录

16 5.1.3 指针变量的赋值 其中指针变量应指向调用malloc或calloc时所分配存储区的首 地址。如free(p);在程序设计过程中，若动态分配的空间不再使用 时（如函数调用结束），应及时释放所分配的内存空间。 有关指针变量的赋值，不仅仅是上述５种，指针变量还可以 指向数组、字符串、结构体、函数、文件，本章以下的章节将讲 述前三种概念，在第六章涉及指针与函数，第八章涉及指针与文 件。 返回目录

17 5.2 指针运算符 教学内容： 5.2.1 指针运算符 5.2.2 无类型指针

18 5.2.1 指针运算符 在5.1.1节描述了怎样用指针变量间接存取变量的数据，本节讲述具体实现方法。
为了使用指针变量间接存取变量中的数据，Ｃ语言中提供了指针运算符“*”。指针运算符是单目运算符，运算对象必须放在指针运算符“*”右侧，而且运算对象只能是指针变量或地址，可以用“指针运算符”来存取相应的存储单元中的数据。 例如，有下面的程序段： int i=123，j，*p； 　 p=&i； 则 j=*p；和j=*&i；都将把变量i的值赋给变量j。而*p=456；和*&i=456；都将把 整数456赋给变量i。此处，表达式*p和*&i都代表变量i。运算符 &和*都是单目运算符，它们具有相同的优先级，结合方向为均为 “从右到左”，因此*&i相当于*(&i)，表达式&i求出变量i的地址。 由此得出结论： 返回目录

19 5.2.1 指针运算符 １．表达式 *&i 等价于变量i； ２．当一个指针变量p指向某变量i时（p=&i;），则表达式*p与变量 i等价。
例如： p=&i; printf("%d\n", *p); /*相当于printf("%d\n", i); */ j=(*p)++; /*相当于j=i++;*/ 注意表达式(*p)++中的括号不能省略，如果没有括号，由于“*”与“++”均为单目运算符，优先级相同，结合方向是“从右到左”，因此*p++等价于*(p++)，此时先使用变量i的值，再使p的值改变，这样p就不再指向变量i了。 返回目录

20 5.2.1 指针运算符 指针变量的值是可以改变的，一个指针变量在某一时刻指向变量i在,另一时刻可以指向变量j。例如 int i=1, j=2, *p; p=&i; *p += 100; /* 相当于i+=100; */ p=&j; (*p)--; /* 相当于j--; */ 通过*p方式存取它所指向变量的值是以间接存取的形式进行的，所以比直接存取一个变量要费时间。例如执行上述语句(*p)+=100; 比执行i+=100; 多费时。但由于p是变量，我们可以通过改变它的指向，间接存取不同变量的值，这给程序设计带来灵活性，也使程序代码编写更为简洁、高效。 返回目录

21 5.2.1 指针运算符 取地址运算符“&”与指针运算符“*”作用在一起时，有相互“抵消”的作用。例如若有int i, *p=&i; 则：
相互等价 相互等价 １． *p i *&I 相互等价 2． &*p p 3．&*i 是非法的表达式，因为i不是地址、也不是指针变量。 前面叙述了当指针变量p指向一个变量i时，可以用*p的形式存 取该变量i的数据。际上只要指针变量p指向内存的某一存储单元， 就可用*p 的形式存取该存储单元的数据。 返回目录

22 5.2.1 指针运算符 例如下面的程序段： int *p; p=(int*)malloc(sizeof(int)); *p=789;
上述程序段第二条语句在内存动态存储区分配一块２字节的存储区， 并把其首地址赋值给指针变量p，即p指向这一存储区，第三条语句 把整数789存入这 一存储区。 另外，指针运算符“*”是单目运算， 指针运算符的运算对象必须是指 针变量或地址。而乘 法运算符“*” 是双目运算符，它的运算对象可以是实型数据或整型据。 返回目录

23 5.2.1 指针运算符 [例5.1]由键盘输入一个正整数，求出其最高位数字。用指针变量来完成本题。 main() { long i,*p;
p=&i; printf("请输入一个正整数:"); scanf("%ld", p); /* 本语句等价于scanf("%ld", &i); */ while (*p>=10) *p /= 10; /* 求出该正整数的最高位数字 */ printf("最高位数字是:%ld。\n", *p); } 返回目录

24 5.2.2 无类型指针 ANSI新标准增加了一种无类型指针“void *”。可定义一个指针变量，
例如，有如下程序段： 　　int *p1; char *p2; 　　void *q; /* 定义q为无类型指针变量 */ q=malloc(sizeof(int)); p1=(int*)q; /* 将q的地址赋值给指针变量p1,q与p1指向同一地址*/ *p1=0x4142; /* 对p1所指的内存赋值0x4124(即十进制数16706) */ p2=(char *)q; /* 将q的地址赋值给指针变量p2,q与p2指向同一地址*/ printf("%d, %c,%c\n", *p1, *p2, *(p2+1) ); free(q); 以上程序段运行的结果是: 返回目录

25 5.2.2 无类型指针 从上面的程序段可知，可以用无类型指针q指向内存中的一块存储
的数据。若指向整型类型的指针p1指向q所指的地址时， 则可用 *p1存取整型数据 若指向字符型的指针p2指向q所指的地址时， 则可用*p2存取字符型数据，上述程序段中，0x41（即十进制数 65）是字符‘A’的ASCII码。 同样也可以用强制类型转换，把一个指针的值赋值给一个无类型 指针。 例如： 　　 float f, *p3=&f; void * q; 　　 q=(void *)p3; 则此时q和p3都指向实型变量f。 返回目录

26 5.3 指针与一维数组 教学内容： 5.3.1 指针与一维数组 5.3.2 移动指针及两指针相减运算 5.3.3 指针比较
5.3 指针与一维数组 教学内容： 5.3.1 指针与一维数组 5.3.2 移动指针及两指针相减运算 5.3.3 指针比较 5.3.4 字符串 5.3.5 指针与二维数组

27 5.3.1 指针与一维数组 １．一维数组和数组元素的地址 一个数组的元素在内存中是连续存放的，数组第一个元素的地址称
数组的首地址。C语言中，数组名是该数组的首地址。例如有以下定义语 句： int a[10]，*p； 则语句p=a；和p=&a[0]；是等价的，都表示指针变量p指向a数组的首 地址。数组首地址的值在Ｃ语言中是一个地址常量，是不能改变的。 因此，语句 a=p; 或a++;都是非法的。若数组的首地址是a，且指针变 量p指向该数组的首地址(即p=a;)，则Ｃ语言还规定： 数组的第0个元素a[0]的地址是a(等价于p )； 数组的第1个元素a[1]的地址是a+1(等价于p+1,详见5.3.2的内容 )； 数组的第2个元素a[2]的地址是a+２ (等价于p+２ )； 数组的第i个元素a[i]的地址是a+i 　 (等价于p+i )； 返回目录

28 5.3.1 指针与一维数组 例如，有下述程序段： int a[6]={1, 2, 3, 4, 5, 6}, *p=a; /*p指向整型数组a的首地址*/ double d[6]={1.1, 2.2, 3.3, 4.4, 5.5, 6.6}, *q=d;　/*q指向双精度实型数组 d的首地址*/ 假设数组a的首地址是2000，假设数组d的首地址是3000，则上述两 个数组分配的内存情况如图5.4(a)与图5.4(b)所示，应注意（int）整型 数组每下移一个元素地址加sizeof(int)即２字节，（double）双精度实型 数组每下移一个元素地址加sizeof(double)即8字节。 返回目录

29 5.3.1 指针与一维数组 ２．通过一维数组名所代表的地址存取数组元素
假设已定义一维数组a，由上述可知a+i是元素a[i]的地址，根据指针运算符“*”的运算规则知 *(a+i) 与元素 a[i]等价。例如，下述程序段： int a[ ]={1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; *(a+5)=50; /*相当于a[5]=50 ;*/ scanf("%d", &a[8]); /*相当于scanf("%d", a+8 );*/ printf("%d\n", *(a+5) ); /*相当于printf("%d\n", a[5]) )*/ 返回目录

30 5.3.1 指针与一维数组 ３．通过指针运算符“*”存取数组元素 设有如下程序段： int a[10]，*p； p=a；
即p指向a数组的首地址，由上述可知p+i是元素a[i]的地址，根据 指针运算符“*”的运算规则知 *(p+i) 与元素 a[i]等价。例如，下述 程序段： int a[ ]={1, 2, 3, 4, 5, 6, 7, 8, 9, 10}, *p=a; *(p+5)=50; /*相当于a[5]=50 ;*/ scanf("%d", &a[8]); /*相当于scanf("%d", p+8 );*/ printf("%d\n", *(p+5) ); /*相当于printf("%d\n", a[5]) )*/ 返回目录

31 5.3.1 指针与一维数组 ４．通过带下标的指针变量存取数组元素 Ｃ语言中的下标运算符“[ ]”可以构成表达式，假设p为指针变量，i为
整型表达式，则可以把p[i]看成是表达式，首先按p+i计算地址，然后 再存取此地单元中的值。因此p[i]与*(p+i)等价。例如，下述程序段： int a[ ]={1, 2, 3, 4, 5, 6, 7, 8, 9, 10}, *p=a; p[5]=50; /*相当于a[5]=50 ;*/ scanf("%d", &a[8]); /*相当于scanf("%d", &p[8] );*/ printf("%d\n", p[5] ); /*相当于printf("%d\n", a[5]) )*/ 综上所述，若定义了一维数组a和指针变量p，且p=a; 则有如下等价规 则： 相互等价 相互等价 相互等价 　　 a[i] p[i] *(a+i) *(p+i) 以上假设p所指的数据类型与数组a元素的数据类型一致，i为整型表达式 返回目录

32 5.3.2移动指针及两指针相减运算 １．移动指针 移动指针就是把指针变量加上或减去一个整数、或通过赋值运算，
使指 针变量指向邻近的存储单元。因此，只有当指针变量指向一 片连续的存储单元（通常是数组）时，指针的移动才有意义。若有下述程序段： 类型名 *p, *q; p=p+n; q=q-m; 此处“类型名”是指针变量p，q所指向变量的数据类型，并假定m, n为正整数，则系统将自动计算出： p指针向高地址方向位移的字节数＝sizeof(类型名)*n; q指针向低地址方向位移的字节数＝sizeof(类型名)*m; 指针变量每增1、减 1运算一次所位移的字节数等于其所指的数据 类型的大小，而不是简单地把指针变量的值加１或减１，见[例5.2]。 返回目录

33 5.3.2移动指针及两指针相减运算 ２．两指针相减运算 指向同一块连续存储单元（通常是数组）的两个指针变量可以进
行相减运算。假设指针变量p，q指向同一数组，则p-q的值等于p所 指对象与q所指对象之间的元素个数，若p>q则取正值，p<q取负值 ,见[例5.2]。指针变量除了可以“位移”和“相减”之外，不能作其 它 算术运算。 返回目录

34 5.3.2移动指针及两指针相减运算 [例5.2] 本例说明指针变量“位移”和“相减”的操作。 main()
{int a[6]={1, 2, 3, 4, 5, 6}, *p1=a, *p2; /*p1指向整型数组a的首地址*/ double d[6]={1.1, 2.2, 3.3, 4.4, 5.5, 6.6}, *q1=d, *q2; /*q1指向双 精度实型数组d的首地址*/ p1++; /*p1指向a数组的元素a[1],p1向下移一个元素(２个字节) */ p2=p1+3; /*p2指向a数组的元素a[4]，p2与p1相距３个元素*/ printf(“%d\n”,p1-p2); /*输出-3到屏幕,因为p2与p1相距元素的个数 为3*/ q1++; /*q1指向d数组的元素d[1]，q1向下移一个元素（８个字节)*/ q2=q1+3; /*q2指向d数组的元素d[4]，q2与q1相距３个元素*/ printf(“%d\n”,q2-q1);/*输出3到屏幕,因为q2与q1相距元素的个数为 3*/ printf("%d, %d, %3.1f, %3.1f\n", *p1, *p2, *q1, *q2); } 返回目录

35 5.3.2移动指针及两指针相减运算 上例运行后指针指向情况见图5.5(a) 和图5.5(b)，图中假设数
组a的首地址是2000，假设数组d的首地址是3000。 在[例5.2]中，指针变量p1,p2所指向的数据类型是 整型，这时p1,p2每位移一个元素，将使指针的地址值位移两２字节，设初始时p1的值为2000，则执行语句p1++；后p1的值为2002，见图5.5(a)；而指针变量q1,q2所指向的数据类型是双精度实型，这时q1、q2每位移一个元素，将 使指针的地址值位移８个字节，设初始时q1的值为3000，则执行语句q1++；q2=q1+３；后q2的值为3032， 见图5.5(b) 。 返回目录

36 5.3.3指针比较 指向同一块连续存储单元（通常是数组）的两个指针变量可以进 行关系运算。假设指针变量p，q指向同一数组，则可用关系运算
则表示p，q指向数组的同一元素；若p指向地址较大元素，q指向 地址较小的元素，则 p>q 的值为１（真），且 p<q 的值为0(假)。 任何指针变量都可以与空指针 NULL相比较，如: if( (p=(double*)malloc(sizeof(double))) !=NULL )*p= ; 此语句功能是在动态存储区中分配一个连续８字节大小的存储区，如果分配成功，则把 存入该存储区。 返回目录

37 5.3.3指针比较 [例5.3] 输出数组的全部元素。 main()
{ int i, a[ ]={ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }, *p=a; printf("\n"); for(i=0; i<10; i++) printf("%8d", a[i]);　　 /* 循环语句１*/ for(i=0; i<10; i++) printf("%8d", *(a+i)); 　 /* 循环语句２*/ for(i=0; i<10; i++) printf("%8d", *(p+i)); /* 循环语句３*/ for(i=0; i<10; i++) printf("%8d", p[i]); /* 循环语句４*/ for(i=0, p=a; i<10; i++) printf("%8d", *p++); /* 循环语句５*/ for (p=a; p<a+10; p++) printf("%8d", *p); /* 循环语句６*/ } 上例中的六个循环语句功能是一样的，都用来输出a数组的10个元素。 第５、第６条循环语句使用了p++移动指针，使指针不断地指向下个 元素。注意第６条循环语句采用了表达式p<a+10这样的指针比较运 算。由于第５条循环语句使指针p产生了位移，因此第６条循环语句 中的赋初值p=a表达式不可缺少。 返回目录

38 5.3.3指针比较 [例5.4] 指针运算符“*”与增1运算符“++”同时作用于一个指针变量的 情况。 main()
{int i, a[]={ 11, 22, 33, 44, 55, 66 }, *p=a; printf(“%3d,”, (*p)++);/* 先输出*p,即输出a[0],再进行 (*p)++,即a[0]的值变成12,p值不变仍指向a[0] */ printf(“%3d,”, *p++);/* *p++相当于*(p++),先输出*p，即输出a[0]， 再进行p++，p指向a[1] */ printf(“%3d,”, *++p); /**++p相当于*(++p)，先进行++p,p指向a[2]， 再输出*p，即输出a[2] */ printf(“%3d\n”, ++*p); /*　++*p相当于++(*p)， 先进行++(*p)， 即a[2]的值变成34，再输出*p， p仍指向a[2] */ for(p=a; p<a+6; p++) printf(“%3d,”,*p); /* 最后输出数组的全部元 素 */ printf("\n"); } 返回目录

39 5.3.3指针比较 在分析[例5.4]时，应掌握如下规则： １.指针运算符“*”与增1运算符“++”均为单目运算符，运算优先级
相同，结合方向是“从右到左”； ２．增1运算符“++”作前缀运算符是“先加1，后使用”， 增1运算 符“++”作后缀运算符是“先使用，后加1”。 指针运算符“*”与减1运算符“--”同时作用于一个指针变量的情况与 上述类似，读者可以自已举例说明。 返回目录

40 5.3.4 字符串 Ｃ语言中可以用两种方式来处理字符串：用字符数组来处理字符 以及用指针来处理字符串。 １．字符数组
字符串 Ｃ语言中可以用两种方式来处理字符串：用字符数组来处理字符 以及用指针来处理字符串。 １．字符数组 4.1.2节中已经讲述了字符数组的概念。每个元素都是字符类型 的数组 称为字符数组。它的定义形式和元素的存取方法与一般数组相同 返回目录

41 5.3.4 字符串 [例5.5] 用字符数组存储字符串与字符。 main() {
字符串 [例5.5] 用字符数组存储字符串与字符。 main() { char str[]={‘O’,‘k’,‘!’,‘\0’}; /*数组名为str，由四个元素组成，每 个元素都存放相应的字符，如s[3]的值为‘\0’ */ char str1[]=“Ok!”; /*数组名为str1，由四个元素组成，元素赋值情况 与上面的str数组相同*/ char str2[]={‘O’,‘k’,‘!’}; /*数组名为str2,由三个元素组成，其中 str2[0]值为'O', str2[1]值为'k', str2[2] 值为'!' */ printf("%s",str); printf("%s\n",str1); printf("%c%c%c\n", str2[0], str2[1], str2[2]); } 返回目录

42 5.3.4 字符串 上例在定义字符数组的同时使用了两种赋初值的方式: （１）将字符逐个赋给数组中各个元素；
字符串 上例在定义字符数组的同时使用了两种赋初值的方式: （１）将字符逐个赋给数组中各个元素； （２）直接用字符串常量给字符数组赋初值，系统将字符串中 的字符顺 序逐个赋给数组中各个元素后，紧接着再把字符串结束标志‘\0 ’ 赋值给 后面的元素。在[例5.5]中，由于字符数组str2最后未赋字符串 结束标 志‘\0’因此不能视为字符串，不能整体输出。 返回目录

43 5.3.4 字符串 使用字符数组来表示字符串时，应注意: (１)字符数组与字符串的区别在于:每个字符串的最后都会加上一
字符串 使用字符数组来表示字符串时，应注意: (１)字符数组与字符串的区别在于:每个字符串的最后都会加上一 个字符‘\0’,而字符数组的每个元素用于存放一个字符,并没有规定 最后一个字符的内容。若在 字符数组中存放一系列字符之后, 接着加放一个字符‘\0’，这就等价于在字符数组中存放了一个字 符串。如果在字符数组中没有存放字符串结束标志‘\0’,该字符序 列就不是字符串。 (２)若要使用字符数组存放字符串，在定义字符数组时，其元素 的个数至少应该比字符串的长度多1，要留有存放字符串结束标志 ‘\0’的元素。 返回目录

44 5.3.4 字符串 (３)在定义字符数组时,可以用两种方式把一个字符串赋值给字符数组(见[例5.5]）：
字符串 (３)在定义字符数组时,可以用两种方式把一个字符串赋值给字符数组(见[例5.5]）： ① 将字符串中的字符依次逐个赋给数组中各个元素后，接着 加放一个字符‘\0’； ② 直接用字符串常量给字符数组赋初值，系统将字符串中 的字符顺序逐个赋给数组中各个元素后，自动把字符串结束 标志‘\0’赋值给后面紧接着的元素。 (４)非定义语句中，不能用赋值运算符“=”把字符串赋值给字符数 组。例如: char str[10]; str=“Ok! ”; 这里str是数组名,是地址常量,其值不能改变。因此,上述第二条赋 值语句str=“Ok!“;是非法的。程序运行时,若要把一个字符串赋值 给字符数组,通常用以下两种方式: 返回目录

45 5.3.4 字符串 ① 给字符数组元素逐个赋值，最后加放一个字符串结束标志，
字符串 ① 给字符数组元素逐个赋值，最后加放一个字符串结束标志， 下述程序段把字符串"Ok!"赋值给字符数组s。 char s[10]; s[0]= 'O'; s[1]= 'k'; s[2]= '!'; s[3]= '\0'; 用这种方法把字符串符赋值给字符数组，很繁琐也不直观. 更常用的方法是使用函数把字符串符赋值给字符数组； ② 使用Ｃ系统提供的库函数把字符串符赋值给字符数组，下 述程序段把字符串"Ok!"赋值给字符数组s。 char s[10]; 　　　　 strcpy(s, "Ok!"); 类似的函数还有strncpy，strcat等（参见第六章与附录F）。也可 使用输入函数: scanf，gets把从键盘输入的字符串赋值给字符数组。 返回目录

46 5.3.4 字符串 (５)允许使用输入、输出库函数（如gets，puts，scanf，printf）对字符数组中的字符串整体输入、输出。
字符串 (５)允许使用输入、输出库函数（如gets，puts，scanf，printf）对字符数组中的字符串整体输入、输出。 (６)对于较长的字符串，Turbo Ｃ允许使用下述分行方法来书写长字符串： char str2[5000]; char str1[]= “ 科学是关于自然的知识总体，它代表了人” “类的共同努力、洞察力、研究成果和智慧。\n当人” “们最初发现了在他们周围反复出现的” "各种关系时，就有了科学的开端。\n"; strcpy(str2, “通过对这些关系的仔细观察，人们开始了解了自然," “而由于自然的可靠性,\n人们还发现他们能够作出预测，” "从而有可能在某种程度上控制他们周围的环境。\n"); 返回目录

47 5.3.4 字符串 ２．字符指针 字符串常量是由双引号括起来的字符序列。例如：“Ok!”。程序中
字符串 ２．字符指针 字符串常量是由双引号括起来的字符序列。例如：“Ok!”。程序中 如果出 现字符串常量，系统就在内存中给该字符串常量分配一 连续的存储区 ，用以存放该字符串，系统还自动在该字符串的 末尾加上字符串的结束 标志‘\0’，因此一个字符串常量所占存储 区的字节数比它的长度（字符 的个数）多一个字节。可以用字 符指针指向字符串，然后通过字符指针 来存取字符串。例如： char *sp; sp="Ok!"; 返回目录

48 5.3.4 字符串 C语言中把字符串常量赋值给字符指针变量，相当于把该字符串
字符串 C语言中把字符串常量赋值给字符指针变量，相当于把该字符串 常量的首地址赋值给字符指针变量，上述语句sp=“Ok!”;使sp指 向字符串常量 “Ok!”，如图5.6所示（图中假设字符串常量“Ok!” 的首地址是1500。当sp指向某字符串常量时,就可以用sp来存取 该字符串，sp[i]或*(sp+i)就相当于字符串的第i+1个字符，如上述 sp[2]的值为‘!’。 返回目录

49 5.3.4 字符串 [例5.6] 利用字符指针把字符串s1复制到字符串s2。 main() {
字符串 [例5.6] 利用字符指针把字符串s1复制到字符串s2。 main() { char s1[]="Good!", s2[15]="How are you!", *from=s1,*to=s2; while (*from) *to++=*from++; *to='\0'; printf("%s\n%s\n",s1,s2); } 返回目录

50 5.3.4 字符串 图5.7说明了上例中复制前、后字符数组s2的变化情况，复制后
字符串 图5.7说明了上例中复制前、后字符数组s2的变化情况，复制后 输出s2时，遇第一个字符串结束标志(s2[5]的值为‘\0’)即停止 输出。元素s[13]与s[14]未用到，其值是任意字符。 返回目录

51 字符串 ３.字符数组与字符指针的区别 表5.1总结了使用字符数组处理字符串与使用字符指针处理字符串的区别。 返回目录

52 5.3.4 字符串 [例5.7]删除一个字符串中所有的空格字符。 #include "stdio.h" main() {
字符串 [例5.7]删除一个字符串中所有的空格字符。 #include "stdio.h" main() { 　　 char s[500], *p1, *p2; printf("请输入一个字符串，该字符串内的空格将被删除:"); gets(s); p1=p2=s; while( *p1 ) if( *p1 == ' ' ) p1++; else *p2++ = *p1++; *p2='\0'; printf("删除空格后的字符串是:%s\n",s); } 返回目录

53 字符串 分析上例的算法：首先p1、p2指向字符数组s的首地址，然后用字符指针p1对字符数组s中的字符依次逐个检查，如果是空格就继续检查下一个字符；如果不是空格就把字符存放在原s数组中， 所放的位置由字符指针p2决定，然后p1、p2下移一个元素；最后 再添加上字符串结束标志，见 图5.8。其中语句*p2++ = *p1++;与 复合语句：{ *p2=*p1; p2++; p1++; }等价。 返回目录

54 5.3.5 指针与二维数组 １．二维数组和数组元素的地址
指针与二维数组 １．二维数组和数组元素的地址 C语言的二维数组由若干个一维数组构成。即先把二维数组视为一个一维数组，而这个一维数组的每一个元素又是一个一维数组。例如定义以下二维数组： int a[3][5]= { { 1, 2, 3, 4, 5 }， { 6 , 7, 8, 9, 10 }, {11 , 12 , 13 , 14, 15 } }; a为二维数组，a数组有3行5列，共15个元素。可以这样理解，数 组a由三个元素组成：a[0], a[1], a[2]，而每个元素又是一个一维数 组，且都含有5个元素，即 a[0] 的元素有 a[0][0], a[0][1], a[0][2], a[0][3] , a[0][4]；数组名 a[0]是这一数组的首地址； a[1] 的元素有 a[1][0], a[1][1], a[1][2], a[1][3] , a[1][4]；数组名 a[1]是这一数组的首地址； a[2] 的元素有 a[2][0], a[2][1], a[2][2], a[2][3] , a[2][4]；数组名 a[2]是这一数组的首地址； 返回目录

55 指针与二维数组 同样数组名a就是数组｛a[0], a[1], a[2]｝的首地址，如图5.9和图5.10 所示。 返回目录

56 指针与二维数组 在Ｃ语言中，二维数组名a同样是二维数组的首地址，其值为二维数组中第一个元素的地址。a也是二维数组第0行的首地址，a 是第1行的首地址，a+2是第2行的首地址。假设此二维数组的首地址为1000，由于第每行有5个整型元素，所以a+1值为1010，a+2值为1020。如图5.10所示。 返回目录

57 5.3.5 指针与二维数组 由于a[0]，a[1]，a[2]是一维数组名，它们就是对应数组的首地址。因此：
指针与二维数组 由于a[0]，a[1]，a[2]是一维数组名，它们就是对应数组的首地址。因此： a[0]是第0行第0列元素的地址&a[0][0]，a[0]+1是第0行第1列元 素的地址 &a[0][1]．．．， a[1]是第1行第0列元素的地址&a[1][0]，a[1]+1是第1行第1列元 素的地址 &a[1][1]．．．， a[i]+j是第i行第j列元素的地址&a[i][j]。 另外，由指针运算符“*”和下标运算符“[ ]”的运算规则得知：a[0] 与*(a+0)等价,a[1] 与*(a+1)等价]．．．，a[i]与*(a+i)等价，因此 a[i]+j与*(a+i)+j等价， 它们的值都是 &a[i][j]，即元素a[i][j]的地址 返回目录

58 5.3.5 指针与二维数组 表5.2总结了二维数组元素的地址表示形式，表中假设二维数组a每行有５个元素,并假设a的首地址为1000。
指针与二维数组 表5.2总结了二维数组元素的地址表示形式，表中假设二维数组a每行有５个元素,并假设a的首地址为1000。 执行语句printf(“%p,%p”, a, *a); 可知 a和*a值是相同的，它们都 指向同一地址，但a是行指针，a+1指向下一排；而*a即为a[0]， 是数组a第0 行第0 列元素的地址&a[0][0]，*a+1指向下一个元素 a[0][1]。 返回目录

59 5.3.5 指针与二维数组 ２.通过地址存取二维数组元素 假设有如下定义： int a[3][5], i, j;
指针与二维数组 ２.通过地址存取二维数组元素 假设有如下定义： int a[3][5], i, j; 则二维数组a中的任一元素a[i][j]，可以用下述表达式之一来等价表示： （１）*(a[i]+j)　由上述知a[i]+j是第i行第j列元素的地址，因此*(a[i]+j)与a[i][j]等价； （２）*(*(a+i)+j) *(a+i)+j也是第i行第j列元素的地址，因此*(*(a+i)+j)与a[i][j]等价； （３）(*(a+i))[j]　此表达式表示先取到*(a+i)+j处的地址，再到该 地址处存取数据， 因此(*(a+i))[j]与a[i][j]等价； 返回目录

60 5.3.5 指针与二维数组 （４）*(&a[0][0]+5*i+j) 由于每行５个元素，&a[0][0]+5*i+j就是第I
指针与二维数组 （４）*(&a[0][0]+5*i+j) 由于每行５个元素，&a[0][0]+5*i+j就是第I 行第j列元素的地址，因此*(&a[0][0]+5*i+j)也与a[i][j]等价。由表 5.2知&a[0][0]与*a或a[0]等价,因此有如下等价关系： 返回目录

61 指针与二维数组 [例5.8] 以下通过一个简单的例子来说明上述等价关系。 main() { int i, j, a[][5]={ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 }; printf( "%5d,", *(a[1]+4) ); /* 输出元素a[1][4] */ printf( “%5d\n”, --*(*a+3) ); /* 先计算--a[0][3]，再输出a[0][3]的值 */ (*(a+1))[1] += 5; /* 等价于语句 a[1][1] += 5; */ *(&a[0][0]+5*2+3) = 55; /* 等价于语句 a[2][3] = 55; */ for(i=0; i<3; i++) for (j=0; j<5; j++) printf( "%5d", a[i][j] ); printf( "\n" ); } 返回目录

62 5.3.5 指针与二维数组 ３．通过指向数组元素的指针变量存取二维数组元素 假设有如下程序段： int a[3][5], i, j, *p;
指针与二维数组 ３．通过指向数组元素的指针变量存取二维数组元素 假设有如下程序段： int a[3][5], i, j, *p; p=&a[0][0]; 则二维数组a中的任一元素a[i][j]与表达式*(p+i*5+j)等价，此时a[i][j] 也与表达式 p[i*5+j]等价。这是因为p是一个指向整型变量的指针， 它也可以指向整型数组元素。 p+1就指向下一个元素，由于每行 5个元素，p+i*5+j就是第i行第j列元素的地址。由表5.2知，a[0] 与*a都是指向第0行第0列元素的地址（即&a[0][0]），因此在这里， 有如下的语句等价关系。 返回目录

63 5.3.5 指针与二维数组 [例5.9] 以下通过一个简单的例子来说明上述等价关系。 main() {
指针与二维数组 [例5.9] 以下通过一个简单的例子来说明上述等价关系。 main() { 　　 int i, j, *p, a[][5]={ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 }; p = *a; printf( "%5d,", *(p+2*5) ); /* 输出元素a[2][0] */ printf( “%5d\n”, (*(p+8))++ ); /* 先输出a[1][3]的值，再计算 a[1][3]++ */ *(p+14) += *(p+2*5+3); /* 等价于语句 a[2][4] += a[2][3]; */ for(i=0; i<3; i++) for (j=0; j<5; j++) printf( "%5d", a[i][j] ); printf( "\n" ); } 返回目录

64 5.3.5 指针与二维数组 ４．通过指向一维数组的指针变量存取二维数组元素 假设有如下程序段：
指针与二维数组 ４．通过指向一维数组的指针变量存取二维数组元素 假设有如下程序段： int a[3][5], i, j, (*pi)[5]; pi=a; 这里定义的(*pi)[5]中,圆括号 ( ) 内的*先与pi相结合，说明pi是 一个指针变量，然 后(*pi)再与右边的[5]相结合，说明指针变量pi指向“包含5个整型元素的一维数组”。由图5.9知数组名 a与pi一样，指向“包含5个整型元素的一维数组”。因此，当 pi=a; 时，pi+1将指向下一排（见图5.11）,称pi为行指针，也 称pi是（指向一维）数组(的)指针。 返回目录

65 5.3.5 指针与二维数组 按照地址对应关系，二维数组a中的任一元素a[i][j]，可以用下述 表达式之一来等价表示： 维数组名,是常量。
指针与二维数组 按照地址对应关系，二维数组a中的任一元素a[i][j]，可以用下述 表达式之一来等价表示： 应该注意，这里的pi是一个指针变量,其值是可改变的；而a是二 维数组名,是常量。 返回目录

66 5.3.5 指针与二维数组 [例5.10] 输出一个二维数组的指定行和指定列。 main()
指针与二维数组 [例5.10] 输出一个二维数组的指定行和指定列。 main() { int a[][5]={ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 }; int i, row, col, (*p)[5]; p=a; printf("请输入二维数组的行（0～2）、列（0～4）："); scanf("%d%d", &row, &col); printf("第%d行的数组元素是：", row); for (i=0; i<5; i++) printf("%5d", *(*(p+row)+i) ); printf("\n第%d列的数组元素是：", col); for (i=0; i<3; i++) printf("%5d", *(p[i]+col) ); printf("\n"); } 返回目录

67 5.3.5 指针与二维数组 假设有如下程序段： int a[3][5], i, j, *pa[3];
指针与二维数组 假设有如下程序段： int a[3][5], i, j, *pa[3]; for (i=0; i<3; i++) pa[i]=a[i]; 这里定义的*pa[3]中，下标运算符“[ ]”优先级高于“*”运算符，pa先与[ ]相 结合构成pa[3]，说明pa是一个数组名，它有3个元素，左边的“*”表示pa的每个元素都是指针，都可以指向整型变量。for循环语句把二维数组a 的每行第0列元素的首地址a[i]赋值给指针变量p[i]，如图5.12所示(图中假 设数组a的首地址为2000)。 返回目录

68 5.3.5 指针与二维数组 元素pa[i]（其中i=0,1,2）是指向整型变量的指针，可以用它指向整型
指针与二维数组 元素pa[i]（其中i=0,1,2）是指向整型变量的指针，可以用它指向整型 数组元素。pa[i]+1就指向下一个元素，按照地址对应关系，二维数 组a中的任一元素a[i][j]，可以用下述表达式之一来等价表示： 应该注意，上述表达式等价的条件是：指针数组pa的每个元素pa[i]分 别指向二维数组a的第i行第0列元素的首地址a[i]（即pa[i]=a[i],其中 i=0,1,2）。另外，pa[i]是一个指针变量，其值是可改变的；而a[i]是 常量，值不能改变。 返回目录

69 5.3.5 指针与二维数组 [例5.11]某班有４个学生，５门课程。编程完成下列操作：１.求出第３
指针与二维数组 [例5.11]某班有４个学生，５门课程。编程完成下列操作：１.求出第３ 门课程的平均分；２．按总分由大到小排序，输出每位学生的学号、成 绩及总分。 main() { int i, j; float *pa[4], *temp, average=0; float score[][7]= { { 1, 76.5, 89.5, 78, , 66, }, { 2, 56.5, 69.5, 49, , 73, }, { 3, 82,90, , 90.5, 81.5, 0.0 }, { 4, 67, 69.5, 43, , 52.5, 0.0 } }; /* 二维数组socre用于存放学生的学号(第0列元素)、5门课程的 */ /* 学习成绩(第1列至第5列元素)、每位学生5门课程的总成绩(第6列 元素) */ 返回目录

70 指针与二维数组 for( i=0; i<4; i++) pa[i] = score[i]; /* 给指针数组的每一个元素赋初值 */ for( i=0; i<4; i++) average += *(pa[i]+3); /* 计算第3门课的总分 */ average /= 4.0; /* 计算第3门课的平均分 */ printf("第3门课的平均分是: %6.2f\n", average); for( i=0; i<4; i++) for (j=1; j<6; j++) pa[i][6] += ( (*(pa+i))[j] ); /* 计算每位学生5门课的 总成绩 */ for( i=0; i<4; i++) /* 采用冒泡法排序 */ for( j=0; j<=4-i; j++) if ( pa[j][6] < pa[j+1][6] ) /* 比较总分值 */ 返回目录

71 5.3.5 指针与二维数组 { temp = pa[j]; pa[j] = pa[j+1]; pa[j+1] = temp;
指针与二维数组 { temp = pa[j]; pa[j] = pa[j+1]; pa[j+1] = temp; } /* 以下程序段按总分由大到小顺序, 输出每位学生的学生的 学号、成绩及总分*/ for( i=0; i<4; i++) { printf("第%.0f号学生的成绩为：", pa[i][0]); for( j=1; j<6; j++) printf( "%-8.2f", *(*(pa+i)+j) ); printf("总分为：%6.2f\n", pa[i][6]); } 返回目录

72 5.3.5 指针与二维数组 上例程序说明了当pa[i]=score[i]（其中i=0,1,2,3）时表达式
指针与二维数组 上例程序说明了当pa[i]=score[i]（其中i=0,1,2,3）时表达式 *(pa[i]+j)、*(*(pa+i)+j)、(*(pa+i))[j]、pa[i][j]及score[i][j]均可相互 等价，在排序前可以用 score[i][j]来代替对应的表达式。指针的优点在于它的值可以改变，指针可以指向不同的对象，本例题只需 交换指针的值就可完成排序，排序后将使得元素pa[i]的下标i值越 小，则pa[i]指向总分值越大的那行的首列元素（见图5.13），即 pa[0]指向总分最大的学生的学号，pa[1]指向总分第二大的学生 的学号，...，pa[3]指向总分最小的学生的学号。本例题如果不用指针，只用二维数组来完成排序，每次交换的数据量是一行的内容，程序的执行效率将大大降低。 返回目录

73 5.3.5 指针与二维数组 ６．通过二维字符数组构成字符串数组
指针与二维数组 ６．通过二维字符数组构成字符串数组 如上所述，C语言中的二维数组可视为一个一维数组，这个一维数组的每个元素又是一个一维数组。因此可以用二维字符数组来 构成字符串数 组。例如： 　　 char book[50][128]; 数组book共有50元素，每个元素可存放128个字符，若用于存放字 符串，可以存放50个长度小于128的字符串。字符串数组可以在 定义时赋初值。例如下面的定义语句： char str[5][10]={ "BASIC", "ADA", "Pascal", "C", "Fortran" }； 上述语句的中二维数组的第一维的长度可以省略，系统将根据字 符串的个数来分配存储空间，与下面的定义语句等价 char str[ ][10]={ "BASIC", "ADA", "Pascal", "C", "Fortran" }； 返回目录

74 5.3.5 指针与二维数组 此二维数组str在内存中存储情况如图5.14所示。str[i](其中i=0, 1,
指针与二维数组 此二维数组str在内存中存储情况如图5.14所示。str[i](其中i=0, 1, 2, 3, 4)代表了第i个字符串的首地址，也可用str[i][j]来存取数组中的一个字符，设有输出语句 printf("%s, %c\n", str[2], str[4][1]); 该语句执行后输出结果是: Pascal, o 即str[2]指向字符串"Pascal"，str[4][1]的值是'o'。 返回目录

75 指针与二维数组 由图5.14可知，用二维字符数组来存放字符串，各字符串都是从每行的第0个元素开始存放字符，有部分存储单元空闲着，各字符串的长度差别越大，空闲单元就越多，显然这将浪费内存。 为了使各字符串常量在内存中存放时不浪费内存空间，可以定义一个指针数组，并在定义时用字符串赋初值的方法，来构成 一个字符串数组。例如： char *ps[5]={ "BASIC", "ADA", "Pascal", "C", "Fortran"}； 返回目录

76 指针与二维数组 这一字符数组在内存的存储情况见图5.15。执行这条语句时，首先为每个字符串常量分配相应的存储空间，然后把相应字符串的首地址赋值给指针数组ps的5个对应的元素，即ps[i](其中i=0, 1, 2, 3, 4)指向第i个字符串，还可以用p[i][j]、p[i]+j)、 *(*(p+i)+j)、(*(p+i))[j]等形式存取第i个字符串中的第j个字符。 设有输出语句 printf("%s, %c\n", ps[4], ps[2][1]); 　　 该语句执行后输出结果是: Fortran, a 即ps[4]指向字符串“Fortran”,ps[2][1]的值是‘a’。用这种方式组成的字 符串数组系统根据字符串常量的长度来分配存储空间，不会浪费内存空 间。 返回目录

77 指针与二维数组 [例5.12]编写一程序，输入数字星期几，则输出英文对应的星期几。例如，输入“０”，则输出“Sunday”，若输入“6”，则输出“Saturday”。 main() { char weeks[][10]={"Sunday", "Monday", "Tuesday", "Wednesday", "Thursday","Friday", "Saturday"}; int i; do printf("请输入星期几（数字0～6）:"); scanf("%d", &i); }while(i<0 || i>6); printf("%s\n", weeks[i]); } 返回目录

78 指针与二维数组 [例5.13]将字符串"BASIC", "ADA", "Pascal", "C", "Fortran"　按从小到大的顺序排序后输出。 #include "string.h" main() { char *temp, *ps[5]={"BASIC", "ADA", "Pascal", "C", "Fortran"}; int i, j, k; for (i=0; i<4; i++) { k=i; for (j=i+1; j<5; j++) if ( strcmp(ps[k], ps[j])>0 ) k=j; /*ps[k]总指向值较小的字符串*/ if ( k!=i ) 返回目录

79 5.3.5 指针与二维数组 { temp=ps[i]; ps[i]=ps[k]; ps[k]=temp; }
指针与二维数组 { temp=ps[i]; ps[i]=ps[k]; ps[k]=temp; } for(i=0; i<4; i++) printf("%s, ", ps[i]); printf("%s\n", ps[4]); 返回目录

80 5.3.5 指针与二维数组 上例程序利用选择法排序字符串，程序中用到字符串比较函数
指针与二维数组 上例程序利用选择法排序字符串，程序中用到字符串比较函数 strcmp来比较二个字符串的大小。比较过程中改变指针数组ps元 素的指向，最后将使得元素ps[i]的下标i值越小，则ps[i]指向值越 小的字符串。比较完成后，ps各元素的指向如5.16所示。 返回目录

81 5.4 指向指针的指针 教学内容： 5.4.1 指向指针的指针 5.4.2 定义指向指针的指针变量 5.4.3 指向指针的指针变量的应用

82 5.4.1指向指针的指针 通过一个指针变量来存取变量的值，这种方式称为“间接存取”方式。例如： double d, *p=&d;
指针变量p中存放的是一个变量d的地址，通过变量p可以间接地 存取变量d的数据, 先通过变量p到变量d的地址，然后再存取变 量d的值，这种通过一次“间接存取 就能存取变量的值，称为 “一级间址”方式，如图5.17(a)所示。如果一个指针变量中存放的是另一指针变量的地址，这就需要二次“间接存取”才能存取变 量的值 ，这称为“二级间址”， 返回目录

83 5.4.1指向指针的指针 如图5.17(b)所示，这样的指针变量称为指向指针的指针。
理论上，Ｃ语言的“间接存取”方式可以进行多次，构成“多级间 址”， 如图5.17(c) 所示，但实际应用中很少超过二级间址，因为级数越高，存取速 度越慢，也不易 理解其存取机制。 返回目录

84 5.4.2 定义指向指针的指针变量 指向指针的指针变量定义的形式为： 类型名 **指针变量名;
　　类型名　**指针变量名; 此处，指针变量名是“指向指针的指针”的变量名称，类型名是 该指针变量经过二级间址后所存取变量的数据类型。由于运算 符“*”的结合性是“从右到左”，因此“**指针变量名”等价于“*(* 指针变量名)”，表示该指针变量的值存放的是另个指针变量的地 址，要经过二次间接存取后才能存取到变量的值。例如语句： 　　　　double **pp; 定义pp为指向指针的指针变量，它要经过二次间接存取后才能 存取到变量的值， 该变量的数据类型为double。 返回目录

85 5.4.3 指向指针的指针变量的应用 １．指向一个指针变量，间接存取变量的值 可以把一个指针变量的地址赋值给指向指针的指针变量，然后通过二级
　可以把一个指针变量的地址赋值给指向指针的指针变量，然后通过二级 址方法存取变量的值。 [例5.14] 以下通过一个简单的例子说明如何通过二级间址方法存取变量的值。 main() { double d= , *p, **pp; pp=&p; p=&d; printf("d=%8.3f, ", **pp); **pp += ; printf("d=%8.3f\n", d); } 返回目录

86 5.4.3 指向指针的指针变量的应用 ２．指向指针数组，存取指针数组元素所指内容 可以把一个指针数组的首地址赋值给指向指针的指针变量。例如：
[例5.15] 有三个等级分，由键盘输入1，屏幕显示“pass”， 输入２显示“good”，输入3显示“excellent”。 main() { int grade; char *ps[ ]={"pass", "good", "excellent" }, **pp; pp=ps; printf("请输入等级分(１～３)："); scanf("%d", &grade); printf("%s\n", *(pp+grade-1) ); } 返回目录

87 5.4.3 指向指针的指针变量的应用 上述程序中pp指向指针数组ps的第一个元素ps[0]，pp+1则指向ps的下一个元素p[1]，pp+2指向p[2]，如图5.19所示。因此*pp就 是字符串“pass”的首地址，*(pp+1)则是字符串“good”的首地址， *(pp+2)是字符串"excellent"的首地址。 返回目录

88 5.5 指针与结构 教学内容： 5.5.1 指向结构体变量的指针变量 5.5.2 指向结构体数组的指针变量
5.5 指针与结构 教学内容： 5.5.1 指向结构体变量的指针变量 5.5.2 指向结构体数组的指针变量 5.5.3 通过指针变量存取位段数据

89 指向结构体变量的指针变量 在第四章4.2节已经讲述了“结构体”的概念。在定义一个结构体变 量时，系统将在内存中分配一块连续的存储空间，用于存放结构 体成员的数据，这块连续存储空间的首地址称为结构体变量的指 针（也称为结构体变量的首地址）。可以定义指向结构体变量的 指针变量，若把某结构体变量 的首地址赋值给一个指针变量，则称这一指针变量指向该结构体变量 。 返回目录

90 5.5.1 指向结构体变量的指针变量 指向结构体的指针变量定义格式是： struct 类型名 *指针变量名；
指向结构体变量的指针变量 指向结构体的指针变量定义格式是： struct　类型名　*指针变量名； 上述类型名为结构体类型名。例如下面定义一个结构体类型booktp来存储书的基本信息： struct booktp { char name[60]; /*书名*/ char author[30]; /*作者*/ float price; /*价格*/ struct datetp unsigned year; unsigned month; } pubday; /*出版日期*/ }; 返回目录

91 5.5.1 指向结构体变量的指针变量 定义了结构体类型，就可以定义结构体变量和指向结构体变量的指 针，
指向结构体变量的指针变量 定义了结构体类型，就可以定义结构体变量和指向结构体变量的指 针， struct booktp book5, *p; 其中book5为结构体变量，p为指向结构体变量的指针。若p=&book5；则称指针变量p指向结构体变量book5，此时可用下述 三种方式之一存取结构体成员（三种方式是等价的）： １．结构体变量名.成员名 ２．指针变量名->成员名 ３．(*指针变量名).成员名 返回目录

92 5.5.1 指向结构体变量的指针变量 例如有下面程序段，
指向结构体变量的指针变量 例如有下面程序段， 　struct booktp *p, book5={“C++ Buider 网络开发实例”, “清汉计算机工作 室", 53, {2000, 9} }; 　 p=&book5; 则book5.price，p->price以及(*p).price的值都是53.0， 而book5.pubday.year，p->pubday.year以及(*p).pubday.year的值都 是2000。 其中指向运算符“->”是由两个符号“-”和“>”组合在一起，就象一个箭 头指向结构成员。指针运算符“*”作用于指针变量p上，构成表达式 (*p)，等价于结构体变量名book5。注意此处(*p).price的圆括号不能少， 若写成*p.price，由于结构体成员运算符“.”的优先级高于指针运算符 “*”，因此*p.price相当于*(p.price)，这是一个非法的表达式。 返回目录

93 5.5.2 指向结构体数组的指针变量 指向结构体的指针变量也可以指向结构体数组及其元素。例如，下述程序段：
指向结构体数组的指针变量 指向结构体的指针变量也可以指向结构体数组及其元素。例如，下述程序段： struct booktp *p, book[3]; p=book; 这样，指针变量p指向结构体数组book的首地址， p+1指向下一个元素book[1],p+2指向元素book[2]，如图5.20所示，图中假定book[0]的地址是3000，由于 sizeof(struct booktp)的值为98，每个结构体元素占内存空间98个字节，因此p+1指向地址3098处，p+2指向地址3196处。 返回目录

94 5.5.2 指向结构体数组的指针变量 使用指针变量指向结构体变量或结构体数组时，应注意运算符的优先级：
指向结构体数组的指针变量 使用指针变量指向结构体变量或结构体数组时，应注意运算符的优先级： １.“( )”、“[ ]”、“->”、“.”四个运算符优先级相同，在Ｃ语言中具有 最高的优先级，运算的结合方向是“从左到右”； ２.“*”、“++”、“--”、“&”四个运算符优先级相同，在Ｃ语言优先级 的级别仅次于上述的四个运算符，运算的结合方向是“从右到左”。 [例5.16] 通过一个简单的例子说明指向结构体数组的指针的应用。 在程序 中，为了说明运算符的优先级和结合性的用法，改变了书的价格。 返回目录

95 5.5.2 指向结构体数组的指针变量 main() { struct booktp {char name[60]; /*书名*/
指向结构体数组的指针变量 main() { struct booktp {char name[60]; /*书名*/ char author[30]; /*作者*/ float price; /*价格*/ struct datetp unsigned year; unsigned month; } pubday; /*出版日期*/ }; 返回目录

96 5.5.2 指向结构体数组的指针变量 struct booktp *p,book[3]=
指向结构体数组的指针变量 struct booktp *p,book[3]= { {“C++Buider 网络开发实例”, “清汉计算机工作室”, 53.0, {2000, 9} }, {"SQL Server 循序渐进教程", "Petkovic", 35.0, {1999, 6} }, {"VB开发指南", "Dianne Siebold", 28.0, {2000, 9 } }, }; p=book; printf(“%8.2f,”, ++p->price); /*上述表达式等价于++(p->price), 即 先计算 ++(book[0].price), 再输出book[0].price */ printf(“%8.2f,”, (++p)->price); /*上述语句先计算++p, p指向 book[1].price, 再输出 book[1].price */ 返回目录

97 指向结构体数组的指针变量 printf(“%8.2f,”, p++->price); /*上述表达式等价于(p++)->price, 先输出 book[1].price，再计算p++, p指向book[2]*/ printf(“%8.2f\n”, p->price++); /*上述表达式等价于(p->price)++, 先输 出book[2].price，再计算(book[2].price)++ */ for(p=book; p<book+3; p++) /* 输出结构体数组的所有数据 */ printf("%s,作者:%s,出版日期:%d年%d月,价格:%5.1f\n", p->name, (*p).author, p->pubday.year, p->pubday.month, p->price); } 返回目录

98 通过指针变量存取位段数据 不能用指针变量指向位段成员，但可以用指针变量指向一个带有位段的结构体变量，此时可用下述三种方式之一存取结构体成员的值（三种方式是等价的）： １．结构体变量名.位段名 ２．指针变量名->位段名 ３．(*指针变量名). 位段名 返回目录

99 5.5.3 通过指针变量存取位段数据 [例5.17]通过指针变量存取位段数据。 main() { struct packed_data
通过指针变量存取位段数据 [例5.17]通过指针变量存取位段数据。 main() { struct packed_data {　unsigned a:4; unsigned b:3; unsigned c:9; } *p, data={ 9, 5, 60}; p=&data; printf("%u,%u,%u\n", p->a, (*p).b, data.c); p->a += 2; (*p).c >>= 2; } 返回目录

100 5.6 指向共用体和枚举型的指针 教学内容： 5.6.1 指向共用体变量的指针变量 5.6.2 指向枚举型的指针变量

101 5.6.1 指向共用体变量的指针变量 指针变量可以指向一个共用体变量，此时可用下述三种方式之一存取共用体成员（三种方式是等价的）：
１．共用体变量名.共用体成员名 ２．指针变量名->共用体成员名 ３．(*指针变量名). 共用体成员名 返回目录

102 5.6.1 指向共用体变量的指针变量 [例5.18]通过指针变量存取共用体成员数据。 main() { struct byte_tp {
unsigned char al, ah; }; union reg_tp unsigned ax; struct byte_tp h; union reg_tp a, *p; p = &a; 返回目录

103 5.6.1 指向共用体变量的指针变量 a.ax = 0x3b5e;
printf("ax=%x, al=%x, ah=%x\n", p->ax, (*p).h.al, p->h.ah); p->h.al -= 3; p->h.ah &= 0x0f; } 返回目录

104 5.6.1 指向共用体变量的指针变量 上例说明了一个reg_tp共用体类型、以及定义相应的共用体变量a和指针变量p，变量a占内存两字节，可使用a.h.ah对它的高字节操作，使用a.h.al对它的低节操作，使用a.ax对高、低两字节同时操作，这类似于“字存取”及“字节存取”ＣＰＵ寄存器上的数据，如图 5.21所示。当指针变量p指向共用体变量a时，有下等价表示关系。 返回目录

105 5.6.2 指向枚举型的指针变量 指针变量可以指向一个枚举型变量，如下定义一个枚举型变量e和指向枚 举型变量的指针变量p：
指向枚举型的指针变量 指针变量可以指向一个枚举型变量，如下定义一个枚举型变量e和指向枚 举型变量的指针变量p： enum 枚举型类型名　e, *p; 若p指向枚举型变量（即p=&e;），则*p与变量e是等价的。 　　[例5.19]通过指针变量存取枚举型变量的值。 main() { enum fruit_type { apple, orange, banana, pineapple }; enum fruit_type fruit[ ]={ orange, apple, pineapple, banana }, *p; char *fruit_name[ ]={"苹果", "桔子", "香蕉", "波萝"}; for( p=fruit; p<fruit+4; p++) printf("%s,", fruit_name[*p]); printf("\n"); } 返回目录

106 5.6.2 指向枚举型的指针变量 apple(对应整数0)、pineapple(对应整数3)、
指向枚举型的指针变量 上例程序中fruit是一个枚举型数组，有四个元素，用指针变量p依 次取出fruit数组四个元素的值：orange(对应整数1)、 apple(对应整数0)、pineapple(对应整数3)、 banana(对应整数2)。而fruit_name是一个指针数组， 共有四个元素，分别指四个字符串。输出时用*p做 fruit_name数组的下标，此时系统自动把*p的枚举型 enum fruit_type类型）转换成其对应的整型数据，如 fruit_name[banana]等于fruit_name[2]。 返回目录

107 本章讲述了利用指针处理内存中各种类型数据的方法，小结如下。
5.7 指针小结 本章讲述了利用指针处理内存中各种类型数据的方法，小结如下。 5.7.1 指针概念综述 5.7.2 指针运算小结 5.7.3 等价表达式

108 5.7.1 指针概念综述 １．变量的地址就是变量的指针。用于存储地址的变量称为指针变量。
指针概念综述 １．变量的地址就是变量的指针。用于存储地址的变量称为指针变量。 当一个变量的地址赋值给某一指针变量时，称这个指针变量指向该变 量。此时，既可用变量名直接存取变量的值，也可用指针变量间接存 取变量的值。 ２．Ｃ语言中的数组变量、字符串数组变量、字符串、结构体变量、 共用体变 量、枚举型变量，甚至函数名及函数的参数（在第六章作详 细介绍）以及文件在第八章作详细介绍）等都有指针，可以定义相应 的指针变量存放这些指针。同样有两种方法存取变量的值：用变量名 直接存取或用指针变量间接存取。也有两种方法调用函数：用函数名 来调用或用指向函数的指针变量来调用（见第六章）。 ３．指针运算符“*”作用在变量的地址上，即表达式“*变量的地址” 相当于间接存 取该变量的值。 ４．一维数组名是该数组的首地址（第一个元素的地址）。当指针 变量p指向数组的某一个元素时，p+1指向下一个元素，p-1指向上一个 元素。 返回目录

109 5.7.1 指针概念综述 ５．字符串可以存放在字符数组中，也能以字符串常量的形式出 现在程序中。程序中把一个字符串常量赋值给一个指针变量，实
指针概念综述 ５．字符串可以存放在字符数组中，也能以字符串常量的形式出 现在程序中。程序中把一个字符串常量赋值给一个指针变量，实 际上是把存放该字符串常量的内存单元首地址赋值给指针变量。 ６．可以把C语言的二维数组a视为一个一维数组(a[0]，a[1]， a[2]，. . . )，而这个一维数组的每一个元素a[i]又是一个一维 数组（a[i][0]，a[i][1]，a[i][2]，. . .）。因此，&a[i][j]、a[i]+j与*(a+i)+j三者相互等价，都是元素a[i][j] 的地址。一个行指针 变量pi指向的数据类型是一个有Ｎ个元素的一维数组，当pi指向二维数组的一行（设每行也有Ｎ个元素）时，pi+1指向下一行，pi-1指向上一行。 ７．指针数组的每一个元素都是一个指针变量，指针数组的元素 可用来指向变量、数组元素、字符串等。 返回目录

110 5.7.1 指针概念综述 ８．指向指针的指针要进行二次“间接存取”（二级间址）才能存取变量的值。
指针概念综述 ８．指向指针的指针要进行二次“间接存取”（二级间址）才能存取变量的值。 ９．通过指针变量存取结构体变量成员数据有二种方法:一种是通过指针运算符“*”，另一种 是通过指向运算符"->"。指针变量存取共用体变量的数据也与之类似。 10．在Ｃ程序中使用指针编程，可以写出灵活、简练、高效的好程序，实现许多用其它高级 语言难以实现的功能。 11．初学者利用指针编程较易出错，而且这种错误往往是隐蔽的、难以发现。比如由于未 对指针变量p赋值就对*p赋值，新值就代替了内存中某单元的内容，可能出现不可意料的错 误。因此使用指针编程，概念要清晰，并注意积累经验。 返回目录

111 5.7.2 指针运算小结 １．指针变量赋值 通过如下程序段来说明指针变量的赋值：
指针运算小结 １．指针变量赋值 通过如下程序段来说明指针变量的赋值： int i, j, a[10], b[5][9], *p, *q, (*pi)[9], *pa[5]; char *ps; char *pas[]={"abc", "defghij", "kn"}; /*将三个字符串常量"abc", "defghij", "kn" */ /* 的首地址分别赋值给指针数组pas的三个元素pas[0]、 pas[1]、pas[2] */ p=&i; /* 将一个变量地址赋给指针变量p */ q=p; /* p和q都是指针变量，将p的值赋给q */ q=NULL; /* 将NULL空指针赋值给指针变量q　*/ p=(int*)malloc(5*sizeof(int)); /* 在内存中分配10个字节的连续存储单元 块，并把这块连续存储单元的首地址赋值 给指针变量p */ p=a; /* 将一维数组a首地址赋给指针变量p */ 返回目录

112 5.7.2 指针运算小结 p=&a[i]; /* 将一维数组a的第i个元素地址赋给指针变量p */
指针运算小结 p=&a[i]; /* 将一维数组a的第i个元素地址赋给指针变量p */ p=&b[i][j]; /* 此赋值语句等价于p=b[i]+j; 或 p=*(b+i)+j; 这三条语句 都是 将二维数组元素b[i][j]地址赋给指针变量p */ pi=b+i; /* 此赋值语句等价于pi=&b[i];　表示行指针pi指向二维数组b 的第i行 */ for( i=0; i<5; i++) pa[i]=b[i]; /* 指针数组pa的元素pa[i](i=0, 1, …, 4)，分别指向二维数组b的第i行的第0 列元素 */ ps="Hello!";/* 将字符串常量"Hello!"的首地址赋值给指针变量ps */ 返回目录

113 5.7.2 指针运算小结 ２．指针变量加（减）一个整数 若有下述程序段： 类型名 *p, *q; p=p+n; q=q-m;
指针运算小结 　２．指针变量加（减）一个整数 若有下述程序段： 类型名　*p, *q; p=p+n; q=q-m; 此处“类型名”是指针变量p，q所指向变量的数据类型，并假定m, n为正整数，则统 将自动计算出： p指针向高地址方向位移的字节数＝sizeof(类型名)*n; q指针向低地址方向位移的字节数＝sizeof(类型名)*m; 指针变量每增1、减 1一次所位移的字节数等于其所指的数据类 型的大小，而不是简单地把指针变量的值加１或减１。另外，上 述指向二维数组b的行指针pi++; pi则指向二维数组b的下一行 返回目录

114 5.7.2 指针运算小结 ３．两个指针变量相比较 指向同一块连续存储单元（通常是数组）的两个指针变量可以进
指针运算小结 ３．两个指针变量相比较 指向同一块连续存储单元（通常是数组）的两个指针变量可以进 行关系运算。假设指针变量p，q指向同一数组，则可用关系运算符 “<”，“>”，“>=”，“<=”，“==”“!=”进行关系运算。若p==q为真，则表 示p，q指向数组的同一元素；若p指向地址较大元素，q向地址较小 的元素，则 p>q 的值为１（真）。如果p和q不指向同一数组，则比 较无意义。任何指针变量或地址都可以与NULL作相等或不相等的比 较。 ４．两指针变量相减 指向同一块连续存储单元（通常是数组）的两个指针变量可以进行相减 运算。假设指针变量p，q指向同一数组，则p-q的值等于p所指对象与q所 指对象之间的元素个数，若p>q则取正值，p<q取负值。 返回目录

115 等价表达式 用指针变量指向某一数据类型的变量时，就可以通过指针来存取该变量的值。表 5.3列出了通过指针存取变量值的相互等价表达式, 表中N、M为整型常量；并假设表中所有构造型数据类型均已正确定义完成。 返回目录

116 习题 一、 选择题（每题只有一个正确答案） 5.1 若已定义：int *p, a; 则语句 p=&a; 中的运算符“&”的含义是【１】。
【１】 A）位与运算 B）逻辑与运算 C）取指针内容 D）取变量地址 5.2 若已定义：int a, *p=&a; 则下列函数调用中错误的是【２】。 【２】 A）scanf("%d", &a); B）scanf("%d", p); C）printf("%d", a); D）printf("%d", p); 5.3 若已定义 int a=5; 对(1) int *p=&a; (2) *p=a;两个语句的正确解释 是【３】。 【３】 A）语句(1)和(2)中的 *p 含义相同，都表示给指针变量赋值 B）语句(1)和(2)的执行结果都是把变量 a 的地址赋给指针变量 p C）语句(1)是在对 p 进行说明的同时进行初始化，使 p 指向 a； 语句(2)是将变量 a 的值赋给指针变量 p D）语句(1)是在对 p 进行说明的同时，使 p 指向 a； 语句(2)是将变量 a 的值赋给指针变量 p 所指变量

117 习题 5.4 Ｃ语言中 NULL 表示【４】。 【４】 A）空指针 B）未定义的变量 C）字符串的结束符 D）文件的结束符
5.5 若有定义 char *p, ch; 则不能正确赋值的语句组是【５】。 【５】 A）p = &ch; scanf("%c",p); B）p = (char *)malloc(1); *p = getchar(); C）*p = getchar(); p = &ch; D）p = &ch; *p = getchar(); 5.6 以下程序段动态分配一个整型存储单元，单元的地址给s，请选择正确答案填空。 int *s; s= 【6】malloc( sizeof(int) ); 【6】 A）int * B）int C）(int *) D）void *

118 习题 5.7 以下程序段的功能是【７】。 char str1[300], str2[300], *s=str1, *t=str2;
5.7 以下程序段的功能是【７】。 char str1[300], str2[300], *s=str1, *t=str2; gets(s); gets(t); while( (*s) && (*t) && (*t==*s) ) { t++; s++; } printf("%d\n", *s-*t); 【７】 A）输出两个字符串长度之差 　　　 B）比较两个字符串，并输出其第一个不相同字符的ASCII码 的差值 　　 　 C）把str2中的字符串复制到str1中,并输出两个字符串长度之 差 　　 D）把str2字符串连接到str1之后，并输出其第一个不相同字符 的ASCII码的差值 5.8 若有以下定义和语句，且0≤i＜5，则不能访问数组元素的是【８】。 int i, *p, a[]={ 1, 2, 3, 4, 5 }; p = a; 【８】 A）*( a+i ) B）p[ p-a ] C）p+i D）*( &a[i] )

119 习题 5.9 以下程序段的运行结果是【９】。 char s[]="ABC"; int i;
5.9 以下程序段的运行结果是【９】。 char s[]="ABC"; int i; for (i=0;i<3;i++) printf("%s", &s[i]); 【９】 A）ABC B）ABCABCABC C）AABABC D）ABCBCC 5.10 把字符串"Ok!"赋值给变量不正确的语句或语句组是【10】。 【10】 A）char a[] = "Ok!"; B）char a[8] = {'O','k','!','\0'}; C）char *p; D）char *p; p = "Ok!"; strcpy(p,"Ok!"); 5.11下列程序段的输出结果为【11】。 float y=0.0, a[]={2.0, 4.0, 6.0, 8.0, 10.0}, *p; int i; p=&a[1]; for(i=0; i<3; i++) y += *(p+i); printf("%f\n",y); 【11】 A） B） C） D）

120 习题 5.12 下列程序段的输出结果为【12】。 char b[]="ABCD"; char *chp=&b[3];
while( chp>&b[0]) { putchar(*chp); --chp; } 【12】 A）DBCA B）DCB C）CB D）CBA 5.13 下列程序段的输出结果为【13】。 char s*= "Morning", *p=s; while(*p!='\0') p++; printf("%d\n", (p-s)); 【13】 A） B） C） D）9

121 习题 5.14 以下程序段的运行结果是【14】。 char c[]={ 'a', 'b', '\0', 'c', '\0' };
printf( "%s\n" , c ); 【14】 A）ab c B）'a''b' C）abc D）ab 5.15 以下各语句中，字符串"abcde"能正确赋值的操作是【15】。 【15】 A）char s[5] = { 'a','b','c','d','e' }; B）char *s; s = "abcde"; C）char *s; gets( s ); D）char *s; scanf( "%s", s ); 5.16 以下程序段的输出结果是【16】。 char s[10], *sp = "HELLO"; strcpy( s, sp ); s[0] = 'h'; s[6] = '!'; puts( s ); 【16】 A）hELLO B）HELLO 　C）hHELLO! D）h!

122 习题 5.17 以下程序段的运行结果是【17】。 char *s = "0123214";
int v1 = 0, v2 = 0, v3 = 0; while( *s ) { switch( *s ) 　 { default : v3++; 　　 case '1' : v1++; break; case '2' : v2++; } s++; printf("%d,%d,%d\n", v1, v2, v3); 【17】 A）5,2, B）2,2, C）5,5, D）1,0,1

123 习题 5.18 若有以下定义和语句，值为9的正确表达式是【18】。
int a[][3]={ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}, *p; p = &a[0][0]; 【18】 A）*(p+2*3+2) B）*(*(p+2)+2) C）p[2][2] D）*(p[2]+2) 5.19 若有定义 int a[3][5], i, j; (且0≤i＜3，0≤j＜5)，则 a[i][j] 的 地址不正确表示是【19】。 【19】 A）&a[i][j] B）a[i]+j C）*(a+i)+j D）*(*(a+i)+j)

124 习题 5.20 若有以下定义和语句，则对 a 数组元素地址的正确引用是【20】。 int a[2][3], (*p)[3]; p=a;
【20】 A）*(p+2) B）p[2] C）p[1] D）(p+1)+2 5.21 若有定义 int *p[4]; 则标识符 p 是一个【21】。 【21】 A）指向整型变量的指针变量 B）指向函数的指针变量 C）指向有四个整型元素的一维数组的指针变量 D）指针数组名，有四个元素，每个元素均为一个指向整型变量 的指针 5.22 若有定义 int (*ptr)[M]; 则标识符ptr是【22】。 【22】 A）M个指向整型变量的指针 B）指向M个整型变量的函数指针 C）一个行指针，指向有M个整型元素的一维数组 D）有M个指针元素的一维指针数组，每个元素都只能指 向整型变量

125 习题 5.23 设有如下定义，则以下说法中不正确的是【23】。 char *ps[2]={ "abc", "ABC"};
【23】 A）ps 为指针变量，它指向含有两个数组元素的字符型一维数组 B）ps 为指针数组，其两个元素中各自存放了字符串“abc”和 "ABC"的首地址 C）ps[1][2] 的值为 'C' D）*(ps[0]+1) 的值为 'b‘ 5.24 以下程序段的运行结果是【24】。 int a[4][3]={ 1,2,3, 4,5,6, 7,8,9, 10,11,12 }; int *p[4],j; for( j=0; j<4; j++) p[j]=a[j]; printf( "%2d,%2d,%2d,%2d\n", *p[1], (*p)[1], p[3][2], *(p[3]+1) ); 【24】 A）4, 4, 9, B）程序出错 C）4, 2,12, D）1, 1, 7, 5

126 习题 5.25 若有定义 char *language[]={ "FORTRAN", "BASIC", "PASCAL", “
JAVA", "C" }; 则 language[2] 的值是【25】。 【25】 A）一个字符 B）一个地址 C）一个字符串 D）不定值 5.26 设有以下定义，则下列能够正确表示数组元素a[1][2]的正确表达式 是【26】。 int a[][3]={1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}; int *p=a[0]; 【26】 A）*((*p+1)[2]) B）*(*(p+5)) C）(*p+1) D）*(*(a+1)+2) 5.27 设有以下语句，则值为11的表达式是：【27】。 struct st 　 { int n; char ch; } a[3]={10, 'A', 20, 'B', 30, 'C'}, *p=&a[0];; 【27】 A）p++->n B）p->n C）(*p).n D）++p->n

127 习题 5.28 以下程序段的运行结果是【28】。 struct stu { int x, int *y; } *p ;
{　 int x, int *y; } *p ; int dt[]={ 1, 2, 3, 4 }; struct stu a[4]={ 5, &dt[0], 6, &dt[1], 7, &dt[2], 8, &dt[3] }; p=a; printf( "%d," , (++p)->x ); printf( "%d," , ++p->x ); printf( "%d\n", ++(*p->y) ); 【28】 A）6,7, B）6,6, C）6,6, D）5,7,2

128 习题 5.29 阅读以下程序，当程序运行时输入 hi 后回车，则程序输出 6968； 若程序运行时输出为 6869，那么输入的是【29】。
#include <stdio.h> main() { union val char cval; int ival; } x; char *p; p=&x.cval+1; scanf( "%c%c", &x.cval, p ); printf( "%x\n", x.ival ); } 【29】 A）lp B）** C）jn D）ih

129 习题 5.30 以下程序段的输出结果是【30】。 union u_tp { char ch[2]; int a;
} r={'A'}, *p=&r; p->ch[1]='B'; printf("%x\n", p->a); 【30】 A） B） C）AB D）BA

130 习题 二、填空题: 5.31 以下程序按逆序重新放置array数组中N个元素的值，array数组中的值由用户输入。
#include <stdio.h> #define N 10 main() { int array[N], i , *ps, *pe, temp; for( i=0; i<N; i++ ) scanf( "%d", array+【1】 ); for( ps=array, pe=array+N-1; ps<pe; ps++, 【2】) { temp=*ps; *ps=【3】; *pe=temp; } for( i=0; i<N; i++ ) printf( "%d ", array[i] ); printf( "\n" );

131 习题 5.32 以下程序中实现从主串 str 中取出一子串 sub，n 表示取出的起始位置，m 表示所取子串的字符个数，程序运行后输出 cdefg。 #include <stdio.h> main() { char str[100]="abcdefgh", sub[100], *p=str, *psub=sub; int n=3, m=5; for ( p=str+n-1; p<str+【4】; p++, psub++ ) *psub=*p; 【5】; puts(sub); }

132 习题 5.33 以下程序用来输出字符串. #include <stdio.h> main() {
char *a[]={ "for", "switch", "if", "while" }; char **p; for( p=a; p<a+4; p++ ) printf( "%s\n", 【6】 ); }

133 习题 5.34 以下程序功能是当输入学生序号(1 或 2 或 3)后，能输出该学生的全部成绩（共有三位学生，每位学生有 4 门成绩）。
#include <stdio.h> main() { float score[][4] = { {60,70,80,90}, {56,89,67,88}, {34,78,90,66} }; float (*p)[4]; int n,i; p = 【7】; scanf( "%d", &n ); printf( "序号为%d 的学生成绩是：", n ); for( i=0; i<4; i++ ) printf( "%5.1f", p【8】 ); }

134 习题 5.35 下列程序 fun 函数实现从字符串 str 中取出连续的数字做为一个正整数，依次存放到 a 数组中，并统计共存放了多少个正整数n。下面程序将输出： 。 #include <stdio.h> main() { char s[255]="ab123 x456,xy16639ghks7890# zxy", *p; int n=0, a[255], i, is=0; /* is 用于判定*p是否为‘1’...‘9’之间的字符, 是则is=1,否is=0 */ for ( p=s; p<s+strlen(s); p++) { if ( !is && *p>='0' && *p<='9' ) { is = 1; 【9】; a[n-1] = 0; }

135 习题 if ( is && ( *p<'0' ||【10】) ) is = 0;
if ( is ) a[n-1] = a[n-1]*10 + *p - 【11】; } for ( i=0; i<n; i++) printf("%d ", a[i]); printf("\n");

136 习题 5.36 以下程序统计字符串 s 中元音字母(a,A,e,E,i,I,o,O,u,U)的个数。
#include <stdio.h> main() { char str[255], a[]="aAeEiIoOuU", *p, *s=str; int n=0; gets(str); while( *s ) { for( p=a; *p; p++) if(【12】) { n++; break; } 【13】; printf( "字符串中元音字母的个数为：%d\n", n) ;}

137 习题 三、编写程序（ 要求用指针方法完成 ） 5.37 输入 10 个整数，找出其中最大数和次最大数。
5.38 编写程序，交换数组a和数组b中的对应元素。 5.39 有10个数围成一圈，求出相邻三个数之和的最小值。 5.40 M个人围成一圈，顺序排号，从第一个人开始报数（从1到N报数），凡报到N的人就从圈里出来；然后再从下一个人开始报数，直到只剩一个人为止。输出从圈里出来人的序号。 5.41 产生动态数组，输入数组大小后，通过动态分配内存函数ma1loc产生数组。 5.42 编写程序，复制字符串。 5.43 编写程序，连接两个字符串。 5.44 编写程序，将一个字符串反向存放。 5.45 编写程序，求字符串的长度。 5.46 输入一串英文文字，统计其中每个字母（不区分大小写）的数目。 5.47 由键盘输入的两个高精度正整数（不超过230位）,求它们的和（精确值）。 5.48 对一个长度为n的字符串从其第k个字符起，删去m个字符，组成长度为n-m的新字符串，并输出处理后的字符串。

138 习题 5.49 编写程序，输入两个字符串str与substr，删除主字串 str 中的 所有子字串 substr。
5.50 编写程序，实现在字符串sl中的指定位置第k个字符处插入字 符串s2。 5.51 找出一个二维数组中的鞍点，即该位置上的元素在该行上最 大，在该列上最小。有可能没有鞍点。 5.52 输入n个字符串，用指向指针的指针的方法按从大到小的顺 序排列后输出。 5.53 输入n行英文字，对其进行一项英文语法检查，把每个英文 句子的第一个字母改为大写。假设每个英文句子可分别由标点符 号 '.'、'!' 或 '?' 结束。 5.54 将n个学生的数据包括学号、姓名、三门课成绩及总分放在一个结构体数组中，用指向指针的指针的方法，按三门课的总分从小到大的顺序排列后输出每个学生的数据。 5.55 桥牌使用52张扑克牌，编写一个模拟人工洗牌的程序，将 洗好的牌分别发给四个人。