高级语言程序设计(C语言)习题答案及详解

2023年11月24日发(作者：布加迪威龙标志)

1.1 单项选择题

1.二进制语言是属于（ ）

①面向机器语言 ②面向问题语言 ③面向过程语言 ④面向汇编语言

「解」人们研制了许许多多计算机程序设计语言，其中二进制语言直接来自计算机的指

令系统，与具体计算机紧密相关，所以是一种面向机器语言。面向问题语言是为了易于描述

和求解某类特定领域的问题而专门设计的一种非过程语言。面向过程语言是一种能方便描述

算法过程的计算机程序设计语言。有汇编语言，但没有面向汇编语言。汇编语言也是一种面

向机器的语言，与机器语言比较，汇编语言用有助于记忆的符号来代表二进制代码。所以解

答是①。

2.下列语言中不属于面向过程的语言是（ ）

①高级语言 ②低级语言 ③C语言 ④PASCAL语言

「解」 C语言和 PASCAL等程序设计语言都是高级语言，它们用于描述复杂加工的

处理过程，所以也称它们是面向过程语言。低级语言是指机器语言和汇编语言，低级语言是

面向机器的语言，而不是面向问题的语言。所以解答是②。

3.下列字符中属于键盘符号的是（ ）

① ②n ③ t ④ b

「解」键盘符号是指键盘上有标记，并能在显示器上直接以其标记字样显示的字符。有

许多键盘上有标记的符号，它们不是用于直接显示的，键入这种字符用于表示特定的意义，

如常用的回车符。为了能让C程序标记这种符号，程序采用转义字符的方式书写这种字符。

如\'n\'、\'t\' 、\'b\'都不是键盘字符，在 C语言中，它们都得用转义字符来表达。只有字符

才是键盘字符。所以解答是①。但在C程序中，反斜杠字符已特别用作转义字符的引导

符，它也得用转义字符的表达形式书写，将它写成‘’。

4.下列字符列中，不是用来表达转义字符是（ ）

① ②\' ③074 ④ 0

「解」转义字符有三种书写形式：反斜社字符后接上某个规定的字符；反斜杠字符后接

上13个八进制数字符；反斜社字符和字符X之后接上1至2个十六进制数字符。后两种

分别八进制数和十六进制数直接给出字符的ASCll代码值。而074是八进制整数，不是转

义字。所以解答是③。

5.不是C语言提供的合法关键字是（）

①switch ②begin ③case ④default

「解」因C语言的关键字表中没有begin，它不是C语言的关键字。所以解答是②。

6.下列字符列中，能作为单个标识符是（）l

①？ a ② a＝2 ③a.3 ④ a___3

「解」在C语言中，规定标识符是这样一种字符序列，由英文字母或下线字符开始，

后接任1个英文字母、下线字符和数字符组成。所以问题所列的字符列只有a＿3是标识符，

其余都l是标识符，一个是由字符‘？’开头、一个中间有字符‘＝’，另一个有字符‘。’。所以

解答是④。

7.在C语言中，下列说法中错误的是（）

①函数定义可以分为两个部分：函数说明部分和函数体

②主函数可以调用任何非主函数

③任何非主函数可以调用其它任何非主函数

④程序可以从任何函数开始执行

「解」每个C函数的定义分两部分，函数说明部分和函数体，所以叙述 ①是正确的叙

述。C语言中，函数可以递归调用，主函数可以调用程序中的任何函数，当然可以调用任何

非主教的其它函数，所以叙述②是一个正确的叙述。同样理由，叙述③也是正确的。C语言

规，C程序只有一个主函数，并总是从主函数开始执行，不能从非主函数开始执行。所以，

说程可以从任何函数开始执行是错误的。所以解答是④。

1.2 填充题

1.汇编语言属于面向________语言，高级语言属于面向________语言。

「解」汇编语言与具体计算机密切有关，是属于面向机器的语言；而高级语言用来描述

求解题的算法，所以是面向过程的语言。所以解答是：面向机器和面向过程。

2.用高级语言编写的程序称为________程序，它可以通过________程序翻译一句

执一句的方式执行，也可以通过________程序一次翻译产生________程序，然后执行。

「解」用高级语言编写的程序称为源程序，源程序不能在计算机上直接运行，运行源程

序有种方式：一种是通过解释程序，对源程序逐句解释执行；另一种是先让编译程序将源程

序一翻译产生目标程序（目标程序是计算机可直接执行的机器语言程序，它是一种二进制代

码程），然后执行目标程序。

3.转义字符是由________符号开始，后接单个字符或若干字符组成。

4.C语言词类主要分为____、_____、_____和_____等。

「解」语言的基本词汇是指直接由字符序列组成，有确定意义的最基本单位，所以C

语言词汇有：字面形式常量。特殊符号（主要是运算符）、保留字和标识符等四类。而表达

式、函数调用等是更高级的语言成分，如表达式中还可分运算分量和运算符等；函数调用也

是一种表达式，它有函数名标识符、圆括号和实际参数表等。利用基本词汇，按照给定的C

语言的句法规则，就可命名程序对象，描述表达式计算、构造语句、函数，直至整个程序。

5.C语言的语句主要分为_____语句、_____语句、_____语句_____语句、______语

句和_____语句等。

「解」C语言有多种不同功能的语句，有用于定义数据的，有用于各种存储和计算的，

有用于程序流程控制的，有多种分类方法。C语言的语句主要有：数据定义语句、表达式语

句、流程控制语句、复合语句、空语句和其它语句。程序中经常使用的赋值表达式语句和函

数调用表达式语句都是典型的表达式语句。

6.C程序是由函数构成的。其中有并且只能有_____个主函数。C语言程序的执行总

是由_____函数开始，并且在_____函数中结束（如别的函数未调用终止程序执行的库函

数）

「解」C程序是由若干函数构成的。其中有并且只能有1个主函数（用main命名）。

C程序的执行总是由主函数开始执行，通常在主函数中结束（如没有在别的函数中调用终止

程序执行的库函数的话）。

7.C语言程序的注释可以出现在程序中的任何地方，一个注释以双符号作为开始标记，

以双符号_____作为结束标记。

「解」C语言程序的注释可以出现在程序基本单词之间的任何地方， C语言程序的注

释以双符号‘／。非为开始标记，并以双符号’。／‘作为结束标记。

2.1 单项选择题

1.下列字符列中，可以作为“字符串常量”的是（ ）

① ABC ② ABC“ ③‘abc’ ④‘a’

「解」C程序中，一个字符率常量是表示一个字符序列，书写时，用双引号字符前后括

住这个字符序列。所以只有“ABC”是一个正确的字符率常量，其余都不是。其中，ABC可

作为标识符，字符列‘abc’不能出现在C程序中，‘a’是一个字符常量。所以解答是②。

2.在以字节存储字符的系统中，‘n ’在内存占用的字节数是（ ）

①1 ②2 ③3 ④4

「解」一般来说，一个字符在内存中只占1个字节，‘n’是转义字符，其意义是换行符，

它作为一个字符存储，在内存也只占五个字节。所以解答是①。

3.字符串“XyZ”在内存占用的字节数是（ ）

①3 ②4 ③6 ④8

「解」字符串中的每个字符占1个字节，但C程序在存储字符串时，要在最后一个有

效字符后面接上 1个字符串结束的标记符‘0’。这样，存储字符串常量“xyZ”需要 4个字

节。所以解答是②。

4.在以下字符列中，合法的长整型常数是（ ）

① OL ② 4962710 ③ 0.054838743 ④ 2.1869el0

「解」为表示不同范围的整数，整型数据分短整型、基本型和长整型，并对三种整型内

部表示的最高位的不同理解，又分别分成无符号和带符号两种。若要明确指明一个整数是长

整型的，必须在整数之后接上字符‘L’。所以OL是一个长整型的整型常量，而4962710是

基本整型数据，而对于用2个字节表示一个基本整型数据的系统来说，该整数将因超出范

围而是一个错误的整数；0.054839743和2.1869el0都是double型的实数。所以解答

是①。

5.一个char型数据，它的值在内存中存放的是（）

①ASCll代码值 ②BCD代码值 ③内码值 ④十进制代码值

「解」计算机存储字符，通常是存储字符的某种代码值。有许多种字符编码的方法，最

流行的是ASCII代码。在C语言中，Char型数据也用ASCII代码表示。所以解答是①。

6.设变量 m，n，a，b，c，d均为以执行（m＝a＝＝）||（n＝c＝＝d）后，m，n

的值是（ ）

①0，0 ②0，1 ③l，0 ④1，1

「解」计算（m＝a＝＝b）||（n=c==d）的过程是先计算逻辑或的左运算分量（m=a==b）

的值，由于赋位运算符的优先级比关系运算符==的优先级低，又先计算 a==b.因 a，b

均为0后，所以比较结果值为1.将1赋给变量m，使变量m的值变为1 .同时这个赋值运

算的结果也是1，这样逻辑运算的左运算分量的值为1.由于逻辑或运算的左运算分量值为1，

按照C语言对逻辑或运算优化计算的规定，不再计算逻辑或的右运算分量，而直接得到逻

辑或运算的结果为1 .由于逻辑或的右运算分量不曾计算过，所以变量n的值也不为变化。

这样，上述表达式计算后，变量m的情为1，变量n的值为0.所以解答是③。

7.设a为5，执行下列计算后，b的值不为2的是（ ）

① b＝a／2 ② b＝6-（——a） ③ b＝a％2 ④ b＝a＜3？3：2

「解」因两个整型数据相除，结果是整数，当a的值为5时，计算表达式b=a／2后，

使b的值为2.计算表达式b＝6-（——a）是先计算子表达式（——a）的，先让a的值减

1变成4，并以减1后的a为子表达式的结果，所以子表达式的结果为4，最后使b的值为

2.在计算表达式b= a%2时，求余运算a％2的结果为1，最后使变量b的值为1.计算表

达式b＝a＜3？3：2时，先计算条件表达式a＜3？3：2，以2为结果，最后也使变量b

的值为人所以解答是③。

8.执行语句“x＝（a＝3，b＝a—－）；”后，X，a，b的值依次为（ ）

①3，3，2 ②2，3，2 ③3，2，3 ④2，3，3

「解」计算表达式x＝（a=3，b=a——）时，先计算赋值号右端圆括号内的逗号表达

式。远号表达式要求各子表达式顺序计算，并以最后予表达式的值为整个逗号表达式的结果。

所以该表达式计算时，先让变量a的值为3，a——的值是a当时的值，以该值为结果赋给

变量b，并以该值为远号表达式的值赋给变量x，然后a的值被减少1.所以计算该表达式

后，使变量x，a，b的值依次为3，2，3.所以解答是③。

9.设整型变量m，n，a，b，c，d均为1，执行“（ m＝a>b）＆＆（n＝a＞b）”后m，

n的值是（ ）

①0，0 ②0，l ③1，0 ④1 ，l

「解」表达式（m＝a ＞b）＆＆（n＝a ＞b）是一个逻辑表达式，它的计算过程是

先计算逻辑与的左分量（m＝a＞b，其中又是先计算a＞b.因a＞b不成立，结果为0，将

0赋给变量m，最后逻辑与的左分量结果为0.由于逻辑运算采用特别的优化计算规则，当

逻辑与的左分量结果为0时，不再计算逻辑与的右分量，而直接以0为逻辑与的结果。所

以，上述表达式计算使m的值变为0，而n的值没有变，依旧为l.所以解答是②。

10，设有代码“int a＝3；”，则执行了语句“a+=a-= a*a；”后，变量a的值是（ ）

①3 ② 0 ③ 9 ④ -12

「解」由于赋值运算符的结合性自右至左，语句“a+=a-=a*a；”的执行是先计算a*a，

得到值 9，再计算 a－＝a*a，使 a的值为-6，接着计算 a＋＝a，使 a的值为-12.所以

解答是④。

11.在以下一组运算符中，优先级最高的运算符是（ ）

①＜＝ ②＝ ③% ④＆＆

「解」常规运算符的优先级自高到低的排列顺序是算术运算符、移位运算符、关系运算

符。按位运算符、逻辑运算符、条件运算符、赋值运算符、逗号运算符。所以问题所给的四

个运算符按优先级自高到低的排列顺序是％，＜＝，＆＆，＝。所以解答是③。

12.设整型变量i的值为3，则计算表达式i——i后表达式的值为（ ）

①0 ②l ③2 ④表达式出错

「解」有些运算符只有一个字符，也有许多运算符由两个字符组成。特别是有些字符既

可是单个字符的运算符，又能组成双字符的运算符。编译系统在识别源程序时，通常是尽量

多地读八字符，能组成多字符单词的先尽量组成多字符单词。所以表达式i——i，被编译器

理解为（i——）-i.另外，当表达式中某变量有后缀自增和自减运算时，先按变量的原值计

算表达式，然后再对变量进行自增和自减运算。同样地，当表达式中某变量有前缀自增和自

减运算时，先对变量进行自增和自减运算，然后再按变量的新值计算表达式。按这个约定，

求表达式（i——）-i是计算i－i的值为0，然后再对i作自减运算。这样，表达式（i——）

-i的值为0.所以解答是①。

13.设整型变量 a、b、c均为2，表达式 a+++b+++c++ 的结果是（ ）

①6 ②9 ③8 ④表达式出错

「解」与上一小题解答的理由相同，表达式a+++b+++c++被系统理解成：（（a++）

+（b++））+c++）。表达式“变量++”的值是变量的原来值，所以在变量a、b.c均为2

的前题下，执行上述表达式，得到结果为6.所以解答是①。

14.若已定义 x和 y为double类型，则表达式： x＝l， y＝x＋3／2结果是（ ）

①l ②2 ③2.0 ④2.5

「解」由于变量x和y都是double类型，表达式 x＝l， y＝x＋3／2是先计算 x＝

1，由于 1是整型的，x是double类型的，该计算先将整数1转换成double类型的1.0，

并将1.0赋给变量x.计算 y＝X＋3／2是先求 3／2的值，因是两整数相除，结果是整型

值 1，然后在计算 X＋1时，也先将 1转换成 1.0，然后求得 X＋l的值为2.0，最后将

该值赋给变量 y，并得到整个表达式的值为2.0.所以解答是③。

15.设a=1，b=2，c＝3，d＝4则表达式a＜ b？a：c＜ d？a：d的结果为（）

①4 ②3 ③2 ④1

「解」条件运算符的优先级比关系运算符的优先级低，并且它的结合性是自右向左的，

所以表达式a＜b？a：c＜d？a：d可用圆括号等价地写成（a＜b？a：（（c）？A：

D）。因A＜B成立，计算结果为A的值1.所以解答是④。

16.设a为整型变量，下列C表达式中，不能表达数学关系式：10＜a＜15的是（ ）

①10＜a＜15 ②a＝＝11||a＝＝12|| a＝＝13|| a＝＝14

③a＞10＆＆a＜15 ④！（a＜＝10）＆＆！（a＞=15）

「解」数学关系式 10＜a＜ 15表示。只能是 11， 12， 13， 14四个值之 l.

用 C表达式表示这个条件，可写成a＞10＆＆ a＜15，或！（a＜＝10）&&！（a

＞=15），或a＝＝11||a＝＝12 || a==13||a＝＝14等。若写成10＜a＜15，该算式

的计算顺序是先求出10＜a的结果0或1，然后以这个结果与15比较，是否小于15，显

然这与数学式子的意义是不一致的。所以解答是①。

17.下列表达式中，正确的C赋值表达式是（ ）

①a＝7＋b＋C＝a＋7 ② C＝7＋b＋＋＝a＋7

③a＝（7＋b， b＋＋， a＋7） ④ a＝ 7＋b， c＝a＋7

「解」赋值运算符是运算符之一，赋值运算也可以出现在一般表达式中。赋值运算时，

出现在赋值运算符左边的表达式应该是引用一个存储对象，例如变量。不可以是一个数值计

算表达式。如表达式a＝7＋b＋c＝a＋7因算术运算符比赋值运算符的优先级高，要把a

＋7的结果赋给7＋b＋c，这是错误的。同样理由，表达式a＝ 7＋b＋＋＝a＋7也是错误

的。而表达式a＝（7＋b，b＋＋，a＋7）就是正确的赋值表达式，它是先计算赋值号左边

的括号内的表达式，括号表达式内是一个逗号表达式，远号表达式要求顺序逐一计算各子表

达式，并以最后一个子表达式的值作为远号表达式的结果，最后将该结果赋给变量a.而表

达式a＝7＋b，c＝a＋7则不是一个赋值表达式，而是一个逗号表达式，它由两个赋值子

表达式组成。所以解答是③。

18.若有以下定义： char a；int b；float c； double d；则表达式a*b+d-c值的类型

为（ ）

①float ② int ③ char ④ double

「解」基本类型的数据可以混合运算，但运算时，对要求运算分量类型相同的运算来说，

如运算分量的类型不是全相同，则会有自动类型转换发生。类型自动转换规则规定类型低（简

单）的向类型高（复杂）的转换。各类型由高到低的排列顺序是：long double、float、

unsigned long、long、unsigned int、int这样，若有定义： char a； int b；float c；

double d；则表达式a*b+d-c的值的类型是double的。首先计算 a*b，得到int类型

的值，接着计算a*b+d，得到double类型的值，最后计算a*b+d-c，得到double类型

的值。所以解答是④。

19.表达式“9！=7”的值是（ ）

①true ②非0值 ③0 ④1

「解」关系运算的结果只有0和1，若关系成立，则结果为1；若关系不成立，则结果

为0.因关系式9！＝7成立，所以表达式的结果为1.虽然1也是非0值，在供选择的答案

中有1，所以最确切的解答是④。

20.用十进制数表示表达式“12|012”的运算结果是（ ）

①1 ②0 ③ 14 ④ 16

「解」按位运算将运算分量视作二进位的位申信息，对两运算分量的对应位进行运算，

产生H进位的位串信息结果。整数12最低8位二进位是00001100，整数012是八进制

数，它的最低8位二进位是00001010.这两个二进位位串信息按位或运算，得到结果是

00001110，对应十进制数14，八进制数是016.所以解答是③。

21.设字符型变量 a＝3，b＝6，计算表达式 C＝（a＾b）＜＜ 2后C的二进制值是

（ ）

① 00011100 ②00000111 ③ 00000001 ④ 00010100

「解」a的值为3，写成8位二进制数形式是00000011，b的值为6，写成8位二

进制数形式是00000110.表达式c＝（a＾b）<<2，先计算a与b的按位加，得到结果

00000101，将这结果向左移2位，得到二进位的位串信息是00010100.所以解答是④。

22.设 a，b和 c都是int型变量，且a＝3，b＝4，c＝5，则下面的表达式中值为 0

的是（ ）

①‘a’＆＆b‘ ②a＜＝b ③a||b+c＆＆b－c ④！（（a）＆＆！||1）

「解」对于表达式‘a’＆＆‘b，两个非O运算分量的逻辑与结果为1.对于表达式a＜＝b，

由于关系式成立，结果也为此又由于变量 a为非 0，表达式a||b+c＆＆b－c的结果也为

1.对于表达式！（（a＜b）＆＆！c||1），先是计算（a＜b）得到结果1；计算！C得到

结果为0；再计算它们的逻辑与，结果为0.继续与1求逻辑或，得到结果为1.最后，对1

求逻辑非，得到结果为0.所以解答是①。

23.设Ch是Char型变量，其值为‘A’，则下面表达式的值是（ ）

ch＝（ch＞＝‘A’＆＆ch＜＝‘Z’）？（ch＋32）：ch

①‘A’ ②‘a’ ③‘Z’ ④‘z’

「解」由于字符型变量ch的值为‘ A’，计算表达式ch＝h＞＝‘ A’＆＆ch＜＝‘ Z’）？

（ch＋32）：ch，先计算其中条件表达式，由于条件（ch＞＝‘A＆＆h＜＝’Z‘）成立，该

条件表达式以 ch＋32＝97为结果，将该值赋给变量 ch，以字符表达这个值为’a‘。所以

解答是②。

24. 设有无符号短整型变量i、j、k，i值为013，j值为 OX13.计算表达式“k＝～i|j

＞＞ 3”后，k的值是（ ）

① 06 ② 0177776 ③ 066 ④ 0177766

「解」将变量 i的八进制数值 013写成二进制形式为00001011，将变量j的十六进

制值 oxl3写成二进制数形式为00010011.表达式k＝～i|j＞＞3的计算过程是先求～i，

结果用八进制代码表示为0177764；接着计算j＞＞3，结果为02.对它们进行按位或运算

结果为0177766.所以解答是④。

2.2 填充题

1.在内存中，存储字符串“X”要占用______个字节，存储字符‘X’要占用_____个字节。

「解」计算机存储一个字符用1个字节，存储字符串时，每个字符要占用1个字节，

另在字符串的有效字符之后存储1个字符串的结束标记符。所以存储字符率“X‘要占用2个

字节，存储字符’X‘只要1个字节。

2.在C程序中，判逻辑值时，用_____表示逻辑值“真”，又用_____表示逻辑值‘假“。

在求逻辑值时，用_____表示逻辑表达式值为”真“，又用_____表示逻辑表达式值为”假“。

「解」在C程序中，判逻辑值时，用非0值表示真；而判逻辑值时，用值0表示假。

但逻辑表达式计算结果，逻辑表达式值为真是用1表示的，而逻辑表达式的值为假，则用0

表示。

3.定义符号常量的一般形式是_____.

「解」定义符号常量用预处理命令的宏定义，其定义的一般形式是：

＃define符号常量名 常量

4.在函数内，说明变量时，若省略存储类型符，系统默认其为_____存储类别，该存储类

别的类型符为_____.

「解」在函数内，说明变量时，若省略存储类型符，系统就默认其为自动存储类别，该

存储类别用auto标识。

5.无符号基本整型的数据类型符为＿，双精度实型数据类型符为＿，字符型数据类型符

为，。

「解」无符号的基本整型的类型符为unsigned int，或简写成unsigned.双精度实型

数据类型符为double，字符型数据类型符为char.

6.定义指定数据类型的变量时，较完整的一般形式是＿。

「解」要指定变量的存储类型，定义指定类型的变量，其一般形式是：存储类型符数据

类型符变量名1，变量名2，……；

7.设有下列运算符：＜＜、＋、＋＋、＆＆、＜＝，其中优先级最高的是_____，优

先级最低的是_____.

「解」对运算符＜＜、＋、＋＋、＆＆、＜＝，按它们的优先级自高到低的顺序排列为：

＋＋、＋、＜＜、＜＝、＆＆所以，优先级最高的是++，优先级最低的是＆＆。

8.设二进制数A是0A101111，若想通过异或运算 A＾B使 A的高4位取反，低4

位不变，则二进制数B应______.

「解」按位加运算的一个重要应用是让某个整型变量的二进位位串信息的某些位信息反

向，0变成1，而1变成0. 这只要设计这样一个位串信息，让要变反的位为1，不要改变

的位为0，用这个位串信息与整型变量按位加就能得到希望的结果。要使字节的高4位取反，

低4位不变，则需要位串信息是11110000，写成八进制数是0360，写成十六进制数为

0xF0.

9.设a＝3， b= 2，C＝l，则 C＞b的值为______.，a＞ b＞ C的值为______.

「解」因a的值为3，b的值是2，条件a＞h为真，其值为1.表达式a＞b＞c的求值

顺序是计算a＞b，结果为1，接着计算1＞c，因c的值为1，条件1＞c为假，结果为0.

10.老已知a＝10，b＝20，则表达式！a＜b的值为_____.

「解」计算表达式！a＜b，先计算！a ，因a的值为1O，！a 的值为0.关系表达式

0＜20为真，所以表达式！a＜b的值为1.

11.设X和y均为 int型变量，且X＝l，y＝2，则表达式 1.0＋x／y的值为_____.

解」计算表达式 1.0＋x／y，先求 x／y，因 x和 y是整型变量，其中的除运算是整

除， 1／2的结果为0.接着计算1.0＋0，计算时，先将右分量转换成0.0，最后得到结果

1.0.

12.设整型变量 X、y、Z均为 5：

①执“x－＝y－x”后，x＝__________，

②执行“x％＝y＋z”后，x_____________.

③执行“X＝（y＞Z）？X＋2：X－2，3，2后，X＝____________.

「解」在变量x、y、z的值均为5的情况下，计算各表达式。由于表达式x－＝y－z

等价于表达式X＝X－（y－Z），所以计算后X的值为5.表达式X%=y＋Z等价于表达式

X＝X%（y＋z），所以计算后x的值也为5.表达式x＝（y＞z）？ x＋2： x－2，3，2

的计算过程用圆括号描述其计算顺序是：

（（X=（y＞Z）？X＋2：X－2），3），2

即这是一个逗号运算表达式，由一个赋值表达式和两个数值构成，逗号表达式要求顺序

求各子表达式的值。表达式X＝（y＞Z）？ X＋2：X－2的计算是先求赋值号右边的条件

表达式，因条件（y＞z）为假，求出X－2的值为3，将该值赋给变量X，使X的值为3.

13.能表述“20＜ X＜ 30或 X＜－100”的 C语言表达式是_____.

「解」首先表述20＜x＜30的C表达式可写成20＜x＆＆x＜30.所以表述“20＜x＜

30或x＜-100”的 C表达式为 20＜X ＆＆ X＜ 30||X＜－100.

14，请写出数学式x/y*z的C语言表达式_______.

「解」数学式子表述的是x除以y乘z的积，写成C表达式可以写为x／（y*z），或

可等价地写成x／y／Z.

15.C语言中运算结果可以当成逻辑值使用的表达式有：_____表达式、_______.表

达式、________表达式、____________表达式、_________表达式、________表

达式。

「解」在C语言中，逻辑判断以非0值为真，以0值为假。所以，几乎所有的表达式

的运算结果都可以当成逻辑值使用，如算术表达式、关系表达式、逻辑表达式、赋值表达式、

逗号表达式、条件表达式等。

3.1 单项选择题

1.设 a＝3，b＝4执厅‘printf（“％d，％d’，（a，b），（b，a））；”的输出是（ ）

①3，4 ②4，3 ③3， 3 ④4，4

「解」在调用格式输出函数的语句中，其中每个格式符对应一个输出项，格式符d要

求输出项内容以十进制整数形式输出。第一个输出项（a，b）是一个逗号表达式，该表达

式的值是b的值，输出4.接着输出字符逗号。第二个输出项（b，a）的值是a的值，输出

3.所以语句执行将输出4，3.正解的选择是③。

2.使用“Scanf（”X=%f，y＝%f“，＆x，&y）”，要使 X，y均为1.25，正确的输入是（ ）

①1.25，1.25 ②1.25 1.25 ③x＝1.25，y＝1.25 ④X＝1.25 y＝1.25

「解」格式输入函数的格式字符串中的字符可以分成三类：空格类字符、其它普通字符

和格式转换说明。其中空格类字符用来跳过一个空格类字符序列，直至下一个非空格类字符。

普通字符要求输入字符与其完全相同。格式转换说明对输入字符列按格式转换说明进行转换，

得到内部值存储到对应输入项所指定的存储位置中。函数调用scanf（“x＝%f，y=%f，

＆x，&y）以普通字符X=开头，输入时也要先输入X＝。接着是一个浮点数输入格式，所

有能构成一个浮点数1.25的字符序列都能满足要求。接着是普通字符列”，y＝“，在输入

的浮点数之后也要有字符列”，y＝“。最后又是浮点数输入格式，同样所有能构成一个浮点

数1.25的字符序列都能满足要求。问题给出的供选择答案中只有x=1.25，y＝1.25是能

满足上述要求的。所以正确选择是③。

3.设有int i＝010，j=10；则执行“printf（”%d，%d＼n“，++i，j——）；”的输

出是（ ）

①ll， 10 ② 9，10 ③ 010， 9 ④ 10， 9

「解」变量i和j的初值分别为八进制数010和十进制数 10，函数调用Printf（“%d，%d

＼n”，++i，j——）中，++i的值是变量 i增1后的值，原来值是八进制数 010，等于

十进制数8，输出9.j——的值是变量j减1之前的值，输出10.格式字符申中的逗号是普

通字符照原样输出。所以问题给出的格式输出函数调用将输出9，10.正确的解答是②。

4.设a，b为字符型变量，执行“scanf（”a＝%c，b＝%c“，&a，&b）”后使a为‘A’，

b为‘B’，从键盘上的正确输入是（ ）

①‘A“B’ ②‘A’，‘B’ ③A＝A，B＝B ④a=A b＝B

「解」函数调用scanf（“c＝%c，b＝%c”，&c，&b）中，普通字符必须按格式字符

串要求照原样输入，c格式对紧接的任何字符都输入。所以实现问题的要求，输入字符列应

为“a＝A，b＝B”。另外要特别指出，在程序中，为表示字符常量，字符前后需加单引号。

但用字符格式输入字符时，在要输入字符前后不必另键人单引号。若键人单引号，则这个单

引号也将作为字符被输入。正确的解答是④。

5.设X、y、Z、t均为int型变量，则执行以下语句后，t的值为（ ）

x＝y＝z＝1；t＝++x||++y＆＆++z；

①不定值 ②2 ③l ④0

「解」语句序列“x＝y＝z＝l；t＝++x||++y&&++z；”使变量x的值为1，变量t

是赋一个逻辑表达式的值。在C语言中，由逻辑与和逻辑或构成的逻辑表达式有特别的计

算规则，顺序计算各逻辑子表达式，并当一旦能得到逻辑表达式的结果时，就立即结束逻辑

表达式的计算，不再计算后继逻辑子表达式。本题的逻辑表达式是两个运算分量的逻辑或，

而且左运算分量++X的值为非0，立即得到逻辑或运算的结果为1，并将1赋给变量t，

所以变量t的值为1.正确解答为③。

6设x、y、z均为int型变量，则执行以下语句后，x、y， z的值为（ ）

X＝1； y＝0； Z＝2； y＋＋＆＆＋＋Z ||++ X；

①2、l、3 ②2、0、3 ③2、l、3 ④2、1、2

「解」语句序列“x＝l；y＝0；z＝2； y++&&++z||++x；”先使变量x的值为 1，

变量y的值为0，变量Z的值为2.由逻辑与和逻辑或构成的逻辑表达式的特别计算规则，

顺序计算各逻辑子表达式，并当一旦能得到逻辑子表达式的结果时，就立即结束逻辑子表达

式的计算，不再计算该逻辑子表达式。计算y++因y的值为0，使y++&&++z的结果为

0，立即去计算++X，这次计算使变量y的值变成1，而变量Z的值本改变。接着计算++X，

使X的值变为2.所以经上述语句执行后，X、y、Z的值依次为2、1、Z. 确解答为④。

7.假定所有变量均已正确定义，下列程序段运行后X的值是（ ）

a＝b＝c＝0； x＝35；

if（！a）x——； else if（b）；if（c）x＝3；else x=4；

①34 ② 4 ③ 35 ④ 3

「解」以变量 a，b，c的值均为 0，变量x的值为 35，语句：

if（！a）x——；else if（b）；if（c）x＝3；else x＝4；

由两个证语句组成。首先执行前一个if语句“if（！a）x——；else if（b）；”，因变

量a的值为0，条件！a成立，执行x——使x的值变为34.接着执行后继的if语句“if（c）

x＝3； else X＝4；”，因变量c的值为0，条件不成立而执行X＝4，最终使变量X的值

为4.正确解答是②。

注意前一个if语句的else部分的成分语句只有“if（b）；”，这是一个单分支if语句，

且其成分语句为空语句。

8.下面的程序段所表示的数学函数关系是（ ）

y＝－l；

if（ x！＝ 0）if（x＞0）y＝l； else y＝0 ；

1（x＜0） 1（x＜0）

① y＝ ｛ 0（x＝ 0） ② y＝{-l（X＝0）

1（X＞0） 0（X＞0）

o（X＜ 0） -l（X＜ 0）

③ y＝ ｛-1（x＝ 0） ④ y＝{ 1（X＝ 0）

1（X＞ 0） 0（X＞ 0）

「解」程序段首先置变量y的值为一l，接着按变量x值的不同情况重置变量y的值。

重置的首要条件是x！＝0，若变量x的值为0，则不再重置变量y的值，所以在X值为0

情况下，y的值是-l.在变量X的值不等于0的条件下，若X的值大于0，重置变量y的值

为1；若变量X的值小于0，重置变量y的值为0.所以程序段实现当变量x的值为0时，

变量y的值为-1；当变量X的值大于0时，置变量y的值为1；当变量X的值小于0时，

置变量y的值为0.正确解答为③。

9.下列语句中，句法错误的是（不考虑语义）（ ）

① while（x＝y）5 ； ② do x＋＋ while（x＝＝10） ；

③while（0）； ④do 2；while（a＝＝b）；

「解」 while语句的一般形式是：

while（表达式） 语句

这里的表达式可以是任何合理的表达式，语句可以是任何语句，包括空语句，或表达式

语句。可能书写的while语句没有任何意义，如供选择的①while（x＝y）5；和③while

（0）；，但这两个语句的句法没有任何错误。do-While语句的一般形式是：

do语句while（表达式）；

其中的成分语句也可以是任何语句，但供选择答案②do x＋＋while（x==10） ；中

的代码x++是一个表达式，不是语句，所以是错误的。正确解答是②。

10，循环语句“for（x＝0， y＝0；（y！=123）||（ x＜4）；x＋＋）；”的循环

执行（ ）

①无限次 ②不确定次 ③4次 ④3次

「解」for循环语句的初始化部分置变量x和y的初值为0，循环条件是（y！＝123）

||（x＜4），每次循环后变量X的值增1.由于循环过程中变量y的值本被修改过，循环条

件又是一个逻辑或，其左分量（y！＝123）永远成立，也就是循环条件永远成立。所以该

循环语句将循环执行无限次。正确解答是①。

11.若i、j已定义为int类型，则以下程序段中的内循环体的执行次数是（ ）

for（ i＝5； i； i——）

for（j＝ 0； j＜4；j＋＋）｛……｝

①20 ② 24 ③ 25 ④ 30

「解」问题所给的程序段的外循环是一个阶循环语句，它的初始化部分置变量i的初值

为5，循环条件简写成i，即i！＝0，每次循环后变量i的值减1.所以外循环共控制5次循

环。内循环也是一个for循环语句，它的初始化部分置变量j的初值为0，循环条件是j<4，

每次循环后变量j的值增1.所以内循环共控制4次循环。这样，如内循环的体内未曾对变

量i和j有修改，在内、外循环一起控制下，内循环的体共被重复执行20次。正确解答是

①。

12.假定a和b为int型变量，则执行以下语句后b的值为（ ）

a＝1； b＝10；

do b－＝a； a＋＋；

}while<（b——＜0）；

①9 ②-2 ③-1 ④8

「解」在这个程序段中，循环开始前变量a的值为1，b的值为10，每次循环从变量

b减去a，并让a增1，并在循环条件判定时，又让b减去1.第一次循环后，变量b的值

变成9，变量a的值变为2，循环判断时，因b的值大于0，循环条件不成立，结束循环。

但在循环判断时，让b减去了1，所以循环结束时，变量b的值为8.正确的解答是④。

13.设x和y为int型变量，则执行下面的循环后，y的值为（ ）

for（y＝l， x＝l； y＜＝50； y＋＋）{

if（x＞＝10） break；

if（x％2==1）｛ x＋＝5； continue；}

X －＝ 3；

}

①2 ②4 ③6 ④8

「解」 for循环语句的初始化部分置变量x和y的初值为1，循环条件是（y＜＝50），

每次循环后变量y的值增1，控制循环最多执行50次。循环体有三个语句：首先在发现变

量X的值大于等于10时，结束循环；接着是当变量X除2的余数为1（即变量X是奇数）

时，让变量X值增5，让X变成偶数，并直接进入下一轮循环；如变量X是偶数，则从变

量X减去3，让变量X变成奇数。由上述分析知，每两次循环使变量X的值增加2.第一次

循环后，变量X的值变成6.第二次循环后，变量X的值变成3.第三次循环后，变量X的

位变成8.第四次循环后，变量X的值变成5.第五次循环后，变量X的值变成 10.第六次循

环时，因变量X的位大于等于 10，直接跳出循环，这次循环是非正常结束，对变量y的修

正只执行了5次。所以循环结束后，变量y的值增至6.正确的解答是③。

14.在C语言中，下列说法中正确的是（ ）

①不能使用“do语句while（条件）”的循环

②“do语句While（条件）”的循环中必须使用“break”语句退出循环

③“do语句while（条件）”的循环中，当条件非0时将结束循环

④“do语句while（条件）”的循环中，当条件为0时将结束循环

「解」 do-while语句的一般形式是：

do语句

while（表达式）；

其语义是重复执行其成分语句，直至表示条件的表达式值为0时结束。do-while语句

是正常使用的一种循环结构之一。do-while语句的循环结束条件由while后的表达式值为

0所控制，并不一定要有break语句跳出循环来结束循环。do-while语句在条件值非0时，

将继续循环，而不是结束循环。条件值为0时，才结束循环。所以正确的选择是④。

15.若有以下程序段，W和k都是整型变量，则不能与该程序段等价的循环语句是（ ）

W＝ k；

LB： if（w＝＝0） gotO LE；

w - -；

printf（“*”）；

goto LB；

LE：

①for（w＝k；w！＝0；W——）printf（“*”）；

② w＝ k；

While（W——！＝0） Prinif（“* ”）；

③ w＝ k；

do{w——； prinif（“*”）；

｝ while（ W！＝ 0）；

④ for（w＝k；W；——W） printf（“*”）；

「解」问题所给出的程序段用goto语句构造一个循环控制结构，该循环结构的初值是

让变量W的值为k的值，循环结束条件是W的情等于0，循环体是让变量W的值减1，

并输出一个字符* .上述循环控制过程用for循环可描述如下：

for＝（w=k；W！＝0； W——） printh（“*”）；

或写成：

for（w＝k ；w；——w） printf（“*”）；

若用while语句，可描述如下：

W＝k；

while（w——！＝0）printf（“*”）；

w++；/*在w等于0时，也执行了一次 w——，这里是对w最后减1的补尝*/

或更直观地写成：

W＝k；

while（w！＝0）{ w——；Printf（“*”）；}

若用do-while语句，可描述如下：

W＝k；

if（W）

do{

w——； prinif（“*”）；

} while（w）；

若写成：

W＝k；

do｛

W——； printf（“*”）；

} while（w！=0）；

是不正确的，因为原代码当k的值为0时，不输出字符*，而上面的改写，当k的值为

0时，将输出许许多多的字符*.所以解答应是③。

3.2 填充题

1.结构化程序设计规定的三种基本结构是________结构，选择结构和______＿结构。

「解」结构化程序设计的三种基本控制结构是顺序结构、选择结构和循环结构。

2.若有定义“int a＝25，b＝14， c＝19；”，以下语句的执行结果是______.

if a＋＋＜＝25＆＆b——＜＝2＆＆c＋＋）

prinif（“***a＝％d，b＝％d，c＝％d＼n”， a，b，c）；

else printf（“###a＝％d，b＝％d，c＝％d＼n”， a， b，c）；

「解」问题所给的if语句中，条件a++＜＝25＆＆b——＜＝2＆＆c++是先求逻辑

与的第一个运算分量，它是一个关系式，关系成立。接着判定第二个逻辑与运算分量，又是

一个关系式，由于变量b的值是14，b不小于等于2，运算分量的关系式不成立，导致if

语句的条件为假，执行else部分。在求且语句的条件时，计算了2个逻辑与分量，使变量

a的值增了1，变量 b的值被减了1.所以输出内容是：＃＃＃a=26，b＝13，c＝19.

3.以下两条if语句可合并成一条if语句为_____________.

if（a＜＝b） x＝1；

else y＝2；

if（a＞b）printf（“****y=%dn” ，y）；

else printf（ “####x＝%dn” ，x）；

「解」在以上两条if语句中，两个条件刚巧相反。若将前一个if语句的第一个成分语

句与第二个if语句的第二个成分语句合并；第一个if语句的第二个成分语句与第二个if语

句的第一个成分语句合并，写成一条if语句如下：

if（a＜＝b）{x＝1；printf（“####x＝%dd，x）；}

else{ y＝2； printf（“****y＝%dn”，y）；}

4.设 i，j，k均为 int型变量，则执行完下面的for语句后，k的值为_______.

for（i=0，j＝10；i＜＝j；i＋＋，j——）k＝i＋j；

「解」该 for语句以i为0、j为10初始化，循环条件是 i＜＝j，每次循环后 i增 1、

j减 1，循环体是将 i与j的和赋给 k.这样变量 k将保存的是最后一次赋给它的值。一次

循环后 i为 l.j为 9，二次循环后 i为 2.j为 8，……，五次循环后 i为 5.j为 5，继续第

六次循环，将 i与 j的和10存于 k后，i为 6、j为 4，结束循环。所以循环执行后 k为

10.

5.下列程序的功能是输入一个整数，判断是不是素数，若为素数输出1，否则输出0，

请为程序填空。

main（）

{int i，X，y=1；

scanf（“％d”，＆x）；

for（i=2；i<=x/2；i++）

if________________ ｛ y=0； break； }

printf（“％d＼n”，y）；

}

「解」为判数x是否是素数，预置变量y的值为1（x可能是素数），然后用循环，用

2至x／2的整数i测试对X的整除性，若能被其中的某个整数整除，则X是合数，置y的

值为0（不是素数），结束测试循环。若都不能整除，则X为素数。i能否整除X，可用求

余运算X％i等于0来判定。所以程序中的空框可填 X％ i＝＝0.测试 X为素数的代码可写

成：

y＝l；

for（ i＝2； i＜＝x／2； i＋＋）

if（x％i＝＝0）{ y＝0； bleak； }

3.3 程序分析题

1.阅读程序，写出运行结果。

main（）

{ int a＝10， b＝4，C＝3；

if（a＜b）a＝b；

if（a＜C） a＝C；

printf（“％d，％d，％dn”， a，b，c）；

}

「解」程序中，第一个if语句if（a）A＝B，当A时，让B值置A，该语句确

保A的值不比B小。同样第二个IF语句IF（A＜C）A＝C，当A＜C时，让C值置A，使

A的值不比C小。实际；情况是A本来就比B和C都大，所以A的值没有变，程序输出A、

B和 C的原来值：10，4，3.

2.阅读下列程序，写出程序的输出结果。

main（）

{ int x=100， a＝10， b＝20， Ok1＝5，Ok2＝0；

if（a＜b）if（b！＝15）if（！Ok1） x＝1；

else if（ok2） x＝10；

else x＝-l；

printf（“％d＼n”，x）；

}

「解」程序预置变量x的值为100，a的值为10，b的值为20，ok1为5，Ok2为

0.

程序中给出的if语句可以写成更结构化的形式如下：

if（a＜b） {

if（b！＝15）｛

if（！Ok1） x＝1；

else{

if（Ok2） x＝10；

else x＝－l；

｝

}

}

由于条件a＜b成立，并且条件b！=15也成立，而ok1不等于0，执行else后的语

句。又因ok2等于0，执行else后的语句赋-1给x.所以程序输出一l.

3.阅读下列程序，写出程序的输出结果。

main（）

{ int y＝9；

for（； y＞0； y——）

if（y％3==0）{ printf（“％d”，——y）；continue；}

｝

「解」循环前，变量y的值为9，其中的循环语句在y大于0情况下循环，每次循环

后y的值减1.循环体是当y能被3整除时输出表达式——y，输出的是减1后的y值。这

样，第一次循环因y为9，能被3整除，输出8，y也变成8.又经两次循环，y的值变为6，

又让y减1变成5，并输出5；又经两次循环，y的值变成3，让y减至变成2，输出2；

再经两次循环后，y的值变成0，结束循环。所以程序输出852.

3.4 程序设计题

1.编一个程序，输入华氏温度（F），按下列公式计算并输出对应的摄氏温度（C）：C

＝ 5（ F－32）／9

「解」利用公式：C＝5（F－32）／9，输入F氏温度，计算并输出对应的C氏温度，

程序要引入两个变量，分别用于存储F氏温度和C氏温度，计算时应采用浮点型，包括公

式中的常数也应写成浮点数，不能采用整型和把常数写成整数。因采用整型编写，公式中的

除运算变成整除，会得出与实际要求不一致的结果。程序如下：

＃include

main（）

{ float f，c；/*变量定义*/

printf（“输入F氏温度”）；

scanf（“％f，＆f）；

c＝ 5.0*（f－32.0）／9.0；

printf（“对应的C氏温度％6.2f＼n”，c）；

}

2.编一个程序，输入一个整数，输出其符号（若≥0，输出1；若＜0输出-1）。

「解」程序可用if语句判断输入数的符号，并控制输出1或-l.程序如下：

＃ include

main（）

{ int c；／*变量定义*／

printf（“输入一个整数”）；

scanf（“ ％d”， ＆c）；

if（C＞＝0） printf（“1n”）；

else printf（“-ln”）；

}

3.编一个程序，输入X的值，按下列公式计算并输出y的值。

X（X≤l）

y＝ {2x－l（l＜x＜10）

3X-11（10≤X）

「解」输入x，按公式计算y.这可用一个嵌套的if语句分段判断并计算出y的值。然

后输出y值。程序如下：

＃ include＜stdio.h＞

main（）

{ int x，y；／*变量定义*／

printf（“输入一个整数”）；

scanf（“％d”，＆x）；

if（ x＜＝l） y＝X；

else if（x＜10）y＝2*x－l；

else y＝3*X－11；

printf（“y＝%d n”， y）；

}

4.编一个程序，输入三个单精度数，输出其中最小数。

「解」设最小数存于变量min中，为求三个数中的最小数，可分以下多步完成，先预

置min为x，然后分别将其余两个数逐一与min比较，当它们中的某个值比存于min中的

值更小时，就用它们更新min.写出程序如下：

＃ include

main（）

{ float X，y，Z，min；/*变量定义*/

printf（“输入三个单精度浮点数”）；

scanf（“%f%f%f”， &x，&y，&Z）；

min ＝x；

if（min>y） min＝ y；

if（min>Z） min＝Z；

printf（“浮点数%f，%f，%f中的最小值是%fn”，X，y，Z，min）；

}

5.编一个程序，求出所有各位数字的立方和等于1099的3位数。

「解」找出所有各位数字的立方和等于1l99的3位整数。 3位整数是100至999

范围内的整数，设分别用a，b，c存储3位数的百位、十位和个位的数字，程序用三重循

环求出a，b，c的立方和为1099的3位数a*100+b*10＋c.程序如下：

＃ include

main（）

{ int a，b， c；/*变量定义*/

for（a＝1； a<=9；a++）

for（b＝0； b<=9； b++）

for（c＝0；c<＝9；c++）

if（a*a*a+b*b*b+c*c*c==1099）

printf（“%dn”，（10*a＋b）*10＋c）；

}

若用一个变量i表示3位数，循环体将3位数变量i分拆出它的百位、十位和个位共3

个数字，然后判这三个数字的立方和是否是1099，若是就输出该变量的值。程序如下：

＃ include

main（）

{ int i，a，b， c；/*变量定义*/

for （i＝100；i<=999；i++） {

a＝i/100；

b＝（i0）/10； /*或b＝（i/10）%l0*/

c=i；

if（a*a*a+b*b*b+c*c*c==1099）

printf（“%dn”， i）；

}

}

6.编一个程序，输入10个整数，统计并输出其中正数、负数和零的个数。

「解」输入10个整数，统计其中正数、负数和零的个数。程序引入3个计数器变量，

用于统计大于以小于0和等于0的整数的个数。开始时，这3个计数器都置0，然后用循

环逐一输入10个整数，并判定当前输入的整数是大于0，或小于0，或等于0，并按判定

结果累加相应计数器。最后，程序输出这3个计数器的值。程序如下：

# include

main（）

{ int i，d，n，z，p；/*变量定义*/

n＝Z＝p＝0；

for（i＝1；i<=10；i++） {

print（“ 输入第%d个整数”， i）；

scanf（“%d”，&d）；

if（d<0）n++；

else if（d>0）p++；

else z++；

}

printf（“负数有%d个，正数有%d个，零有%d个。n”，n，p，z）；

}

7.编程序，按下列公式计算e的值（精度为1e－6）：

e＝1+1/1！+1/2！+1/3！+…+1/n！+…

「解」按e的幂级数展开式计算e的值。这是典型的求级数和计算问题。通常采用逐

项计算，并累计的方法。计算新的项时，可用上一轮循环计算出的项，这能提高程序的效率。

循环直至当前项的值小于精度要求结束。程序如下：

# include

main（）

{ double e，t，i；/*变量定义*/

e＝0.0；t=1.0；i＝1.0；

while（t>＝1.0e-6） {

e+＝t；

t/= i；

i+= 1.0；

}

printf（“e＝%.6fn”， e）；

}

8.编程序，按下列公式计算y的值（精度为1e－6）：

y=∑1/r*r+1

「解」按所给公式计算数列的和。类似上一小题的解，逐项计算并累计。程序如下：

# include

main（）

{ double y，r，t；/*变量定义*/

y＝0.0；r＝1.0；

while（（t=1.0/（r*r+1.0））>=1.0e-6） {

y+=t；

r+=1.0；

}

printf（“y=%.6fn”， y）；

}

9.编一个程序显示ASCII代码0x20至ox6f的十进制数值及其对应字符。

「解」显示ASCII代码为十六进制0x20至ox6f的字符的十进制代码值与其字符。

程序可用一个循环，让变量i顺序地取0X20至OX6f的值，并逐一输出其十进制代码和对

应的字符，程序如下：

# include

main（）

{ int i，k＝0；

for（i=0x20； i<=0x6f；i++） {

if（k++== O）/*每行十个*/

printf（“n”）；

printf（“=（%C）”， i，i）；

}

printf（“n”）；

}

10.用三种循环语句分别编写程序显示1至100的平方值。

「解」用三种循环语句分别编写显示1至100的平方值的程序。直接写出3个程序如

下：

（1） 用输循环实现的程序

# include

main（） /*用for循环*/

{ int i，k＝0；

for（i＝l；i<=100；i++） {

if（k++%5==0） /*每行五个*/

printf（“n”）；

printf（“=*=＝]”，i，i，i*i）；

}

printf（“n”）；

}

（2） 用while循环实现的程序

# include

main（） /*用 while循环*/

{ int i，k=0 ；

i=1；

while（<=100）{

if（k++%5==0）/*每行五个*/

printf（“n”）；

printf（“=*=＝]”， i，i，i*i）；

1++；

}

printf（“n”）；

}

（3） 用do-while循环实现的程序

# include

main（） /*用do-while循环*/

｛ int i， k＝0 ；

i=1；

do{

if（k++%5==0） /*每行五个*/

printf（“n”）；

printf（“=*=＝]”，i，i，i*i）；

1++；

} while（<=100）；

printf（“n”）；

}

4.1 单项选择题

1.若有下列说明，则数值为4的表达式是（ ）

int a[12]＝{ l，2，3，4，5，6，7，8，9，10，11，12 }；

char c＝‘a’，d， g；

①a[g－c] ②a[4]

③a[‘d’-‘c’] ④a[‘d’-c]

「解」数组元素的下标自0开始顺序编号，值为4的元素是a[3].所以只有下标表达式

的值为3的才是正确的。下标表达式g-C中的的变量g和c的值是还未被设定的，其值不

确定。a[4]的值为5，下标为4是不对的。‘d’-‘c’的值为1，a[l]的值是2，所以也是不对

的。变量c的值为‘a’ ，‘d’-c＝3，所以正确解答是④。

2.设有定义：“char s[12]={”string“}；” 则printf（“%dn”，strlen（s））；的

输出是（ ）

① 6 ② 7

③11 ④ 12

「解」在C语言中，字符串是指在有效字符之后有字符率结束标记符的字符列，并约

定字符串的长度是指字符率中有效字符个数，不包括字符串的结束标记符。存放于字符数组

s中的字符串是“string”，该字符串的长度为6，所以输出该字符串的长度应是6.正确的解

答是①。

3.下列语句中，正确的是（ ）

① char a[3][]={‘abc“，’1‘}； ② char a[][3]={’abc‘，’l‘}；

③char a[3][]={‘a’，“1”}； ④char a[][3]={“a”，“1”}；

「解」如定义数组时有初始化，其最高维的长度可以省缺，由系统根据初始化时的初值

个数确定，而其它维的长度是不可以缺省的。对二维字符数组的初始化，可以按行用字符串

对其初始化，也可以按二维数组元素的存储顺序逐一用字符对其元素初始化。在供选择解答

①和③中，有不是最高维的长度被缺省，所以是错误的。在供选择解答①和②中，还将字符

串常量写作‘abc’，这也是错误的。只有④，用字符率按行给二维字符数组初始化，这才是

正确的。正确构解答是④。

4.合法的数组定义是（ ）

①int a[]={“string”} ②int a[5]={0，1，2，3，4，5}；

③char a={“string”} ④char a[]={0，1，2，3，4，5}；

「解」①错误的原因是整数数组不可以用字符串对其初始化。②错误的原因是，数组初

始化时，初始化指定的值的个数多于数组的元素个数。③错误的原因是，能用字符串初始化

的只；有字符指针变量，或字符数组。字符率不能对其它类型的变量初始化，包括字符变量。

④是正确的，因为字符数组可以用小整数（作为字符的ASCII代码值）对其元素初始化。

5.语句“printf（”%dn“strlen（”atsnol21“））；”的输出结果是（ ）

①11 ②10 ③ 9 ④ 8

「解」字符串中的字符可以是一般的普通字符，也可以是由反斜杠字符开头的转义字符。

在字符串“absno1211” 中，有三个转义字符，它们是n、1、，所以该字符串的有

效字符个数是9.所以正确的回答是③。

6.函数调用“strcat（strcpy（strl，str2），str3）”的功能是（ ）

①将字符串strl复制到字符串str2中后再连接到字符串str3之后

②将字符串strl连接到字符串str2中后再复制到字符率str3之后

③将字符串str2复制到字符串strl中后再将字符串str3连接到字符串strl之后

④将字符串str2连接到字符率strl之后再将字符串strl复制到字符串str3中

「解」函数调用strcat（s1，s2）是将s2字符串复制连接到s1字符串之后，使s1

字符串变得更长。函数调用strcpy（s1，s2）是将s2字符串复制到s1，使s1字符串的

内容与s2字符串的内容相同。函数调用strcat（strcpy（strl，str2） ，str3） 是先执

行strcpy（strl，str2），然后再执行strcat（strl，str3），所以其功能是将字符串str2

复制到字符串strl中，然后再将字符串str3复制连接到字符串strl之后。正确的选择是③。

7.设有如下定义，则正确的叙述为（ ）

char x[]＝{“abcdefg”}；

char y[]＝{‘a’，‘b’，‘c’，‘d’，‘e’，‘f’，‘g’}

；

①数组x和数组y等价②数组x和数组y长度相同

③数组X的长度大于数组y的长度④数组X的长度小于数组y的长度

「解」不指定数组长度的字符数组定义，其所需要的字节数可由初始化中给出的值的个

数确定。字符数组可以用字符串初始化，也可用字符逐个给字符数组的元素初始化。但用字

符初始化时，尽管给出了字符串中的全部字符，还是不会自动有字符率结束字符。但字符串

初始化自动会含有字符串的结束标记符，字符串初始化所需要的字节个数会比用同样多的字

符初始化多1个字节。所以只有③才是正确的。

4.2 填充题

1.根据变量定义“static int b[5]， a[][3]={1，2，3，4，5，6}；”，b[4]＝_____，

a[1][2]

「解」系统规定，静态变量定义时，若末初始化，系统自动给定二进制代码全0的值。

所以态数组b的元素全为0，当然包括b[4]也为几静态数组a是二维数组，每行有三个元

素，在初始化中结出了六个初值，所以数组a有2行。由于数组的元素按行顺序存储，并

按行顺序初始化。前三个值是第一行，后三个值是第二行。a[1][2]是第二行的第三列元素，

也是 a的最后一个元素，所以其值是6.

2.设有定义语句“static int a[3][4]={{1}，{2}，{3}}；”则a[l][l]值为＿，a[2][1]

的值为＿。

「解」给二维数组初始化时，可按行给出初值，并且每行可以只给前面部分的元素给出

初值。系统规定，对哪些未给出初值的部分元素，系统自动置二进制代码全0的值。由于

定义语句只给a[0][0]给定初值l、a[l][0]给定初值2、a[2][0]给定初值3.这样，其它元

素都为0值。所以，a[1][1]＝ 0，a[2][1]＝ 0.

3.若在程序中用到“putchar（ ）”函数时，应在程序开头写上包含命令＿____，若在

程序中用到“strlen（ ）”函数时，应在程序开头写上包含命令_____＿。

「解」putchar（）是系统提供的头文件stdio.h中定义的宏，所以程序要使用它，必

须写上包含命令：#include.函数strlen（）是系统提供的字符串处理函数之一，字符串处

理函数的函数原型说明和它们用到的有关常量、数据结构等，在系统提供的头文件tring.h

中定义，所以使用该函数的程序应在程序开头写上包含命令并include.

4.下面程序的功能是输出数组s中最大元素的下标，请填空。

main（）

{int k， p ；

int s[]={1，－9，7，2，-10，3}；

for（p＝0， k＝p；p<6； p++）

if（s[p]>s[k]）____________

printf（“%dn” ，k）；

}

「解」为要寻找数组中的最大元素的下标，需先预设1个临时最大元素的下标，并顺

序逐一考察数组的元素，当发现当前元素比临时最大元素更大时，就用当前元素的下标更新

临时最大元素下标。直至考察了数组的全部元素后，这临时最大元素下标就是数组的最大元

素下标。通常预设的最大元素下标是数组的首元素下标，考察是从首元素开始顺序向后继元

素考察。程序中，存储临时最大元素下标的变量是k，变量p控制顺序考察的循环控制变量。

当发现当前元素s[p]比临时最大元素s[k]更大时，应该用p更新k.所以在空框处应填入代

码“k＝p；”。

5.下面程序的功能是将一个字符串str的内容颠倒过来，请填空。

# include

main（）

{int i， j，_____________；

char str[]={“1234567”}；

for（i＝0，j＝strlen（str）； i；I++，J++）

{ k＝str； str=str[j]； str[j]=k； }

printf（“%sn”， str）；

}

「解」颠倒一个字符串中的字符，就是首尾对应的元素两两交换。简单地可用两个游标

变量i和j， j是前端元素的下标， j是后端元素的下标， 交换以这两个变量值为下标的

元素str和 str[j].开始时，i的值为 0，j的值为字符率未元素的不标（字符串长度减1）。

每次交换后，i增 1，j减1.继续交换的条件是str还位于str[j]的前面，即i字符串末

元素的不标是它的长度减1，所以在第二个空框处应填入-1.程序为了交换STR[I]和

STR[J]，使用了变量K，该变量应在程序的变量定义部分中一起定义，所以在第一个空框

处应填入K.

6.以下程序可把输入的十进制数以十六进制数的形式输出，请填空。

main（ ）

{ char b[17]={“ABCDEF”}

；

int c[64]，d，i＝0，base＝16；

long n；

printf（“Enter a number：n”）；。

scanf（“%ld”， &n）：

do { c=________；i++；n＝n/base；}

while（n！＝0）；

printf（“Transmite new base：n”）；

for（——i； i>= 0；——i）

{d＝c； printf（“%c”，b）；}

printf（“n”）；

「解」程序中，字符数组b存储十六进制的 16个数字符，整型数组C存储泽出的十

六进制数的各位数值。从整数n译出它的各位十六进制数值，需采用除16取余的方法，即

求n除16 的余。得到它的十六进制的个位数，接着将n除以16.在n不等于0的情况下

循环，能顺序求出n的十六进制的个位数、十位数、百位数等等。程序中变量base已预置

16，所以在第一个空框处可填代码nose或n.当n的十六进制数的个位、十位、百位等数

字依次存放于数组C中后，就从最高位至最低位，参照数组c的内容d（以其内容为下标），

取十六进制数字符表中的字符b[d]输出。所以在第二个空框处可填入代码[d].

4.3 程序分析题

1.阅读程序，写出程序运行结果。，

main（）

{ static int a[][3]＝{9，7，5，3，l，2，4，6，8}；

int i，j，sl＝0，s2＝0；

for（i＝0； i<3；i++）

for（j＝0；j<3；j++）

{ if（i＝＝j） s1＝s1＋a[j]；

if（i+j＝＝ 2） s2＝s2＋a[j]；

}

printf（“%dn%dn”， sl，s2）；

}

「解」已知数组。共有3行3列席一行依次是9，7，5；每二行是3，1，2；第三行

是4，6，8.程序引用数组元素的游标变量是i和j，外循环控制变量i是数组的行下桥，内

循环控制变量j是数组的列下标。循环体的工作是将数组的某些元素累计到sl，某些元素累

计到S2.将行下标i和列下标j相同的元素累计到sl，sl＝a[0][0]＋a[l][1]＋a[2][2].将

行下标i与列下标j的和为 2的元素累计到 s2，s2＝a[0][2]＋a[l][l]＋a[2][0].所以sl

是18，s2是10.程序输出：

18

10

2.说明下列程序的功能。

main（）

{ int i，j；

float a[3][3]，b[3][3]，x；

for（i＝0；i<3；i++）

for（j＝0；j<3 ；j++）

{ scanf（“%f”，&x）； a[j]＝ x；

}

for（i＝0；i<3；i++）

for（j＝0；j<3；j++）

b[j]＝a[j]；

for（i=0；i<3；i++）

{printf（“n”）；

for（j＝0；j<3；j++）

printf（“%f”，b[j]）；

}

printf（“n”）；

}

「解」程序第一段两重循环，实现按行顺序输入数组a的全部元素的值。程序第二段

两重循环是将数组a转置复制到数组b.程序第三段两重循环实现按行输出数组b的全部元

素。所以程序的功能是按行顺序输入3*3二维数组的全部元素，然后按列顺序输出。

3.写出下列程序的运行结果。

main（）

{static char a[]＝｛‘*’，‘*’，‘*’，‘*’，‘*’，‘*’}；

int i，j，k；

for（ i＝0；i<5；i++）

{ printf（“n”）

for（j＝ 0；j；J++） PRINTF（“%C”，‘’）；

for（j＝0；j<5 ；j++）printf（“%c”，a[k]）；

}

printf（ “n”）；

}

「解」程序的外循环控制循环五次，每次开始先输出一个换行符，共输出5行信息。

对于i（自0开始计算）行，先输出i个空白符，接着输出字符数组a中的五个字符，由于

a中的五个字符都是字符。，所以输出五个*字符。这样程序是输出以下形式的图案：

* * * * *

* * * * *

* * * * *

* * * * *

* * * * *

4.说明下列程序的功能。

main（）

{ int i，j ；

float a[3][3]，b[3][3]，c[3][3]，x；

for（i＝0；i<3；i++）

for（j=0；j<3；j++）

{ scanf（“%f”， &x）； a[j]= x；

}

for（i＝0；i<3；i++）

for（j＝0；j<3；j++）

{scanf（“%f”，&x）；b[j]＝x；

}

for（i＝0； i<3； i++）

for（j＝0；j<3；j++）

c[j]＝a[j]＋ b[j] ；

for（i＝0； i<3；i++）

{ printf（“n”）；

for（j＝0；j<3；j++）

printf（“%f”， c[j]）；

}

printf（“n”）；

}

「解」程序第一段的功能是按行顺序输入数组a 的元素。程序第二段的功能是按行顺

序输入数组b的元素。程序第三段的功能是顺序累加数组a和数组b的对应元素，并将和

存于数组C的对应元素中。最后，按行顺序输出数组C的全部元素。

4.4 程序设计题

1.编程序，输入单精度型一维数组 a[10] ，计算并输出 a数组中所有元素的平均值。

「解」为了计算数组元素的平均值，首先要累计它的全部元素的和，然后除以数组元素

的个数，即得数组元素的平均值。写成C程序如下：

# include

main（）

{ int i， n＝10；

float s，a[10] ；

printf（“Enter %d numbers！ n”， n）；

for（ i=0；i< n； i++）

{ scanf（“%f”，&s）； a= s；

}

for（s=0.0，i=0；i；I++）

s+= a ；

s /＝n；

printf（“平均值是%.2fn”， s）；

}

2.编程序，输入10个整数存入一维数组，再按逆序重新存放后再输出。

「解」将数组的元素逆序重新存放，就是将数组的首尾对应元素两两交换。简单地可用

两个游标变量i和j，i是前端元素的下标，j是后端元素的下标，交换以这两个变量值为下

标的数组元素。开始时，i的值为0，j的值为末元素的下标。每次交换后，i增1，j减1.

继续交换的

条件是i程序如下：

# include

main（）

{ int a[10]， i，j，t，n＝10；

printf（“Enter %d numbers！ n”， n）；

for（i＝0；i；I++）

scanf（“%d”，&a ）；

for（i=0，j＝n-1；i；I++，J——） {

t＝ a； a＝a[j] ；a[j] ＝t；

}

for（i＝0； i； I++）

printf（“%dt”， a）；

printf（“n”）；

}

3.编程序，输入两个字符串（<40个字符） ，连接后输出（不准用系统函数） .

「解」将字符串s2连接到字符串s1的计算过程可分两个步骤完成。首先找到字符串

s1的末尾，然后参照字符串s2，将字符串s2的全部有效字符逐一复制到字符串s1，最后

在字符串s1的末尾接上字符率结束标记符。完整程序如下：

# include

# define N 40

main（）

{ char s1[N] ，s2[N]；

int i，j；

printf（“Enter stringl！n”）；

scanf（“%s”，s1）；

printf（“Enter string2！ n”）；

scanf（“%s”， s2）；

for（i＝0； sl！＝‘0’ ； i++） ；

for（j＝0；s2[j]！＝‘0’ ；i++，j++）

so＝s[j] ；

s1＝‘0’

printf（“sl＝%sn” ，sl）；

}

4.编程序按下列公式计算S的值（其中X1、X2、…、Xn由键盘输入）：

s＝∑（xi-x0）（xi-x0） （其中x0是X1、x2、…、Xn的平均值）

「解」输入数组x的n个元素的值，按公式计算。程序首先输入n，设n<100，然后

输入n个数据，接着求它们的平均值，最后按计算公式求出s，并输出。程序如下：

# include

# define N 100

main（）

{ double x[N+1]， s；

int i，n；

do {

printf（“Enter n（<100）”）； scanf（“%d”， &n）；

} while（<=0||n>=100）；

for（i=1； i<=n；i++）{

scanf（“%lf”， &s）；x＝s；

}

for（s＝0.0，i＝1；i<=n； i++）

s+=x ；

x[0] ＝ s/n；

for（s＝0.0， i=1；i<= n；i++）

s+=（x-x[0]）*（x－x[0]）；

printf（“s=%fn”， s）；

}

5.输入一个3X5的整数矩阵，输出其中最大值、最小值和它们的下标。

「解」输入一个二维数组，寻找二维数组的最大值和最小值。其中寻找最大值和最小值

的工作可用两重循环实现，即按行按列考察二维数组的元素。程序如下：

# include

main（）

{ int a[3][5]， i，j，t，n＝3， m＝5，

min，max， minrow， mincol， maxrow， maxcol；

printf（“Enter %d*%d numbers ！n” ， n，m）；

for（i＝0； i；I++） ）

for（ j＝0；j；J++）{

scanf（“%d”， &t）； a[j]＝ t；

}

min＝max=a[［0][0]； minrow＝mincol＝maxrow=maxcol=0；

for（i＝0；i；I++）

for（j＝0；j； J++）{

if（ a[j]> max ）{

max= a[j] ；maxrow= i；maxcol=j ；

}

if（ a[j]） {

min＝a[j] ； minrow= i； mincol＝j ；

}

}

printf（“MAX＝a[%d][%d] ＝%d MIN＝ a[%d][%d] ＝%d n”，

maxrow，maxcol，max，minrow，mincol，min） ；

}

6.输入一个字符串，将其中的所有大写字母改为小写字母，而所有小写字母全部改为大写

字母，然后输出。

「解」程序先输入字符率，然后顺序考察输入字符串中的字符，当发现是大写字母时，

将它改写成对应的小写字母，而当它是小写字母时，就将它改写成对应的大写字母。若变量

ch中的字符是大写字母，则与它对应的小写字母的表达式可以写成ch- ‘A’＋‘a’ ；类似地，

若变量ch中的字符是小写字母，则与它对应的大写字母的表达式可以写成ch－‘a’＋‘A’ .

完整程序如下：

# include

# define N 200

main（）

{ char s[N] ；

int i；

printf（“ Enter string！ n”）；

scanf （“%s” ，s）；

for（i＝0； s！＝‘0’；i++）

if（s >=‘A’&&s <=‘Z’ ）

s＝s -‘x’＋‘a’ ；

else if（s >=‘a’&& s <=‘z’）

s＝ s－‘a’ ＋‘A’ ；

printf（“s＝%sn”，s）；

}

7.设某班50名学生的三科成绩表如下：

课程一 课程二 课程三

…… …… ……

试编一个程序，输入这50个学生的三科成绩，计算并输出每科成绩的平均分。

「解」程序定义一个50行3列的二维数组，用于存储全班学生的成绩。程序顺序输入

各个学生的三科成绩，然后按列的顺序，累计各科总分，并计算平均分。完整程序如下：

# include

# define N 50

# define M 3

main（）

{int score[N][M]， i，j，t；

double a[M]；

printf（“Enter scores！n”）；

for（i＝0；i< N； i++）

for（j＝0；j；J++） {

scanf（“%d”，&t）；score[j]＝t；

}

for（j＝0；j；J++）A[J]＝0.0；

for（j＝0；j< M；j++）{

for（i＝0；i< N； i++）

a[j]+= score[j]；

a[j]/＝ N；

}

for（j＝0；j；J++）

printf（“课程%d的平均分是%.2fn”， j+1，a[j]）；

}

8.编一个程序，输入一个整型数据，输出每位数字，其间用远号分隔。例如，输入整数为

2345，则输出应为： 2， 3， 4， 5.

「解」程序的主要工作是从输入整数分拆出它的十进制整数的各位数字，将分拆出来的

各位数字存于数组中，然后将这些数字自高位到低位的顺序逐位输出。要将一个整数按十进

制数的要求分拆，需用一个循环，每次循环求出被分拆数除以10的余数的办法来求出它的

个位，每分拆出一位就将被分拆的数除以10.循环过程直至被分拆的数为0结束。完整程序

如下：

# include

main（）

{int a[20]，i，base＝10；

int n；

printf（“Enter a number！ n”）；

scanf（“%d”， &n）；/*整数输入*/

i＝0；/*对n进行分拆，各位数字自低位到高位存于数组 a*/

do{

a[i++]＝n% base；

n/＝ base；

} while（n） ；

for（i——；i>=0；i——）/*自高位到低位输出*/

printf（“%d%c”，a， i？ ‘，’ ：“n‘）；

}

9.编一个程序，输入一个字符串，将其中所有的大写英文字母的代码+3，小写英文字

母的代码-3.然后输出加密后的字符串。

「解」程序的主要工作是输入字符串，并顺序考察输入字符率中的字符，分别对其中大

小写英文字母完成问题要求的更改，而跳过不是英文字母的字符。完整程序如下：

# include

# define N 200

main（）

{char s[N]； int i；

printf（“Enter string！ n”）；

scanf（“%s”， s）；

for（i＝0；s ！＝‘0’； i++）

if（s >=‘A’ && s＝‘Z’）

s＝3；

else if（s＝‘a’&& s＝‘z’ ）

s＝3；

printf（“s＝%sn”，s）；

}

10.编一个程序，将按第9题中加密的字符率（从键盘输入）解密后输出。

「解」本问题编写的程序是完成上一程序的逆操作。同样是顺序考察输入字符串，对满

足要求的字符作恢复更改。要求是当字符减3后是大写英文字母时，则对其作减3处理的

替换；当字符加3后是小写英文字母时，则对它作加3的处理。如此做法是有错误的，程

序未考虑原

先不是英文字母，而未被加3或减3处理，但对它减3或加3后是英文字母时，将被

下面的程序转换成英文字母。所以下面的程序不是完成上题程序的逆操作。但没有简单的办

法能避免这个错误。完整程序如下：

# include

# define N 200

main（）

{char s[N]； int i；

printf（“Enter string！n”）；

scanf（“%s”，s）；

for（i＝0；s ！＝‘0’；i++）

if（s-3>=‘A’&&s-3<=‘Z’）

s-=3；

else if（s+3>=‘a’ && s+3<= ‘Z’）

s+=3；

printf（“s=%sn”，s）；

}

5.1 单项选择题

1.设有定义“int a＝3， b，*p＝&a；”，则下列语句中使 b不为3的语句是（ ）

① b＝* &a； ② b＝* p；

③ b＝a； ④ b＝*a；

「解」定义有 int a＝3， b，*p＝&a；对b赋值的表达式有*&a、*p、a 、*a.引

用变量。的值有两种方法，一是直接引用a，二是通过a的指针间接引用a.对于后者，又

有多种表达方法，通过指向a的指针p，间接引用a的内容，如*p.或通过求地址运算符由

变量a得到其指针&a，再由这指针表达式间接引用 a的内容，如* &a.所以表达式*&a、

*p和a都能引用变量a的值，而使b的值为3.而表达式。a是错误的，因为a不是指针变

量，不能对它施行取内容运算符……所以解答是④。

2 .设指针x指向的整型变量值为万，则“printf（”%dn“，++ *x）；”的输出是（ ）

① 23 ② 24 ③ 25 ④ 26

「解」若指针变量x指向某个变量，例如指向变量v，并且变量v的值是25，则表达

式++ *x的值是26.这是因为表达式的计算顺序可加圆括号表达成（++（*x）），首先

是*x，是对X所指变量V的引用，所以++ *X就是++V.++V是先让变量V增1，并以

增至后的V的值为表达式++V的结果，所以其值是 26.所以解答是④。

3.若有说明：“ int i，j＝ 7，*p＝&i；”，则与“ i＝j；”等价的语句是（ ）

①i＝*p； ②*P＝* &j；

③i==&j； ④i＝* *p；

「解」指针变量 p指向变量i时，表达式i=*p等价于 i＝i；表达式*p＝*&j等价于i

＝j；而表达式i＝&j企图将整型变量的指针赋给整型变量，这是错误的；表达式i=* *p

也是一种错误的表达式。p是指针，*p是p所指变量j，* *p是企图将整型变量j当作指

针，并想通过j间接引用某个变量。所以解答是②。

4.若有说明语句“int a[10]，*p＝a；”，对数组元素的正确引用是（ ）

①a[p] ②P[a]

③*（P＋2） ④P＋2

「解」在 C语言中，约定数组名单独出现在表达式中时，它表示数组首元素的指针。

有int a[10] ，则a可以作为&a[0]使用。另有整型指针变量p，代码p＝a实现p指向数

组a的首元素。则表达式*（p＋2）是引用数组元素a[2].表达式a[p]和p[a]都是不正确

的，下标必须是整型表达式，不可以是指针表达式。表达式p＋2是指针表达式，它的值是

&p[2].所以只有表达式*（p＋2）引用数组a的元素a[2].所以解答是③。

5.下面各语句中，能正确进行赋字符串操作的语句是（ ）

①char s[5] ={“ABCDE”}； ②char s[5] ={‘A’，‘B’，‘C’，‘D’，‘E’}；

③ char *s；s＝“ABCDE”； ④ char *s；scanf（“%”， s）；

「解」字符串最终存储于字符数组中，存储字符串的字符数组可以是程序主动引入的（定

义或动态分配），也可以是字符串常量，由系统分配。其中字符数组用字符串初始化就是字

符串存储于由程序引入的字符数组的例子。给字符指针赋字符串则是系统自动分配字符率存

储空间的例子。给字符指针赋字符串并不是将一个长长的字符串存于字符指针变量中，而是

将字符串常量存储于常量区，并将存储这个字符串的首字节地址赋给指针变量，让指针变量

指向字符率常量的首字符。对于以字符串作为字符数组初值的情况，要求字符数组足够的大，

能存得下字符串常量。这里有一个特别的规定，若数组的大小少于存储字符串有效字符的字

节个数，系统将报告错误；当字符数组的大小只能存储字符串的有效字符，而不能存储字符

率结束标记符时，则存储于字符数组中的内容是字符序列，因没有存储字符率结束标记符，

存储的内容就不是字符串。

如代码char a[5]＝“ABCDE”。另外，给字符数组元素逐一赋字符初值，并在字符初

值中没有字符串结束标记符，则存于字符数组中的内容也不是字符率。如代码 char

s[5]={‘A’，‘B’，‘C’，‘D’，‘E’}.特别要注意当字符指针还未指向某个字符数组的元素时，

不可以通过字符指针输入字符串。如代码char *s；scanf（“%s”，s）。若写成char *str；

scanf（“%s”，&str）更是错误的了。由于C语言规定数组不能相互赋值，所以只能将字

符串常量赋给某字符指针。如代码char *s；s＝“ABCDE”是正确的。实际上，字符率“ABCDE”

被存储于常量区中，向指针变量赋的是字符指针，让s指向其中的字符‘A’。所以解答是③。

6.若有以下定义，则不能表示a数组元素的表达式是（）

int a[10]＝｛1，2，3，4，5，6，7，8，9，1o}，*p＝a；

①*p ② a[10] ③*a ④ a[p-a]

「解」上述代码定义了有10个元素的整型数组。，和定义指针变量p，并让p指向数

组元素a[0].所以代码*p是引用 a[0].由于数组a只有10个元素，最后一个元素是a[9]，

表达式a[10]是错误的。数组名a可以作为a的首元素的指针，表达式*a就是a[0] ，是

对数组a的首元素a[0]的引用。指针p的值是a，表达式p-a.的值是0，所以a[p－a]就

是a[0].所以解答是②。

7.若有以下定义，则值为3的表达式是（）

int a[]＝ {1，2，3，4，5，6，7，8，9，10}，*p＝a；

①p＋＝2，*（p++） ③p＋＝2，* ++p

③p＋＝3，*p++ ④ p＋＝2，++ *p

「解」数组a有10个元素，分别有值1至10，指针变量p指向a[0] ①逗号表达式 p

＋＝2，*（P++），先是P＋＝2使P指向a[2]，接着是*（P++），以当时P所指变量

a[2]取内容3为表达式的值，同时使p指向a[3].②返号表达式p＋＝2，* ++p，先是p

＋＝2使p指向a[2]，以后是* ++p，又使 p增1，让它指向a[3]，并取指针p所指变

量a[3]的内容4作为表达

式的值。③逗号表达式 p＋＝3，*p++，先是p+=3使p指向a[3]，以后是*p++，

表达式的值是 a[3]为 4，而使p指向a[4].④逗号表达式p＋＝2，++ *p，先是p＋＝2，

使p指向a[2]，以后是++ *p，因当时的*p就是 a[2]，++a[2]使a[2]增1，变成4，

并以4为表达式的值。所以只有p＋＝2，*（p++）的值是3.所以解答是①。

8.设有定义“char a[10]={”abcd“}，*p=a；”，则*（p＋4）的值是（ ）

①“abCd” ②‘d’

③‘0’ ④不能确定

「 解」若有char a[10]＝“abcd”，*p＝a，则指针变量p指向a[0].在表达式*（p

＋4）中，p＋4指向a[4]，*（p＋4）就是a[4].由于用字符“abcd” 给字符数组a赋初

值，a[4]的值是字符串结束标记符‘0’。所以解答是③。

9.设有代码“int（*ptr）[10]；”，其中的ptr是（ ）

①10个指向整型变量的指针

②指向10个整型变量的函数指针

③一个指向具有10个元素的一维数组的指针

④具有10个指针元素的一维数组

「解」代码“int（*ptr）[10]；”的分析过程是，因圆括号，括号内的ptr先与字符*

结合，字符*修饰标识符ptr是一种指针；接着与后面的一对方括号结合，表示是这样的一

种指针，是指向一维数组的；再有方括号中的10，说明这种数组有10个元素。至此，ptr

是指向含10个元素的

一维数组的指针。最后，是最前面的int，表示数组元素是int类型的。所以，ptr是一

个指向具有10个int型元素的一维数组的指针。所以解答是③。另外，要是①，10个指

向整型变量的指针，就是一个指针数组，上述代码应写成“int *ptr[10]；”，即ptr是一个

有10个指向整型变量的数组。要是②，返回值是指向10个整型变量的函数的指针，上述

代码应写成“int（*（*ptr）（））[10]；”，即ptr是指针，指向一种函数，函数的返回

值又是一种指针，指向10个元素的数组，数组的元素是整型的。下面的代码是这样的函数

指针和函数的例子：

# include

int a[][10]={{1，2，3，4，5，6，7，8，9，0} ，{0，1，2，3，4，5，6，7，

8，9} }；

int（*（*ptr）（int））[10]；

int（*f（ int n））[10]

{return a＋n；

}

void main（）

{ int（*p）[10]，*q；

ptr＝f；/*让ptr指向函数f*/

P＝（*ptr）（0）；

q=*p；

printf（“%dn”， *p）；

P＝（*ptr）（l）；

q=*p；

printf（“%dn”， *q）；

}

在上述代码中，函数有一个int型的形参。要是④，其意义与①相同，上述代码应写成

“int* ptr[10]；”，即 ptr是一个有10个元素的数组，数组元素是指向整型变量的指针。

10.若有以下定义，则数值为4的表达式是（ ）

int w[3][4]＝{{0，1}，{2，4}，{5，8}}，（* p）[4]＝ W；

①*w[1]＋l ②p＋＋，*（p＋1） ③w[2][2] ④p[1][1]

「解」二维数组定义有多种赋初值的办法，问题给出的代码是按行给数组的部分元素赋

初值。它们分别是w[0][0]＝0.w[0][1]＝1、w[1][1]=2.w[1][1]=4，w[2][0]=5，

w[2][1]＝8.根据约定，未指定初值的元素自动置全0值。指针变量p是一个指向具有四

个int型元素的一维数组的指针，定义时的初值使它指向数组W的第一行。①的代码，

*w[1]+1中的W[l]是指向 w[l][0]的指针，*w[1] 就是w[1][0]，其值是2，*w[1]＋

l的值是3.②的代码是逗号表达式，“p＋＋，*（p＋1）”先使p指向数组w的第二行，*

（p＋l）中的p＋l是指向数组w的第三行，*（p＋1）是指针值，指向数组w的第三行的

第一个元素，即&w[2][0]. ③的代码w[2][2]引用数组W第三行的第三列元素，其值是

0.④的代码p[1][l]引用数组W第二行的第二列元素w[1][1]，其值是 4.所以解答是＠。

11.若有下面的程序片段，则对数组元素的错误弓D用是（ ）

int a[12]＝{0}，*p[3]，* *pp，i；

for（ i＝0；i<3；i++） p=&a[i＋4]；

pp= P；

①pp[0][1] ②a[10]

③ p[3][l] ④*（*（p＋2）＋2）

「解」上述代码定义变量a是有12个整型元素的数组，它的初值全是0.p是有三个元

素的指针数组，每个指针能指向整型变量。哪是指针的指针，它能指向一个指向整型变量的

指针， i是一个整型变量。执行代码for（i＝0；i<3；i++） P＝&a[i+4] 使指针数组 p

的元素 p[0]指向 a[4] ，p[l]指向a[5] ，p[2]指向 a[6].代码pp＝p使指针变量pp指

向p[0].①代码pp[0][l] 用指针表达可等价地写成*（*pp＋l）。其中*pp就是 p[0]，

p[0]的值是&a[4]，*pp+1的值是&a[4]＋1=&a[5]，*（*pp+1）就是a[5].②代码a[l0]

当然是引用数组a的元素。③代码p[3][1]数组p只有三个元素，没有p[3]，所以是错误

的。④代码*（*（p＋2）＋2）中的（p＋2）是 &p[2]，*（p＋2）是 p[2]，其值是&a[6]，

*（p＋2）＋2的值是&a[8]，*（*（p＋2）＋2）引用的是a[8].所以解答是＠。

12.若有如下定义和语句，则输出结果是（ ）

int * *pp， *p，a＝10，b＝20；

PP=&p； P＝&a； P＝&b； printf（“%d%dn”，*p，* *PP）；

①10， 20 ② 10， 10

③ 20， 10 ④ 20， 20

「解」上述代码定义变量pp是指针的指针，它能指向一个指向整型变量的指针。定义

变量p是指针，它能指向一个整型变量。a是一个整型变量，它有初值10.b也是一个整型

变量，它有初值20.代码 pp=&p 使pp指向p，p＝&a使p指向a，p＝&b又使p指向

b，不再指向a.所以。p是引用b，其值为20.* *pp是通过pp间接引用p，再通过p间

接引用b，所以也是20.所以解答是④。

13.若有以下定义和语句，则对w数组元素的非法引用是（ ）

int w[2][3]，（* pw）[3]； pw＝ w；

① *（w[0]＋2） ②*pw[2]

③pw[0][0] ④*（pw[l]+2）

「解」上述代码定义2行3列的二维数组w，定义能指向有3个整型元素一维数组的

指针pw，并让pw指向数组w的第一行。①代码*（w[0]＋2）中的w[0]是&w[0][0]，

w[0]＋2是&w[0][2]，所以*（w[0]＋2）就是w[0][2].②代码*pw[2]中的pw[2]是

&w[2][0]，该数组w只有2行，没有w[2][0]，所以代码*pw[2]是对数组W元素的非

法引用。③代码pw[0][0]就是w[0][0].④代码*（pw[l]＋2）中的pw[1]就是*（pw＋l），

即&w[l][0]，pw[l]＋2就是&w[l][2]，所以*（pw[1]＋2）就是w[1][2].所以解答是②。

5.2 填充题

1.“* ”称为___________运算符，“&”称为_________运算符。

「解」单目运算符“*”称为取内容运算符，单目运算符“&”称为取地址运算符。

2.若两个指针变量指向同一个数组的不同元素，可以进行减法运算和___________

运算。

「解」若两个指针变量指向同一个数组的不同元素，可以进行减法运算求它们所指元素

相差多少元素。进行关系运算，判定它们所指元素的前后，或是否指向同一个元素等。

3.设 int a[10] ，*p＝a；则对a[3]的引用可以是p[______________] 和*

（p_________）。

「解」若指针p指向数组a的首元素，则引用a[3]用指针p可以写成p[3]和*（p＋

3）。

4.若d是已定义的双精度变量，再定义一个指向d的指针变量p的代码是

___________.

「解」若d是一个双精度变量，定义能指向它的指针变量p可以用以下代码double *p

＝&d.

5.&后跟变量名，表示该变量的________＿；*后跟指针变量名，表示该指针变量

_______.&后跟的是指针变量名，表示该指针变量的_____________.

「解」单目运算符&是取地址运算符，&后跟变量名，就表示该变量的地址。单目运算

符*是取内容运算符，*后跟指针变量名，表示该指针变量所指变量的内容。若&后跟的是指

针变量名，就表示该指针变量的地址。若知道指针变量的地址，欲通过指针变量的地址引用

指针变量所指变量的内容，需要连续两次取内容运算。

6.设有char *a＝“ABCD”，则printf（“%s”，a）的输出是_______；而printf（“%c”，

*a）的输出是______.

「解」若给字符指针变量a赋一个字符串常量“ABCD”，实际上是给a赋指向字符串常

量首字符‘A’的指针。程序通过它访问字符串中的各字符。如用代码printf（“%s”，a） 输

出这个字符串常量“ABCD”的字符列ABCD，用代码printf（“%c”，*a）输出a所指的字

符 A.

7.设有以下定义和语句，则*（*（p＋2）＋l）的值为__________.

int a[3][2]={10，20，30，40，50，60}，（*p）[2]；

p= a；

「解」上述代码定义3行2列的二维数组a ，定义指向两个元素的一维数组指针p，

并让p指向二维数组a的首行。则代码*（*（p＋2）＋l）中的p＋2指向二维数组a的第

2行a[2]，*（p＋2）指向a[2][o]，*（p＋2）+l指向a[2][l]，*（*（p＋2）＋l）是

引用a[2][l]，其值是60.

8.以下程序的功能是从键盘上输入若干个字符（以回车符作为结束）组成一个字符串存

入一个字符数组，然后输出该字符数组中的字符串。请填空。

# include

# include

main（）

{ char str[81]，*sptr；

int i；

for（i＝0；i<80；i++）

{ str=getchar（）；if（str＝＝‘n’） break；}

str＝____________；

sptr＝str；

while（* sptr） putchar（* sptr______________）；

}

「解」从键盘输入字符行，通过循环逐一输入字符，当发现输入字符是换行符时，结束

循环。为了使输入的字符列变成字符串，必须在输入字符列之后，原存储换行符的元素改为

存储字符串的结束标记符，需用代码 str＝‘0’ ，所以在第一框填入代码‘0’。当要将存于

字符数组str中的字符串通过循环逐一输出字符串的字符时，可以用字符指针sptr，让sptr

遍历整个字符串，每次循环时，输出sptr所指字符，并让sptr增1，即可用代码*sptr++

实现，所以在第二框填入代码++.

5.3 程序分析题

1.阅读下列程序，写出程序的输出结果。

main（）

{char *a[6]={“AB”，“CD”，“EF”，“GH”，U“，”KL“}；

int i；

for（i＝0；i<4；i++） printf（“%s”， a）；

printf（“n”）；

}

「解」程序定义了有六个元素的字符指针数组a ，数组a 的各元素指向字符率常量。

程序的for循环遍历了a的前四个元素，用字符率输出格式，输出指针数组a前四个

元素所指的字符串。所以程序输出： ABCDEFGH.

2.阅读下列程序，写出程序的主要功能。

main（）

{ int i，a[l0]，*p＝&a[9] ；

for（i=0；i<10；i++） scanf（“%d”，&d）；

for（； p>=a； p——） printf（“%dn”，*p） ；

}

「解」程序定义了有10个元素的整型数组a，另定义指针变量p，并让它指向a的最

后一个元素a[9].执行代码的第一个循环是顺序输人数组a的10个元素。第二个循环利用

指针p逆序遍历数组a，将数组a的各元素逆序输出。所以程序的功能是输入10个整数，

并逆序输出这10个整数。

3.阅读下列程序，写出程序运行的输出结果。

char s[]＝“ABCD”；

main（）

{ char * p；

for（ p＝s；p< s＋4；p++） printf（“%sn”， p）；

}

「解］程序定义了一个字符数组s，由给它所赋的字符串初值知，该数组只有五个元素。

程序另定义了字符指针变量p.循环开始时，先让p指向数组的首元素。循环每次输出以p

所指字符为首字符的字符串，并让它指向下一个字符。如此反复循环四次，所以程序输出以

下内容：

ABCD

BCD

CD

D

4.阅读下列程序，试写出程序运行的结果。

main（）

{int i，b，c，a[]＝{1，10，-3，-21，7，13}，*p_b，*p_c；

b=C=1；p_b＝p_C＝ a；

for（i＝0；i<6； i++）

{ if（b<*（a＋i）） {b＝*（a＋i）； p_b＝&a； }

if（c>*（a＋i）） {c＝*（a＋i）； p_c＝&a； }

}

i＝*a；*a＝*p_b；*p_b＝i；i=*（a＋5）；*（a＋5）＝*p_c；*p_c＝i；

printf（“%d，%d，%d，%d，%d，%dn”， a[O]，a[1]，a[2]，a[3]， a[4]，

a[5]）；

}

「解］程序定义了一个整型数组。，由给它所赋的初值知，该数组有六个元素。程序另

定义了三个整型变量i.b、C和两个指针变量p_b.p_c.程序首先置变量b和C都为1，p_b

和p_c都指向数组a 的首元素a[0].接着执行六次循环，循环体由两个if语句。第一个if

语句是当 b的值小于*（a＋i）（就是a）时，将*（a＋i）的值复制到b，并让p_b指向

a.这是在a中找最大值，将最大值存于b，最大值元素的指针存于指针变量p_b.第二个if

语句是当c的值大于*（a+i）（就是a）时，将*（a＋i） 的值复制到c，并让p_c指向

a.这是在a中找最小值，将最小值存于c，最小值元素的指针存于指针变量p_c.循环结束

后的前三个语句实现最大元素与a[0]交换。接着三个语句是在已经过前面交换的基础上，

将最小元与a[5]交换。最后程序顺序输出数组a的六个元素。所以程序输出内容是：

13， 10，-3， l， 7，-21.

若数组a的初值由输入任意指定，上述程序对一种特殊情况不能完成功能的要求，即

最小元素若是a[0]，p_c所指元素已被移到p_b指针所指位置，实际与a[5]交换的不再

是数组中的最小元素，而是最大元素。

5.4 程序设计题

1.输人3个整数，按从大到小顺序输出。

「解」存储输入的三个整数可用三个简单变量，也可用数组。设用三个简单变量x，y，

z存储输入的三个整数。另设若干个指针变量指向存储输入数据的变量。实现从大到小输出

三个整数有多种方案，如通过比较交换变量的值，多次比较交换使变量满足条件x>=y>=z.

这样，变量的输入值可能会与它的输出值不一样。如通过比较交换指针变量，当比较后发现

要交换时，就交换变量的指针，而不交换变量的值，则在比较结束后，变量的值没有改变，

但从指针方向来看，它们的值是从大到小排列的。下面的程序就采用这种方案。

# include

main（）

{ int x，y，z；

int *big=&x，*mid=&y，*sma=&z，/*置三个指针变量分别指向x，y， z*/

*temp；

printf（“Enter x，y，z.n”）；

scanf（“%d%d%d”， big，mid，sma）；/*顺序为变量x，y，z输入值*/

if（*big< *mid） {temp＝big；big＝mid； mid＝temp； }

/*使*big>=*mid*/

if（*big<*sma） { temp＝big；big＝sma；sma＝temp； }/*使*big>=*sma*/

if（*mid<*sma）{temp＝mid；mid=sma；sma=temp； }/*使*mid>=*sma*/

printf（“%dt%dt%dn”， x，y，z）；/*按输入顺序输出x，y，z*/

printf（“%dt%dt%dn”，*big，*mid，*sma）；/*按从大到小的顺序输出*/

}

2.编一个程序，输入15个整数存入一维数组，再按逆序重新存放后再输出。

「解」输入数组的元素，并重新颠倒存放后输出。将存储于数组中的元素颠倒存储，只

要首尾相对应的元素两两交换即可。若用指针实现，可让一个指针p指向前端的元素，另

一个指针q指向与前端元素对应的后端的元素。循环前，让p指向数组的首元素，让q指

向数组的末元素。循环时，让p和q所指两个元素交换，并让p增1，q减l.循环条件是p

所指元素在前，q所指元素在后，即p＜q.程序如下：

# include

main（）

{ int a[15]，*p，*q， temp；

printf（“Enter 15 numbers.n”）；

for（p＝a；p＜a＋15；p＋＋）

scanf（“%d”， p）；

for（p＝a，q＝a＋14；p＜q；P++，q——） {

temp＝*p； *p＝*q；*q=temp；

}

for（p＝a；p＋15；P++）

printf（“%dt”，*p）；

printf（“n”）；

}

3.输入一个字符串，按相反的次序输出其中的全部字符。

「解」要相反的次序输出字符串的全部字符，可用一个字符指针变量，从指向字符串的

本字符开始，逆序遍历字符串，输出指针所指字符即可。但为了让字符指针指向字符串的末

字符，若不用字符串处理库函数，得用一个循环，让它从字符串的首字符开始，顺序移至字

符串的结束标记符，然后倒退一个字符，就能让它指向字符串的末字符。程序如下：

# include

# define N 200

main（）

{ char s[N]，*p；

printf（“Enter a string.n”）；

scanf（“%s”， s）；

for（p＝s；*p； p++）；

for（p——； p>=s； p——）

printf（“%c”，*p）；

printf（“n”）；

}

4.输入一个一维实型数组，输出其中的最大值、最小值和平均值。

「解」设实型数组的元素个数n不超过20.程序输入n，并用循环输入数组的元素，再

用循环遍历数组，求出数组的最大值和最小值、数组元素的和。然后求出数组元素的平均值，

最后输出结果。程序如下：

# include

# define N 20

main（）

{ double a[N]，max，min，ave，*p， t；

int n；

printf（“Enter n（0＜n＜20）。n”）；

do{

scanf（“%d”，&n）；

if（n>0 && n<20） break；

printf（“n值不合要求，请重新输入！n”）；

} while（l）；

printf（“输入%d个实数n”， n）；

for（n＝a；n＋N； P++）{

scanf（“%lf”，&t）；*p＝t；

}

max＝min＝ave=*a；

for（p＝p+l；p； P++）{

if（max<*p） max＝*p；

if（min>*p） min＝*p；

ave＋＝*p；

}

ave/＝n；

printf（“最大值：%ft最小值：%ft平均值：%fn”，max，min，ave）；

}

5.输入一个3×6的二维整型数组，输出其中的最大值、最小值及其所在的行列下标。

「解」找出其最大值和最小值，及它们的行列位置。采用按行按列顺序遍历数组的方法

找出数组的最大值、最小值，以及它们在数组中的位置指针。输出时，将位置指针转换成行

下标和列下标。程序如下：

# include

# define N 3

# define M 6

main（）

{ int a[N][M]，*maxp，*minp，*q，t；

printf（“输入%d个整数n”， N*M）；

for（q＝a[0]；q<*a＋N*M；q++） {

scanf（“%d”，&t）；*q＝t；

}

maxp=minp=*a；

for（q＝a[0]；q<*a＋ N*M； q++） {

if（*maxp<*q） maxp=q；

if（*minp>*q） minp＝q；

}

printf（“最大值：%d它的行下标是%d它的列下标是%dn”，

*maxp，（maxp-*a）/M，（maxp-*a）%M）；

printf（“最小值：%d它的行下标是%d它的列下标是%dn”，

*minp，（minp-*a）/M，（minp-*a）%M；

}

6.输入三个字符串，找出其中最大的字符串。

「解」将输入的三个字符率分别存于三个一维字符数组中，另用一个字符指针数组，分

别指向这三个字符串，然后用循环控制这三个字符串的比较，找出最大的字符串。两字符串

比较时，程序不用标准库函数，而用两字符串的对应字符比较来实现。完整程序如下：

# include

# define N 120

# define M 3

mian（）

{ char s1[N]， s2[N]，s3[N]，*strs[M]={s1，s2，s3}，*p，*q，*ms；

int i；

printf（“输入%d个字符串n”， M） ；

for（i＝ 0； i； I++）

scanf（“%s”，strs）；

ms＝strs[0]；

for（i=1；i； I++） {

for（ p=ms，q=strs；*p！ ＝‘0’ && *p＝＝*q；p++，q++）；

if（*p<*q） ms＝strs；

}

printf（“最大字符串：%sn”，ms）；

}

7.输入两个字符串，将它们连接后输出。

「解」程序设有两个存储字符串的数组，先输入两个字符串，然后找到第一个字符串的

末尾，接着将第二个字符串复制在第一个字符串的后面，然后输出。程序如下：

# include

# define N 120

main（）

{ char s1[N＋N]，s2[N]，*p，*q；

printf（“输入2个字符串n”）；

scanf（“%s%s”，s1，s2）；

for（p＝sl；* p！＝‘0’； p++）；

for（q＝s2；*p++＝*q++；）；

printf（“两字符串连接后：%sn” ，sl）；

}

8.比较两个字符串是否相等。

「解」程序设两个存储字符串的数组，先输入两个字符串，两字符率比较时，直接用两

字符串的对应字符比较来实现。完整程序如下：

# include

# define N 120

main（）

{ char sl[N] ，s2[N]，*p，*q；

char *result[]={“小于”，“相等” ，“大于”}；

int comp；

printf（“输入 2个字符串n”）；

scanf（“%s%s”，s1，s2）；

for（p＝sl，q＝s2；*q！＝‘0’&& *p＝＝*q； p++， q++）；

comp＝*P <* q？ 0：*P＝＝*q？ l：2；

printf（“字符串1与字符串2比较：%sn”，result[comp]）；

}

9.输入10个整数，将其中最大数与最后一个数交换，最小数与第一个数交换。

「解」程序设一个一维数组存储输入的10个整数。然后遍历数组，找出最大元素和最

小元素的指针。接着按要求先将最大元素与最后一个元素交换，然后将最小元素与第一个元

素交换。最后，输出数组中的全部整数。程序应考虑到这样一种特殊情况，即最后一个元素

正是最小元素，它在与最大元素交换后，位置已移到原先存储最大元素的位置。程序应保证

最大元素移到末尾，最小元素移到最前端。

程序如下：

# include

# define N 10

main（）

{ int a[N]，*maxp，*minp，*q，t；

printf（“入%d个整数n，N）；

for（q＝a；q＋N；Q++） {

scanf（“%d”，&t）；*q＝t；

}

maxp= minp= a；

for（q＝a；q＋N；Q++）{

if（*maxp<*p） maxp=q；

if（*minp>*q） minp＝q；

}

t＝*maxp； *maxp=a[N-1]； a[N－l]＝t；

if（minp＝＝&a[N－l]） minp＝maxp；

t＝* minp；*minp＝ a[0]； a[0]＝ t；

for（q＝a；q＋N； Q++）

printf（“%d”，*q）；

printf（“n”）；

}

6.1 单项选择题

1.函数调用语句“f（（el，e2），（e3，e4，e5））；”中参数的个数是（ ）

①1 ②2

③4 ④5

「解」上述函数调用中，（e1，e2）和（e3，e4，e5）是两个带括号的表达式，所

以函数调用只提供两个实参，其中第一个实参先计算el的值，然后计算e2，并以e2的值

为实参。第二个实参顺序计算e3，e4，e5，并以e5的值为实参。所以解答是②。

2.C语言中，函数的隐含存储类型是（ ）

①auto ②static

③extern ④无存储类别

「解」由于C函数内不能再定义函数，C函数的存储类型只能是静态的或外部的之一。

若定义函数时不指定存储类型是静态的，则它的存储类型就是外部的（extern），即函数

允许被程序的其它函数调用。所以解答是③。

3.以下对C语言函数的有关描述中，正确的是（ ）

①在C语言中，调用函数时，只能把实参的值传递给形参，形参的值不能传递给实参

②C函数既可以嵌套定义，又可以递归调用

③函数必须有返回值，否则不能定义成函数

④C程序中，有调用关系的所有函数必须放在同一个源程序文件中

「解」C语言规定，调用函数时，只能把实参的值传递给函数的形参。函数调用时，形

参从实参表达式得到初值，报参也是函数的一种局部变量，其值可以改变，但形参的值不能

传回给对应的实参。当函数设置非指针类型的形参时，实参可以是同类型的一般表达式；当

函数设置指针类型的形参时，对应的实参也必须是同类型的指针表达式。所以叙述①是正确

的。C语言虽可以递归调用，但同时规定，在函数内不能再定义函数，所以叙述②是错误的。

通常C函数会有返回值，但也可以没有返回值。有许多情况，函数的执行是完成某种预定

的工作，并没有返回值，所以叙述③是不正确的。在C程序中，如函数未指定是静态的，

则就是外部的，能让别的文件中的函数调用。但函数要调用别的文件中的函数，在调用代码

之前，需对它作说明，所以叙述④也是不正确的。正确的解答只有①。

4.设函数的功能是交换X和y的值，且通过正确调用返回交换结果。不能正确执行此

功能的函数是（ ）

① funa（int *x， int *y）

{ int * p；

* p＝*x； *x＝*y； *y=*p；

}

② funb（int x， int y）

{ int t；

t=x；x=y；y=t；

}

③ func（int *x， int *y）

{ int p；

p＝*x； *x＝*y； * y＝p；

}

④fund（ int *x，int *y）

{

*x=*x+ *y；*y=*x- *y；*x= *x- *y；

}

「解」设计实现交换两个变量值的函数。希望函数调用能改变调用环境中的变量，方法

之一是让函数设置指针类型的形参，实参传送给形参的是希望交换值的两个变量的指针。函

数的两个形参得到这两个变量的指针后，函数就能通过形参间接引用要交换值的变量，或引

用它们的值，或改变它们的值。从而实现从函数传回信息存于调用环境的变量中。以上所述

是设计交换变量值函数的一般原则，具体编写函数时还需注意对上述原则的正确应用。

对于函数funa，该函数的定义满足设置指针形参，并通过指针形参间接引用环境变量

的要求。但是在函数体中定义了指针变量p，并在p宋明确设定它所指向的变量下，代码

*p＝* x企图将值存入它所指的变量中，这是初学者经常出现的一种严重的错误。该函数

因有错，不能实现交换变量值的功能。

对于函数funb，该函数不定义指针形参，函数体也没有可用的指针间接引用调用环境

中的变量，所以该函数也不能实现交换变量值的功能。

对于函数func，该函数正确定义了指针形参，函数体也正确通过指针形参间接引用环

境中的变量，并正确定义了自己的局部变量。该函数能实现交换变量值的功能。

对于函数fund，该函数也正确定义指针形参和函数体通过形参间接引用环境变量。特

别要指出的是，该函数是利用*x和*y的；日值与新值之间的关系实现问题要求的。其中第

一个赋值使。x存有原来未交换之前的*x与*y之和；第二个赋值从这个和中减去原来的*y，

并将差赋给*y，使*y的值是交换之前的*x的值；第三个赋值再次从和中减去新的*y，即

减去交换之前的*x，这个差就是交换之前的*y，并将差赋给*x.经以上三个赋值，实现两变

量之间的值交换。

所以不能正确执行交换变量值的函数是funa和funb，即正确选择是①②。

5.要求函数的功能是在一维数组a中查找x值。若找到，则返回所在的下标值；否则，返

回0.设数据放在数组元素的a[1]到a[n]中。在以下给出的函数中，不能正确执行此功能的

函数是（ ）

① funa（int *a，int n， int x）

{ *a＝x；

whlie（a[n]！＝x） n——；

return n；

}

② funb（int *a， int n， int x）

{ int k ；

for（ k＝l； k<＝n； k++）

if（a[k]＝＝x） return k；

return 0 ；

}

③ func（int a[]， int n， int x）

{ int * k；

a[O]＝x； k＝a＋n；

while（*k！＝x）k——；

return k－n；

}

④ fund（int a[]， int n， int x）

{ int k＝0；

do k++；

while（（k） &&（A[K]！ =X））；

if（（k＋1） &&[K]＝＝X）） RETURN K；

else return 0；

}

「解」在数组中找指定值是经常遇到的计算要求，有多种编程方法。在这里，数据预放

在数组下标1至n的元素中，下标为0的元素没有放数据，程序可以利用这个位置简化查

找函数。函数funa先将要查找的情放入a[0]，从数据表的最后一个元素开始逆序向前查

找。这样做的好处是循环条件不必担心因数组中原先没有值为x的元素而一直顺序查找下

去，访问不是数表的元素，需插入条件n＞O.在a[0] 处放入x后，这个条件就不必要了，

循环至少在访问了a[0] 后终止，并返回0值。所以该函数能完成指定的功能。函数funb

采用常规的办法编写，循环在a[1] 与a[n]之间顺序寻找，一旦找到立即返回找到处的下

标，直至查找循环结束，查不到指定的值而返回0值。函数func采用与函数funa相同的

方法，不过是另外引入一个指针变量。但是该函数return语句后的表达式有严重的错误，

应返回k－a，两指针的差，其值等于找到元素的下标。表达式k－n是指针k向前移n个

位置的指针值。函数fund预置k为0，循环让 k增 1，并在 k在界内和 a[k] 不等于 x

的情况下循环。循环结束有两种情况，或 k已不在界内，或k在界内，并且a[k]等于x.

若是后者，函数返回k，而若前者，函数返回比该函数也能正确完成查找工作。这样，不能

正确完成查找工作的函数是函数fonc.所以正确选择是③。

6.以下程序的输出结果是（ ）

# include

subl（char a，char b） {char c；c＝a；a＝b；b=c；}

sub2（char *a，char b）{ char c；c＝*a；*a＝b；b＝c；}

sub3（char *a，char *b） { char c；c＝*a；*a＝*b；*b＝c；}

main（）

{ char a， b；

a＝‘A’； b＝‘B’； sub3（&a，&b）； putchar（a）； putchar（b）；

a＝‘A’；b＝‘B’ ；Sub2（&a，b）；putchar（a）； rutchar（b）；

a=‘A’； b=‘B’； sub1（a，b）； putchar（a）；putchar（b）；

}

①BABBAB ②ABBBBA

③ BABABA ④ BAABBA

「解」在上述程序中，函数subl完成两形参值的交换，这个交换不影响实参变量，这

是一个没有意义的函数。函数sub2将第二个形参的值置入由第一个指针形参所指的变量中，

指针形参所指的变量由调用时的实参提供。函数sub3完成将两个形参所指的变量的值交换。

程序调用sub3，使变量a和b的值交换输出BA；调用subZ，使变量b的值传送到a，

输出BB；调用subl，变量a和b的值不改变，输出AB.所以程序输出BABBAB.正确解答

是①。

6.2 填充题

1.静态型内部变量的作用域是___________.

「解」静态存储类型的主要特性是永久性和专用性。静态局部变量提供永久存储，但因

它是局部变量，也得遵守局部变量的作用域规则，是定义它的函数或复合语句。

2.函数中的形参和调用时的实参都是数组名时，传递方式为_____＿；都是变量时，

传递方式为_____________.

「解」在C语言中，实参向形参传递方式只有值传递，但传递的内容可能是非指针类

型的值，如基本类型值，或结构类型值，也可以是指针类型值。通常传递指针类型值特称为

传地址方式。其中实参向指针形参传递数组名，就是一种传地址方式。若形参不是指针类型

的，形参是一般的变量，实参可以是变量或表达式，就是值传递方式。

3.函数的形式参数的作用域为_____，全局的外部变量和函数体内定义的局部变量重

名时，________变量优先。

「解」函数将它的形参当作它的局部变量，所以函数形参的作用城为定义它的函数。当

函数的形参或函数内的局部变量与函数外的全局变量同名时，函数的局部变量优先。

4.若自定义函数要求返回一个值，则应在该函数体中有一条________语句，若自定

义函数要求不返回一个值，则应在该函数说明时加一个类型符____________.

「解」苦自定义的函数有返回值，则函数返回时应执行带表达式的return语句返回，

该表达式的值将作为函数调用的结果。为了强调函数是一个不返回值的函数，应在该函数说

明时，加上一个void类型说明符。

5.若给fun函数的形参s传送字符串：“ㄩㄩ 6354abcc”（其中ㄩ表示空格字符），

则函数的返回值是__________.

# include

long fun（char s[]）

{ long n；int sign；

for（； isspace（*s）； s++）；

sign＝（*s＝＝‘-’ ）？－1：l；

if（*s＝＝‘＋’ ||*s＝＝‘－’） s++；

for（n＝0； isdigit（*s）； s++） n＝10*n＋（*s－‘0’）；

return sign *n；

}

「解」函数fun的第一个for循环跳过字符串的前导空白符，接着分析第一个非空白符

是否是负号，若是置变量sign为-1；否则，置变量sign为1.接着的if语句在第一个非空

白字符是负号或正号时，跳过该字符。以后的for循环将后面的数字符当作十进制数的各位

数字译出一个长整数n.遇字符a时，结束译数循环。最后，函数返回sign与n的乘积。所

以若调用函数时提供的实参是“ㄩㄩ6354abc”，函数返回值是整数6354.

6.下面函数要求计算两个整数X、y之和，并通过形参Z传回该和值，请填空。

void add（int x，int y，________z）

{_________＝x＋ y； return；}

「解」函数希望通过形参z传送结果，形参z必须是指针类型的，由于返回整型结果，

所以z的说明是int *z.函数返回前必须先把结果通过形参z间接引用（写成* z）传回。

7.以下函数用来在w数组中插入x.在n所指向的存储单元中存放着w数组中的字符个数。

数组W中的字符已按从小到大的顺序排列，插入后数组W中的字符仍有序。请填空。

void fun（char *w，char x， int *n）

{ int i， p；

p＝0；

w[*n]＝x；

whlie（ x>w[p] ） p++；

for（i=* n； i>p；i——） w＝_____________；

w[p] ＝ x；

++ *n；

}

「解」在用数组实现的有序序列中插入内容，必须先寻找插入位置。插入位置找到后，

需将插入位置之后的元素向后移动一个位置，留出插入点。最后，将元素插入，并增加序列

的元素个数。函数为了简化寻找插入位置循环的循环条件，预先在序列的最后置人插入值。

插入位置之后的元素向后移动一个位置必须从最后一个元素开始往前逆序移动，是将前一个

元素向后移，所以在空框处应填入w[i－l] .

7.函数my_cmp（）的功能是比较字符串s和t的大小，当S等于t时返回0，否则返回

s和t的第一个不同字符的ASCII码差值，即s>t时返回正值，当s时返回负值。请填

空。

my_cmp（ char *s， char * t）

{while（*s＝＝* t）

{ if（*s＝＝‘0’） return 0 ；

++s；++t；

}

return____________；

}

「解」两字符串大小比较必须从它们的首字符开始，在对应字将相等情况下循环，直至

不相等结束。相等时，老字符率已到了字符串的结束标记符，则两字符率相同，函数退回0

值；如还有后继字符，则准备比较下一对字符。对应字符不相同，循环结束。循环结束时，

就以两个当前字符的差返回。所以在空框处应填入*s-*t，保证在s>t时返回正值，当s

时返回负值。

6.3 程序分析题

1.阅读函数，写出函数的主要功能：

ch（int *p1，int *p2）

{ int p；

if（*pl>*p2） { p＝* pl；*pl＝*p2；* p2＝p； }

}

「解」函数办有两个指针形参p1和p2，函数体通过*pl和*p2间接引用它们所指变

量。当pl所指变量的位大于p2所指变量的值时，交换两形参所指变量的值。所以函数的

功能当形参1所指变量比形参2所指变量的值大时，交换这两个变量的值。调用该函数能

保证形参1所指变量的值不大于形参2所指变量的值。

2.阅读函数，写出函数的主要功能：

float av（a，n）

float a[]；

int n；

{ int i； float s；

for（i＝0，s＝ 0；i；I++） S＝S＋A[I]；

return s/n；

}

「解」函数有一个数组形参a和一个整型形参n.函数首先用循环求数组a的前n个元

素和，然后将和除以n.即求数组元素的平均值。

3.阅读下面程序，写出运算结果。

unsigned fun6（ unsigned num）

{ unsigned k＝l；

do { k*＝ num；num/＝10；}

while（n） ；

return k；

}

main（）

{ unsigned n＝26；

printf（“%dn”， fun6（n））；

}

「解」函数有一个形参num，循环前变量 k置 1，循环中，表达式num是取num

的个位，将num的个位值累乘于k中，然后num除以10.循环直至num为0结束，这

是逐一求出num十进制表示的各位数字，并累乘于变量k的循环。函数最后返回k.函数

fun6的功能是求整数的各位十进数字积。所以程序输出12.

6.4 程序设计题

1.编一个名为root的函数，求方程ax*x + bx + c=0的b*b－4ac，并作为函数的

返回值。其中的a、b、c作为函数的形式参数。

「解」该函数应设3个形参，分别表示一元二次方程的三个系数。函数按公式求出结

果返回即可：

double root（double a，double b，double c）

{ return b*b＋4.0*a*c；

}

2.编一个函数，若参数y为闰年，则返回1；否则返回0.

「解」由每四年一个闰年，但每100年少一个闰年，每400年又增加一个闰年的约定。

记年份为y，则y年是闰年的条件是：

（y能被4整除，但不能被100整除）或（y能被400整除）

用逻辑表达式可描述如下：

（y%4＝＝0 && y0） ||y@0＝＝0

写成函数为：

int isLeap（int y）

{ return（ y% 4＝＝0 && y% 100） || y@0＝＝ 0；

}

3.编一个无返回值，名为root2的函数，要求如下：

形式参数： a，b，c单精度实型，root单精度实型数组名。

功能：计算ax*x +bx＋c＝0的两个实根（设b*b－4ac> 0）存入数组root[2]中。

「解」函数根据形参。a，b，c的值，首先计算d＝b*b-4*a*c.考虑到实数运算时的

计算误差，两个几乎相等的数相减有效位数也几乎全部丢失的情况，应先求出绝对值大的根，

然后利用报与系数之间的关系，再求绝对值小的根。函数定义如下：

void root2（ float a，float b，float c， float root[]）

{ float re，im，d＝b*b－4.0*a*c；/*求判别式*/

re＝－b/（2.0*）；

if（d>＝0.0） { /*有两个实根，先求绝对值大的根*/

im＝（float）sqrt（（double）d）/（2.0*a） ；

root[0] ＝re＋（b<0.0？ im：-im）；

root[1]＝c/（a*root[0]）；

}

}

4.编一个无返回值，名为trus的函数，要求如下：

形式参数：数组s1[2][3]和s2[3][2] 是整型数组。

功能：将s1数组转置后存入s2数组中。

「解」为实现问题要求，可用两重循环，按行按列的顺序遍历数组s1的元素，将它们

分别复制到数组s2的对位位置即可。

void trus（int sl[][3]， int s2[][2]）

{ int i，j ；

for（i＝0； i<2； i++）

for（j＝ 0；j<3； j++）

s2[j] ＝s1[j]；

}

5.编一个名为countc函数，要求如下：

形式参数：array存放字符串的字符型数组名。

功能：统计array数组中存放的字符串中的大写字母的数目。

返回值：字符串中的大写字母的数目。

「解」为统计字符串中大写英文字母的个数，函数引入一个计数变量。通过遍历字符串，

当发现字符率中的字符是大写字母时，计数变量增1.字符率遍历结束，返回计数变量的值。

int counic（char *array）

{ int c＝0；

while（* M） {

if（*array>＝‘A’ && *array<‘Z’） c++；

array ++；

}

return c；

}

6.编一个名为link函数，要求如下：

形式参数：s1[40]，s2[40]，s3[80] 是用于存放字符串字符数组。

功能：将s2连接到s1后存入s3中。

返回值：连接后字符串的长度。

「解」这是要编写两字符串连接拷贝到另一字符串的函数，函数返回连接后的字符串的

长度。实现函数的功能，就是先将s1中的字符串复制到s3，继续将s2中的字符串复制到

s3.

void link（ char *sl， char *s2，char *s3）

{ while（*s3＋＋＝*sl++）；

s3 - - /* 准备复盖字符串结束标记符*/

while（*s3++= * s2++）；

}

7.编一个函数，求一维实型数组前n个元素的最大数、最小数和平均值。函数利用数

组和n两个形参，求得最大值、最小值、平均值，并分别利用另外三个指针形参将求得的

最大值。最小值、平均值传回。本函数无返回值。

「解」函数设一个数组形参a、一个整数形参n、传回最大值的指针形参、传回最小值

的指针形参和传回平均值的指针形参。函数通过遍历找出最大值、最小值和数组的元素和，

最后将数组元素和除以n求得平均值。

void maxMinAve（ double a[]，double n， double *maxp，double *minp，

double *avep）

{double s＝0.0， max＝* a， min＝*a； int m；

while（m——） {

s+=*a；

if（*a> max） max＝* a；

if（*a） MIN＝*A；

a＋＋；

}

*maxp＝ max； *minp＝min； *avep＝ s/n；

}

7.1 单项选择题

1.设有定义“struct {int x；int y；} d[2]＝{{1，3}，{2， 7}}；”，则

printf（“%dn”， d[0].y/d[0].x*d[l].x）；的输出是（ ）

①O ②l

③3 ④6

「解」结构数组d有两个结构元素，每个结构又由两个整型成分组成，初始化后，d[0].x

＝1，d[0].y＝3，d[1].x＝2.所以表达式d[0].y/d[0].x* d[l].x的值是 6.所以正确解答

是④。

2.设有定义“enum term { my， your＝4， his， her＝his＋10}；”，则

printf（“%d，%d，%d，%dn”，my， your， his， her）；

的输出是（ ）

①0，l，2，3 ②0，4，0，10

③0，4，5，15 ④1，4，5，15

「解」按枚举类型定义的规定，枚举类型team的枚举常量对应的整数分别是my=0、

your＝4、his＝5、her＝15.所以语句输出0，4，5，15.正确解答是③。

3.以下对枚举类型名的定义中，正确的是（）

①enum a ={one，two，three}；

② enum a{a1， a2，a3}；

③enum a ={‘1’，‘2’，‘3’}；

④ enum a {“one”，“two”，“three” }；

「解」枚举类型定义的句法是：

enum 枚举类型名 {枚举类型常量1，枚举类型常量2，……}；

其中枚举类型常量都是互不相同的标识符。所以定义enum a {a1，a2，a3 }；

是一个正确的定义。任何在枚举类型名之后接上 =，或用字符常量，或用字符串常量

作为枚举类型常量都是不正确的定义。解答应是②。

4.若有如下定义，则 printf（“%dn”， sizeof（them））；的输出是（ ）

typedef union { lOng x[2]；int y[4]；char z[8]；} MYTYPE；MYTYPE them；

①32 ②16 ③8 ④24

「解」共用型变量的成分是覆盖存储，为共用型变量分配存储时，以其中需要最多存储

字节的成分进行分配。设long型数据占4个字节、int型数据占2个字节。共用型MYTYPE

有三个成分，第一个成分是有两个long型元素的数组，它需要8个字节；第二个成分是有

4个int型元素的数组，它也需要8个字节；第三个成分是有8个字符元素的数组，也是8

个字节。所以MYTYPE类型的共用型变量只需要8个字节。正确解答是③。

5.设有以下说明和定义：

typedef union {long i；int k[5]； char c；} DATE；

struct date {int cat； DATE cow； double dog；} too；

DATE max；

则下列语句的执行结果是（ ）

printh（“%d”，sizeof（struct date）＋sizeof（max））；

① 26 ② 30

③ 18 ④ 8

「解」设long型数据占4个字节、int型数据占2个字节，double数据占8个字节。

共用型DATE有三个成分：long型成分i，有五个int型元素的数组k，char型成分 c.所

以 DATE类型的变量需要10个字节。结构类型date有三个成分：int型成分cat，DATE

共用类型cow， double型成分dog.所以结构类型 date需要20个字节。所以表达式

sizeof（struct date）＋sizeof max的值是30.正确解答是②。

6.根据下面的定义，能打印出字母M的语句是（ ）

struct person {char name[9]； int age； }；

struct person c[1O] = {{“John”，17 }，{“Paul”，19 }，{“Mary”，18 }，{“Adam”，

16 }}；

① printf（“%c”， c[3].name）； ② printf（“%c”， c[3].name[1] ）；

③printf（“%c”，c[2].name[1]）； ④printf（“%c”，c[2].name[0] ）；

「解」结构类型struct person有两个成分：九个元素的字符数组name和一个基本

整型age元素类型为 struct person的数组c有10个元素，其中前四个元素被设定了初

值。在已设定初值的元素中，只有c[2].mame[0]的值是字符M.其余元素及元素的成分都

不是字符比正确解答是④。

7.设有如下定义，则对data中的a成员的正确引用是（ ）

struct sk{int a；float b；} data，*p＝ & data；

①（*p）。data.a ②（*p）。a ③ p -> data.a ④ .a

「解」结构变量data有两个成分a和b.结构指针变量p指向结构变量data.引用结构

变量data的成分a有两种方法：一是直接由变量data引用其自己的成分a，写成data.a；

二是通过指针变量p引用它所指的结构的成分a，这又有两种写法，分别是p -> a和（*p）。

a.正确解答是②。

7.2 填充题

1.运算符“。”称为__________运算符，运算符“ -> ”称为__________运算符。

「解」引用结构变量或共用型变量的成分用成员运算符‘。’，若某指针指向一个结构变

量或共用型变量，通过指针引用它所指变量的成分用指向成员运算符‘ -> ’。

2.设有定义“struct {int a； float b； char c；} abc，*p_abc＝&abc；”，则对

结构体成员a的引用方法可以是abc_________a和p_abc___________a.

「解」若有结构变量abc有成分a，并有指针p_abc指向结构变量abc，则引用变量

abc成分a的标记形式有abc.a和p_abc ->a.

3.若有以下说明和定义语句，则变量W在内存中所占的字节数是__________.

union aa {float x；float y； char c[6]； }；

struct st { union aa v； float w[5]； double ave； } w；

「解」共用型aa有三个成分，一个是float型成分x，一个是float型成分y，再一个

是有六个元素的字符数组。若float型数据占4个字节，则类型aa数据要占用6个字节。

结构变量w有三个成分，一个是共用型成分aa，要占用6个字节；一个是有5个float型

元素的数组w，要占用20个字节；再一个是double型的ave.若doube型数据要8个字

节，则结构变量w要占用34个字节。

7.3 程序分析题

1.阅读下列程序，写出运行结果。（字符0的ASCII码为十六进制的30）

main（）

{ union { char c； char i[4]； } z；

z.i[0]＝ 0x39；z.i[1]＝ 0x36；

printf（“%c n”， z.c）；

}

「解」共用型变量z有两个成分，一个是字符型的c，另一个是有4个字符的数组i.

由于共用型的成分是覆盖存储，成分c的内容也是成分i的首元素。程序给Z的i成分的首

元素置十六进制代码0x39，即十进制数57.数57是字符‘9’的ASCII代码。用字符输出格

式，输出该变量的值，将输出字符‘9’ .

2.阅读下列程序，写出程序的运行结果。

main （）

{ struct student

{ char name[10]；

float k1；

float k2；

} a[2]＝{ {“zhang”， 100，70} ，{“wang”，70，80 } }，* p＝a；

int i；

printf（“nname：%s total＝%f”，p ->name，p -> k1＋p -> k2）；

printf（“nname：%s total＝%f”，a[l].name， a[1].k1＋a[l].k2）；

}

「解」结构数组a 有两个元素，每个元素有三个成分：10个元素的字符数组和两个类

型为float的成分k1、k2.结构指针变量p指向结构数组a的首元素。其中初始化使a的

两个元素分别有值如下：

a[0].name＝“zhang”，a[0].k1＝ 100.0，a[0].k2＝70.0，

a[1].name＝“wang”，

a[l].k1＝70.0， a[1].k2 =80.0.所以程序运行后输出：

name：zhang total = 170.000000

name： wang total＝ 150.000000

3.阅读下列程序，写出程序的运行结果。

main （ ）

{ enum em { em1＝3， em2＝l， em3 }；

char * aa[] = {“AA”，“BB”，“CC”，“DD” } ；

printf（“%s%s%sn”，aa[em1]，aa[em2]， aa[em3] ）；

}

「解」由枚举类型测的定义知，枚举类型常量em1的值是3，枚举类型常量em2的

值是1，枚举类型常量em3的值是2.所以程序运行后输出：

DD BB CC

7.4 程序设计题

1.用结构体存放下表中的数据，然后输出每人的姓名和实发工资（ 基本工资+浮动工

资-支出）。

姓名 基本工资（元） 浮动工资（元） 支出（元）

Li 220.00 300.00 90.00

Xia 370.00 180.00 60.00

Wang 620.00 0.00 70.00

「解」程序定义struct person结构类型，包含人的姓名（<20个字符）、基本工资、

浮动工资和支出，用这个struct person结构类型定义数组。程序首先输入人数n（<100），

再输入n人的信息，最后输出各人的姓名和实发金额。程序如下：

# include

# include

# define N 100

struct person {

char name[20] ；

float base；

float ds；

float pay；

} person[N]， *p；

void main （）

{ int n；

float d；

char buf[120]；

printf（“输入n（<%d）！ n”，N）；

do {

scanf（“%d”， &n）；

if（n>0 && n） BREAK；

printf（“输入n不合理！ 请重新输入！ n” ）；

} while（1）；

printf（“输入%d个人的姓名、基本工资、浮动工资和支出 n”， n）；

for（ p＝person； p＋N； P＋＋） {

scanf（“%s”， buf）； strncpy（ p -> name， buf， 19）；

scanf（“%f”， &d）； p -> base＝d；

scanf（“%f”，&d）； p -> ds＝d；

scanf（“%f”， &d ）； p -> pay＝ d；

}

for（p = person； p< person＋n； p＋＋）

printf（“%s %.2fn”，p-> name，P->base＋p->ds－P -> pay）；

}

2.编一个程序，输入10个职工的编号、姓名、基本工资、职务工资，求出其中“基本工资

十职务工资”最少的职工姓名并输出。

「解」类似上一程序，直接给出程序如下：

# include

# define N 10

struct person {

char no[10]；

char name[20]；

float base1；

float base2；

} person[N]， *p， *minp；

void main （）

{ float d；

char buf[120]；

printf（“输入%d个人的编号、姓名、基本工资、职务工资 n”， N）；

for（p＝person； p＋N； P＋＋） {

scanf（“%s”， buf）； strncpy（p -> no，buf，9）；

scanf（“%s”， buf）； strncpy（ p -> name， buf， 19）；

scanf（“%f”， &d）；p -> base1 =d；

scanf（“%f”，&d）；p -> base2＝d；

}

for（minp＝p＝person； p＋N； P＋＋）

if （p -> basel＋p -> base2< minp -> basel＋ minp -> base2） minp =p；

printf（“基本工资与职务工资和最少的职工是%s n”，minp -> name）；

printf（“他的基本工资与职务工资和是%.2f n”，minp -> basel＋ minp -> base2）；

}

3.编一个程序，输入10个学生的学号、姓名、3门课程的成绩，求出总分最高的学生

姓名并输出。

「解」类似上一程序，直接给出程序如下：

# include

# include

# define N 10

struct stu {

char no[10]；

char name[20]；

int score[3]；

} students[N]，*p， *maxp；

void main（）

{ char buf[120]； int maxs；

printf（“输入%d个学生的编号、姓名、三门课程成绩 n”， N）；

for（p＝ students；p< students＋N；p＋＋） {

scanf（“%s”， buf）； strncpy（p -> no， buf， 9）；

scanf（“%s”， buf）； strncpy（ p -> name， buf，19）；

scanf（“%d%d%d”，&p -> score[O]， &p -> score[1]， &p -> score[2]）；

}

for（maxp= p =students， maxs＝-1； p< students＋N； p＋＋）

if（ p -> score[0] + p -> score[1]＋p -> score[2]> maxs） {

maxp＝p；maxs=p ->score[0]＋p -> score[1]＋p ->score[2]；

}

printf（“最高总分的学生是%s他的总分是 %d n”， maxp -> name， maxs）；

}

4.编一个程序，输入下列学生成绩表中的数据，并用结构体数组存放，然后统计并输出三门

课程的名称和平均分数。

name foxbase pascal c

wang 98.0 87.0 77.0

qian 90.5 91.0 88.0

sun 74.0 77.5 66.5

li 84.5 64.5 55.0

「解」类似上一程序，直接给出程序如下：

# include

# include

# define N 100

struct stu {

char namep[20]；

int foxbase；

int pascal；

int c；

} students[N]， *p；

void main （）

{ int n， sf， sb， sc；

char buf[120]；

printf（“输入n（< %d） ！ n”， N）；

do {

scanf（“%d”， &n）；

if（n>0 && n） BREAK；

printf（“输入 n不合理！ 请重新输入！ n”）；

} while（1）；

printf（“输入%d个人的姓名、Foxbase成绩、Pascal成绩、C成绩 n”， n）；

for（ p＝ students；p< students＋n； p＋＋）；

scanf（“%s”，buf ）；strncpy（p -> name， buf， 19）；

scanf（“%d%d%d”， &p -> foxbase，&p -> pascal，&p -> c）

}

sf＝sb＝sc ＝0；

for（ p＝students； p＋N； P＋＋） {

sf＋＝ p -> foxbase； sb＋＝ p -> pascal； sc＋＝ p -> c；

}

printf（“Foxbase：%.2f t Pascal：%.2f t c：%.2f n”，

（float）sf/n，（float）sb/n，（float）sc/n）；

}

8.1 单项选择题

1.若与文件型指针中相关联的文件的当前读位置已到了文件的末尾，则函数feof（fp）

的返回值是（ ）

①0 ②－l

③非零值 ④NULL

「解」当调用fopen函数时，系统将为实参文件设定一个存放文件读写控制信息的控

制块。该控制块记录有关文件持征、使用方式，当前读写位置等文件状态，并将该控制块的

指针返回，作为文件指针变量的值。以后程序通过该指针调用函数时，系统能访问到这个控

制块，利用该文件控制块中的控制信息，正确完成文件的读或写。所以文件指针并不真正指

向文件当前读写位置，但通过文件指针，系统能在文件控制块中访问文件的当前读写位置。

若某文件与文件指针中相关联着，该文件的当前读写位置在文件的末尾时，函数调用feof

（fp）的返回值是一个非零值。所以正确解答是③。

2.下列语句中，将C定义为文件型指针的是（ ）

① FILE c； ② FILE *c； ③ file c； ④ file *c；

「解」如上题所述，文件控制块的类型已由系统命名为FILE.所以定义文件指针变量是

C，就得用代码：“FILE *c；”。所以正确解答是②。

3.标准库函数fputs（pl，p2）的功能是（ ）

①从pl指向的文件中读一个字符率存入p2指向的内存

②从p2指向的文件中读一个字符串存入pl指向的内存

③从pl指向的内存中的一个字符串输出到p2指向的文件

④从p2指向的内存中的一个字符串输出到pl指向的文件

「解」标准函数调用fputs（p1，p2）完成的功能是将由字符指针pl所指的字符串内

容输出到与文件指针p2相关联的文件中，即将从pl所指的内存中的字符串内容输出到p2

所指向的文件中。所以正确解答是③。

8.2 填充题

1.“FILE *p”的作用是定义一个______，其中的“FILE”是在________头文件中定义

的。

「解」代码“FILE *p”的作用是定义一个文件指针变量，其中的FILE是在标准输入输

出头文件stdio.h中定义的。

2.在对文件进行操作的过程中，若要求文件的现行位置回到文件的开头，应当调用的函

数是_______函数。

「解」若要让文件随机地从某个现行位置回到文件的开头，可调用库函数rewind（ ）。

f2）；

}

fclose（f1）；

fclose（f2）；

}

「解」程序首先以读方式打开文件pl.c，以写方式打开文件P2.c.程序在文件pl.c未结

束之前读入l000个字符复制到文件p2.c.然后关闭这两个文件。所以程序的功能是将文件

pl.c的前l000个字符复制到文件p2.c.子目录字符‘’在C语言中作为转义字符的引导字符，

若在字符串中要用这个字符，必须双写该字符。如C盘根目录tc子目录文件p1.c，在C

程序中应写成字符串“c：tc pl.c.

2.假定在当前盘当前目录下有2个文本文件，其名称和内容如下：

文件名

内容 121314 # 252627#

写出运行下列程序后的输出。

# include

# include

void fc（ FILE *）；

main（）

{ FILE *fp；

if（ fP＝ fopen（“”， “r”））＝＝ NULL）

{ printf（“Can not open file！ n”）；

exit（l）；

}

else{ fc（fp）； fclose（fp）； }

if（（ fp = fopen（“”，“r”））＝＝NULL）

{ printf（“Can not open file！ n”）；

exit（1）；

}

else { fc（fp）； fclose（fp）； }

}

void fc（fp1）

FILE *fpl；

{ char c；

while（（c＝fgetc（fpl））！＝‘#’） putchar（c）；

}

「解」程序以读方式打开文件，若能正常打开，则调用函数fc.接着同样地，以

读方式打开文件，若能正常打开，也调用函数fc.函数企从指定的文件读入字符，在

读入字符不是字符‘#’情况下循环，将读人字符输出。对于文件，程序输出121314，

对于文件，程序输出252627.所以程序输出7.

8.4 程序设计题

1.编一个程序，从键盘输入200个字符，存入名为“”的磁盘文件中。

「解」要将从键盘输入的字符写到指定的文件，程序要定义一个文件指针变量，并以写

方式打开指定的文件，然后是一个循环，反复从键盘读人字符，将读人字符复制到文件。程

序如下：

# include

# include

FILE * fp；

void main（）

{ int i， ch；

if（（ fp =fopen（“”，“w”））＝＝ NULL） {

prinit（“Can‘t open file %s.n”，“”）； exit（0）；

}

printf（“Enter 200 characters. n”）；

for（ i = 1；i<＝200；i＋＋） {

ch＝ getchar（）；

if（ ch＝＝ EOF） break；

fputc（ ch，fp）；

}

fclose（fp）；

}

2.从上一题中建立的名为“”的磁盘文件中读取120个字符，并显示在屏幕上。

「解」要从指定文件读入字符显示，要以读方式打开，并用循环控制从文件读人字符。

程序如下：

# include

# include

FILE * fp；

void main（）

{ int i；

if（（ fp =fopen（“”，“r” ））＝＝ NULL） {

printf（“Can‘t open file %s.n”，“” ）； exit（0）；

}

for（i＝l； i<＝120； i＋＋ ） {

if（feof（fp）） break；

putchar（ fgetc（fp））；

}

fclose（fp）；

printf（“n”）；

}

3.编一个程序，将磁盘中的当前目录下名为“” 的文本文件复制在同一目录下，文

件名改为“”。

「解」程序需要两个文件指针变量，一个对应读文件，另一个对应写文件。并分别用读

和写方式打开两个文件。

接着是以读文件状态作为循环控制条件，在读文件还未结束下循环，反复读人字符，并

将读人字符复写到写文件中。程序如下：

# include

# include

FILE * rp， * wp；

void main（）

{ int c；

if（（rp＝ fopen（“”，“r”））＝＝ NULL） {

printf（“Can‘t open file %s.n”，“”）； exit（0）；

}

if（（wp＝ fopen（“”，“w”））＝＝ NULL） {

printf（“Can‘t open file %s.n”，“”）； exit（0）；

}

while（（c＝ fgetc（rp））！= EOF）

fputc（ c，wp）；

fclose（wp）；

fclose（rp）；

}

4.编程序，对名为“”的磁盘文件中“＠”之前的所有字符加密，加密方法是每

个字节的内容减10.

「解」程序从文件读出字符，在字符“＠”未出现之前，将读出字符作加密处理后回写。

加密循环受文件结束或当前字符是“＠”字符控制。程序如下：

# include

# include

# define DALTA 10

FILE * rp；

void main（）

{ int c；

if（（ rp = fopen（“”，“r+”）） ==NULL ） {

printf（“Can‘t open file %s.n”，“”）； exit（0）；

}

while（（ c＝ fgetc（rp））！= EOF） {

if（ c ＝＝‘＠’） break；

c＋＝ DALTA；

fseek（ rp，－1L，1 ）；

fputc（ c， rp）；

fseek（ rp，OL，l）；

}

fclose（rp）；

}

5.编程序，对上一题中名为“”的磁盘文件中“＠”之前的所有字符解密并显示。

「解」要编写的程序完成与上一程序功能相反的工作，将上述程序中的DALTA定义成

一10即可。完整程序略。

6.输入100个学生的信息（含学号、姓名、年龄、七门课程成绩、总分），其中学生

的总分由程序计算产生。先将学生信息存入磁盘二进制数据文件中。然后再

读取该文件，寻找总分最高的学生并输出该生的所有信息。

「解」程序要定义一个结构，逐一输入学生信息，并完成学生的总分计算，将学生信息

存到该结构中，然后将该结构信息存入文件。设学生信息的输入以学生的学号为负数结束。

然后，程序再用循环从这文件读入学生信息，将其中总分更高的学生信息存入另一结构中。

循环结束后，结构中存储的就是总分最高学生的信息。最后，显示这总分最高的学生信息。

程序如下：

# include

# include

# include

struct stu {

long no；

char name[20]；

int age；

int score[7]；

int total；

} student， maxs；

FILE *fp；

void main（）

{ char buf[120]；int total，i，t；long lt；

if（（fp＝ fopen（“”，“wb”））＝＝ NULL） {

printf（“Can‘t open file %s.n”，“” ）；exit（0）；

}

printf（“输入学生的学号、姓名、年龄、七门课程成绩（学号小于0结束） n”）；

while（1） {

scanf（“%ld”， <）； = lt；

if（< 0） break；

scanf（“%s”， buf）； strncpy（ ， buf，19）；

scanf（“%d”， &t）； = t；

for（ total = 0， i = 0； i < 7；i＋＋） {

scanf（“%d”，&t）； ＝ t；

total＋＝ t；

}

＝ total；

fwrite（char *） & student，sizeof student， 1， fp）；

}

fclose（fp）；

if（（fp ＝ fopen（“”，“rb”））＝＝ NULL） {

printf（“Can‘t open file %s.n”，“”）；exit（0）；

}

＝－100；

While（ ！feof（fp）） {

fread（（char *） & student，sizeof student，l，fp）；

if（ > ） maxs＝student；

}

fclose（fp）；

printf（“总分最高的学生信息：n”）；

printf（“学号：%ld”， ）；

printf（“ t姓名：%s”，maxs，name）；

printf（“t年龄：：%dn成绩：”， ）

for（ i＝0； i< 7； i＋＋）

printf（“m”，）；

printf（“nTOTAL = %dn”， maxs. total）；

}

9.1 单项选择题

1.在下列代码中，正确的C代码是（ ）

①# define MYNAME＝“ABC”

②# include string.h

③ for（i＝0；i<10； i＋＋）；

④ struct int stu { int name }；

「解」①是关于宏定义的，在宏的定义形式中，宏名与字符列之间至少有一个空白符，

并在宏名希望代表的字符序列之间也不能有任何非空格类字符，若有也被当作是字符序列的

一部分。有了宏定义，以后程序中若要有宏名后的字符序列就可简写成宏名。选择①在宏名

之后紧接字符=.②是关于包含命令的，在上述包含命令的格式中，被包含文件应放在一对

尖括号之间，或一对双引号之间，不可在文件名字符列的首末没有这种符号。③是for语句，

for语句的循环体可以用空语句，从语言的句法规则来说，该语句是正确的。但通常循环是

为了完成某种重复计算操作，单一地让一个变量循环增1到某个值，程序员是不会编写这

种代码的。④是想定义结构类型，定义结构时，struct后接结构类型名，不可在结构名之

前插入某些其它类型符。正确解答是③。

2.在下列代码中，正确的C代码是（ ）

①# define PI＝3.14159

② include“stdio.h”

③ for（i＝0，i<10， i＋＋） a＋＋；

④static struct { int i；} b ={2}；

「解」①定定义时，宏名与被定义的字符列之间不可以插入等号等其它字符。选择答案

②是包含文件预处理，所有的预处理命令都应由字符# 开始于新的一行。③在写for语句

时，其中的三个表达式必须用字符“；”分隔。④在定义结构变量时，结构的类型名可以省缺，

并可为结构变量赋初值。为结构变量赋初值，必须顺序给出各成分的初值，并将初值写在一

对花括号中。这里给出的结构变量定义的代码是正确的。正确解答是④。

3.在下列代码中，错误的C代码是（ ）

①# define PI 3.14159

②# include“stdio.h”；

③ if（2）；

④ for（；；） if（1） break；

「解」①是正确的宏定义。②的文件包含预处理命令行不可以有多余的分号字符。③是

if语句，虽没有任何意义，但就句法来说是正确的。④是for语句，其成分语句是if语句，

从for语句来说，是一个无穷循环的控制结构，但它的成分语句因条件成立，执行break

语句，立即退出循环。同样虽也是一条没有任何意义的语句，但从句法规则来说，也是正确

的。正确解答是②。

4.设有以下定义，则执行语句“z＝2*（N＋Y（5＋1））；”后，z的值为（ ）

# define N 3

# define Y（n）（（N＋l）*n）

①出错 ②42 ③48 ④54

「解」在新的宏定义中，可以使用前面已定义的宏名。另外，宏调用是这样被替换展开

的，分别用宏调用中的实在参数字符序列替换定定义字符序列中对应所有出现的形式参数。

而宏定义字符序列中的不是形式参数的其他字符则保留。这样形成的字符序列，即为宏调用

的展开替换结果。所以代码“z＝2*（N＋Y（5＋1））；”被替换成：

z＝2*（3＋（（3＋1）*5＋1））；

执行该代码，将使Z的值为48.解答为③。

5.以下程序中的for循环执行的次数是（ ）

# include

# define N 2

# define M N+1

# define NUM（M＋l）* M/2

main（）

{ int i， n＝0；

for（ i＝ l； i<＝NUM；i++） { n++； printf（“%d”，n）； }

printf（“n”）；

}

①5 ②6 ③8 ④9

「解」代码NUM被替换成（2＋1＋1）*2＋1/2，所以其值是8.所以程序中的脸循环

执行的次数是8次。正确解答是③。

9.2 填充题

1.设有定义“# define F（N） 2*N”，则表达式 F（2＋）的值是_____.

「解」F（N）被定义成2*N，表达式F（2＋3）被替换成2*2＋3，其值是7.

2.设有下列程序：

# include

main（int argc，int *argv[]）

{ while（ ——argc> 0） printf（“%s”，argv[argc]）；

printf（“n”）；

}

假定上述程序编译连接成目标程序名为，如果输入如下的命令：

P 123 AAA BBB ↓（其中的↓表示回车）

则输出结果是_____.

「解」程序启动时，参数argc的值是4，由于循环条件是一即组>0，是先减1后判

大于0，循环共进行三次，顺序输出argv[3]，argv[2]和argv[1]，即输出BBBAAAl23.

9.3 程序分析题

1.阅读下面程序，写出程序运行结果。

# define PR（ar） printf（“%d，”， ar）

main（）

{ int j，a[] ={1，3，5，7， 9，11，15}， * p＝ a＋5；

for（j＝3； j； j——）

switch（j） { case 1：

case 2： PR（ * p＋＋）； break；

case 3： PR（*（——p））；

}

printf（“n”）；

}

「解」程序的宏定义PR以d格式输出参数的值和远号字符。程序给数组a 赋初值，

并由指针p指向元素a[5].程序让j从3减至1，共循环三次。当j是3时，让p减1，并

输出p所指元素的值9；当 j是2和1时，输出p所指的数组元素的值，并让p增1，顺

序输出9和11.所以

程序输出：

9，9，11

2.设下面的程序经编译连接后生成的目标程序名为： ，写出输入以下命令行

后的输出：

ABC FILE1 FILE2 ↓（其中的↓表示回车）

# include

main（ int argc， char *argv[]）

{ int i；

printf（“%d n”，argc）；

for（i＝O；i；I＋＋） PRINTF（“%S”，ARGV[I]）；

printf（“n”）；

}

「解」程序首先输出参数argv的值3，然后循环三次，顺序输出ABC、FILE1和FILE2，

并回车

3

ABC FILE1 FILE2

3.读程序，写功能。

# include

# include

main（int argc， char *argv[]）

{ FILE *fl，*f2；

char ch；

if（argc< 3）

{ printf（“Parameters missing！ n”）；exit（0）； }

if（（（f1 =fopen（argv[1]，“r”））＝＝ NULL） ||

（（f2＝fopen（argv[2]，“w”））＝＝ NULL））

{ printf（“Can not open file！ n”）； exit（0）； }

while（！feof（f1）） fputc（fgetc（f1），f2）；

fclose（f1）；

fclose（f2）；

}

「解」程序在argc小于3时，报告出错信息结束。当argc大于2时，以程序启动时

的第一和第二参数为文件名打开文件，井用循环将第一参数的文件内容复制到第二参数的文

件。

9.4 程序设计题

1.设计一个复制文本文件的程序，源文件名和目标文件名随程序启动执行命令输入。

「解」直接写出程序如下：

# include

FILE *rfp，*wfp；

int main（ int argc， char *argv[]）

{

if（ argc < 3） {

printf（“Parameters missing ！ n”）； return 0 ；

}

if（（（rfp＝ fopen（argv[1]，“r”））＝＝ NULL） ||

（（＝fopen（argv[2]，“w”））＝＝ NLILL）） {

printf（“不能打开文件n”）；

return 0；

}

while（ ！ feof（rfp））

fputc（ fgetc（rfp）， wfp）；

fclose（wfp）；fclose（rfp）；

printf（“程序结束n”）；

return l；

}

2.设计一个程序，将随启动程序执行时输入的两个整数的和、差、积、整除商、模运算的结

果输出。 「解」直接写出程序如下：

# include

main（ int argc，char *argv[]）

{ int tl，t2；

if（ argc < 3） {

printf（“Parmenters missing！n”）； return 0；

}

t1＝atoi（ argv[l] ）；t2＝atoi（ argv[2] ）；

printf（“%d＋%d＝%dn”， t1， t2， t1＋t2）；

printf（“%d－%d＝%dn”， t1，t1，t1－t2）；

printf（“%d*%d＝%d n”，t1，t2，t1*t2）；

printf（“%d/%d＝%dn”，t1，t2， t1/t2）；

printf（“%d% %d＝%dn”，t1，t2， t1%t2）；

}

3.设计一个比较字符串的程序，两个字符串随启动程序执行的命令输入，输出其中大的

字符串。

「解」直接写出程序如下：

# include

main（int argc，char *argv[]）

{ char *s1，*s2；

if（ argc < 3） {

printf（“Parameters missing！ n”）；return 0；

}

for（s1＝argv[1]，s2＝argv[2]；*s1 && *s1＝＝*s2；s1++，s2++ ）；

printf（“%sn”，*s1< *s2？ argv[2]：argv[1]）；

}

3.下面的程序用来统计文件中字符的个数，请填空。

# include

# include

main（）

{ FILE *fp；

long num＝0；

if（（ fp =fopen（“”，“r”））＝＝ NULL）

{ printf（“Cann‘t open file！ n”）； etit（0）； }

while________ { fgetc（fp）； num++； }

printf（“num =%d n”。 num）；

fclose（fp）；

}

「解」若要统计文件中的字符个数，程序设计一个计数器，并预置该计数器为0值，

并打开文件。在正确打开情况下，接着是一个循环。循环在文件未结束的情况下，反复读人

字符，并增加字符计数器。所以循环条件可写成：！feof（fp）。程序有一个错误，由于

num变量的类型是long型的，输出它的值应在格式符d之前加上格式修饰符‘l’，不加这

个修饰符只有在long型与int型实现相同的系统才是正确的。另外，要统计文件的长度，

最好用二进制方式打开，通过读入的字节数求出文件的长。这是因为正文文件方式打开时，

文件中的双字符（回车字符和换行字符）读入后将被当作一个字符存储，二进制方式不进行

这样的转换。

8.3 程序分析题

1.读程序，写功能。

# include

# include

main（）

{ FILE *f1，* f2；

int k；

if（（ f1＝ fopen（“c：tc pl.c”，“r” ）＝＝ NULL）

{ printf（“Can not open file！ n”）；

exit（0）；

}

if（（f2＝ fopen（“a： pl.c”，“w” ））＝＝ NULL）

{ printf（“Can not open file！ n” ）；

exit（0） ；

}

for（ k＝1；k<＝l000；k＋＋）

{ if（ feof（f1）） break；

fputc（ fgetc（f1），