第一章 C语言基础知识
一，选择题
1 答案是A
A正确
B {}可以作为复合语句的标志
C main 函数不是用户命名的
D 分号是语句结束的标志，肯定是语句的一部分
做这个题目需要对书上的概念透彻的理解
2 答案是A
A 错误 用户标识符:命名时，标识符的选择由用户自定，但是不能与关键字相同，所以A选项错误。这个题目考察用户标识符
3 答案是B
用户标识符是标识符，所以可以是有下划线，但是中划线不属于字母，
数字，下划线其中一种。这个题目考察用户标识符的概念。
4 答案是B
define 是预定义标识符，而预定义标识符可以是用户标识符，所以
define可以是用户标识，if 是关键字，而关键字不能是用户标识符，
所以if不可以是用户标识符
5 答案是D
long 是关键字，参照附录二
注：6--13 考察用户标识符概念
6 答案是D
D答案以数字2开头了，不符合标识符定义
7 答案是C
C答案以数字开头了
8 答案是D
int 是关键字
9 答案是B
答案A 是关键字，答案C是以数字开头了，不符合概念，答案D出
现了小数点
10 答案是A
答案A出现了小数点
11 答案是C
答案C 以数字开头了
12 答案是A
B答案中float 是关键字，C答案中3c以数字3开头了，D答案中-5d
中 - 不属于字母，数字，下划线中一种
13 答案是A
B答案中-max中-错误，C答案中3COM以字母3开头了，D答案中
int 是关键字，不是用户标识符
14 答案是B
A答案中15. 后面不应该有点，C答案中出现了逗号，D中字母B有
问题
15 答案是D
Visual C++6.0中int类型的变量占的字节数为4。
16 答案是B
B中出现了8，而八进制只能有0到7组成
17 答案是D
答案D中开头是0不是o
18 答案是C
答案A中E后面是整数，0.5是小数
答案B 中E后面不能为空
答案D中E前面不能为空
本题目考察指数的表示形式
19 答案是C
答案A中2.0有问题，不能为小数形式
答案B中E前面不能为空
答案D中E后面不能为空
本题目考察指数的表示形式
20 答案是A
B中八进制中不能出现数字8，C中e后面不能是小数，D中e后面
不能为空
21 答案是B
B中0.4是小数，不正确
22 答案是C
C中0.5是小数，不正确
23 答案是D
3.6-5/2+1.2+5%2=3.6-2+1.2+1=3.8
本题目考察算术运算符，需要注意整数除以整数结果只能是整数
24 答案是D
%不能用于实型的计算
25 答案是D
D答案中$不属于字母，数字，下划线
26 答案是 A
A答案是逗号表达式，B答案中x+1=y是赋值表达式，左边只能是变
量，而这里是x+1, 同理答案C中x+10也是错误的，在D答案中，
考察的是强制类型转换，
正确的是(double)x/10
27 答案是 A
本题考察的是注释需要注意的地方，具体解答见课本第2页中间部分
28 答案是B
答案A中n2没有定义，答案C中在定义f之前不能使用它，答案D
中E后面必须是整数
29 答案是 C
考察的是强制类型转换，正确的是k%(int)f
30 答案是 D
本题目类似与第七课时的例一，解题方法是要抓住++m,--n,--m,
表达式的值是变量变化之后的值，而n--表达式的值是变量n变化之
前的值
31 答案是B
本题目考察的是负
整数与无符号正整数在计算机中存放的格式的一样的，但表示的不
同的两个数
32 答案是C
A答案中%运算对象不能为实型，26.8错误，B答案中考察的赋值
运算符，赋值运算符左边必须是变量，所以赋值运算符左边1+2错
误，同理答案D错误
33 答案是 C
本题目考察的是课本第15页的关于自加与自减运算符的第一点说
明，即增量运算符的运算对象只能是变量，而在C答案中++(i+1)
中，i+1是表达式
34 答案是 B
本题目考察的是整数除以整数结果是整数，在B答案中1/2结果是0，导致整个表达式的值是0，明显是错误的
35 答案是D
对于++、--单目运算符来说，其运算对象可以是char型、int型和float型变量
36 答案是A
本题目主要考察n++表达式的值是n变化之前的值，然后使n的值增加1
37 答案是 B
c=a/b+0.4 c=8/5+0.4 c=1+0.4 c=1.4 因为c 是int 型的，所以c的值是1 ，做此题目需要仔细阅读题目
38 答案是 D
(int)a+b/b=(int)5.5+2.5/2.5=5+1.000000=b=6.000000
同样a,b的类型是double型的
39 答案是D
long 和short不能相互修饰
40 答案是 C
标识符中不能有$
41 答案是C
A选项中，在变量赋值时不能赋给表达式，而y*5是表达式；选项B中进行强制类型转换时，类型标识符要加上括号，所以错误；选项D中，%（求余运算符）运算对象只能是整形数。
42 答案是 A
选项A中，b变量还没有定义
43 答案是C
选项A中long是关键字；选项B中“-”符号不属于字母、数字或下划线；选项D中，int是关键字。
44 答案是 B
选项A中，八进制数只能由0—7之间的数字组成；选项C，十六进制数应该以0X开头，并且由0—9以及a—f组成，Oabc不正确；选项D中10，000包含逗号，不正确。
45 答案是B
C语言的标识符中只能包含字线、数字和下划线，没有连接符。
46 答案是 C
既然在内存中，字符数据以 ASCII 码存储，它的存储形式就与整数的存储形式类似。这样使字符型数据和整型数据之间可以通用。一个字符数据既可以以字符形式输出，也可以以整数形式输出。以字符形式输出时，需要先将存储单元中的 ASCII 码转换成相应字符，然后输出。以整数形式输出时，直接将 ASCII 码作为整数输出。也可以对字符数据进行算术运算，此时相当于对它们的 ASCII 码进行算术运算。
47 答案是D
不同的计算机系统或者编译系统，对3种整数类型所占用的字节数有不同的规定。
48 答案是A
选项B中求余运算（%）的运算对象必须是整型；选项C中，赋值运算符（=）的左边必须是变量，不能是常量或表达式；选项D与选项C同理。
49 答案是 A
++运算符有前缀和后缀两种形式，本题中的选项C就是前缀形式，其表达式的值为增1后的值，而选项A为后缀形式，其表达式的值为增1之前的值。而选项B和D的表达式都是k加1之后的值
50 答案是A
51 答案是C
选项A中将一个变量j的值赋给了一个表达式，这种写法是错误的，只能给变量赋值，而不能给常量和表达式赋值；选项B中强制类型转换的格式使用出错，强制类型转换时，类型标识符必须用括号括起来；选项D中，求余运算符（%）的两端必须是整形数。
52 答案是 D
字符常量是用单引号括起来的单个字符，所以选项B错误；此外还有一种特殊的字符专为控制设计，称为转义字符，有三种转义字符：一种是由一个“\”开头加一个普通字符组成，代表一个字符。如’\’’表示一个单引号字符，所以选项D正确；’\\’表示一个斜杠字符，而选项C中的’\’则是错误的；用“\”与其后的1~3位八进制数字构成的字符序列，表示ASCII码等值于该八进制数的字符；用“\x”与其后的1~2位十六进制数字构成的字符序列，表示ASCII码等值于该十六进制数的字符；所以选项A错误。
53 答案是B
字符常量是用单引号括起来的单个字符，所以选项A正确；此外还有一种特殊的字符专为控制设计，称为转义字符，有三种转义字符：一种是由一个“\”开头加一个普通字符组成，代表一个字符。如’\n’表示一个换行符，所以选项D正确；用“\”与其后的1~3位八进制数字构成的字符序列，表示ASCII码等值于该八进制数的字符，所以选项B错误，因为9不是八进制数字；用“\x”与其后的1~2位十六进制数字构成的字符序列，表示ASCII码等值于该十六进制数的字符；所以选项C正确。
54 答案是D
大写字母的ASCII码值比小写字母的ASCII码值小32
55 答案是 A
选项A中的字符变量ch只能接收单个字符，‘ab’不是单个字符，所以错误。
56 答案是B
char x=’C’将一个大写字母赋给了字符型变量x；然后通过x=x+32将x中字符的ASCII码值加32，即为小写字符’c’的ASCII码值；然后将x以字符形式输出，即为小写字母c。
57 答案是A
语句char x,y；定义两个字符型变量x，y；然后通过x=’B’-‘A’+’a’将用大写字母B的ASCII码送去大写字母A的ASCII码，结果便为1，然后再加上小写字每a的AS CII码，结果就为小写字母b的ASCII码，然后再赋值给变量x；通过y=x+2，将变量x中的ASCII码值加2，即变成小写字母d的ASCII码值再赋值给变量y;然后以数值形式输出变量x中的ASCII码值为98，再以字符形式输出变量y中的字符为d。
58 答案是 B
选项A中字符’0’的ASCII码值为48，所以A的结果不为1；选项B中’\0’代表空值，空值NULL的ASCII码值为0所以结果为1；选项C中字符’1’的ASCII码值为49，所以结果不为1；选项D相当于用0-48结果也不为1。
59 答案是 D
如果要表示十六进制字符，则要用’\x’开头，所以选项A错误；如果要表示八进制，则’\0’开头，后面跟1~3位的八进制数，八进制数由0~7组成，不包含8，所以选项B错误；用单引号括起来的单个字符才是字符常量，所以C错误；而’\n’是转义字符，用来表示回车符。
60 答案是B
用单引号括起来的单个字符，称为字符常量，所以选项B错误。
61 答案是C
先将c1 变量中的字符的ASCII码值输出，即为65，将变量c2中字符的ASCII码值减2后输出，即为66。
62 答案是 A
我们知道异或运算，只有两个操作数不同，结果才为1。所以0^1=1，1^1=0，由此可推理，任何数与1进行异或运算都得它的相反数；变量b中的高4位为1，所以要让变量a的高4位取反，即可让变量a和变量b进行异或运算。
63 答案是A
变量c1和c2中的值相同，所以转换成二进制数后，对应的二进制位上的值也相同，当两值相同时，只有进行异或运算，结果才为0，所以c1^c2值为0。所以本题的正确答案为A。
64 答案是A
4|3转换成对应的二进制数即100|011=111再转换为十进制数即为7；而4&3转换成对应的二进制数即100&011=000，再转换为十进制数即为0；所以选择A。
65 答案是 D
x/y的值为1，z的值也为1，1和1求反进行与运算，结果一定为0。所以本题选择D。
66 答案是D
2+x=00000010+10100111=10101001；~3=~00000011=11111100；所以就相当于10101001^11111100=01010101,所以选择D。
67 答案是 D
a=0x3转换为二进制数即为00000011；b=a|0x8转换为二进制数即为00000011|00001000=00001011即b=11，b<<1即00001011<<1=00010110即c=22，所以本题选择D。
二，填空题
1 位 0 1
2 关键字 预定义标识符 用户标识符
3 8
4 八 十 十六
5 int float double
6 5+3.6/2=5+1.8=6.8
7 15 16 a++表达式的值是a变化之前的值，当然a本身增加了1
8 把10赋给变量B
9 123.46 (int)(x*100+0.5)/100.0=(int)(12345.67+0.5)/100.0=(int)(12346.17)/100.0=12346/100.0=123.46。
10 3
整个表达式是一个逗号表达式，变量n和i赋值为2后，通过++i将i的值增加1变为3，然后再通过i++为i增加1，整个逗号表达式的值为i++的值，此时是后缀，所以整个i++表达式的值为3，而变量i的值为2。
11 11110111
第11题没有详细解析而且答案出错：
~x^y<<1=~00000010^00000101<<1=11111101^00001010=11110111
12 2
只有’\\’和’\b’是正确的
13 2 20.000000
x=f*=n/=(c=50)是一个赋值表达式，它的顺序是从右向左赋值，先执行c=50，然后执行n/=50即n=n/50=100/50=2，接着执行f*=2即f=f*2=10*2=20.000000，最后再将值赋给变量x。输出变量n和x的值，即为2 20.000000。
14 a=14
表达式a=(3*5,a+4)的括号中是一个逗号表达式，其结果是最后一个表达式的值，即将a+4=14的值赋给变量a。所以输出结果为a=14。
第二章 顺序结构
一 选择题
1， 答案是 C
随意使用空语句会导致逻辑上出现错误，不要随便使用。
2， 答案是 B
语句必须以分号结尾，A,C,D表达式后面均没有分号。
3， 答案是 C
int x=13,y=4;说明x,y均为整型，所以x/y只取整数部分（舍去法），值为3，把3赋值给x，整个x=x/y表达式的值为左边变量x的值，所以输出为3。
4， 答案是 A
a,b均为整型，a/b是取a÷b所得商的整数部分，所以是0，再把0赋值给 c，所以是c的值是0。
5， 答案是 D
A 注释语句可以放在代码的任何位置
B 将r定义为整型不会在编译时出错，会自动进行类型转换
C 变量s为浮点型，格式描述符％f时正确的
D π是非法的变量
6， 答案是 D
(x,y)是逗号表达式，它的值只有一个，所以格式说明符的个数和输出项的个数是相等的。并且逗号表达式的值为最后一个表达式的值，最后一个表达式是y=2003,所以整个表达式的值是2003，因此输出值为2003。
7， 答案是 A
m是十进制整数以十进制有符号的形式输出，即照原样输32767,n=032767，032767是八进制的整数以八进制无符号形式输出，去掉前面的0。见教材P34
8， 答案是 C
m,n的值都是十六进制数0xabc，m-=n即是m=m-n, 把m-n的值赋给m，
即把0赋给m,再把m值以十六进制无符号的形式输出，输出的十六进制
数不用在前面0x或者0X。见教材P35
9， 答案是 B
表达式i－－的值是在变量自减之前的值，i的初值为10，所以该表达式的值也为10；表达式j++的值是变量自加之后的值，j初值为1，所以该表达
式在值是2。
10， 答案是 C
m=0256,即m是八进制的数0256，要以八进制无符号的形式输出，即输出
256；n=256,即n是十进制的数256，也要以八进制无符号的形式输出，首
先要把十进制数转化为八进制数，256转化为八进制为0400，以无符号形
式输出，即输出400。
11， 答案是 B
在printf语句中，格式控制的个数只有一个，即％d，而输出项有两项，即a和b。而得到的结果应该只有一个，所以应该输出第一个变量的值，即变量a的值。
12， 答案是 C
第一个数据的输出控制宽度是2位，但是x的值是102，占3位，要输出的数据宽度大于规定的输出宽度，所以按数据的实际宽度输出，输出102。第二个数据要求以十进制形式输出，输出控制宽度是2，y的值为012，是八进制数，所以要转换成十进制数10后再输出。
13, 答案是 B
表达式a＝f/=c*=(x=6.5),按从右到左结合，先把6.5赋值给x，再执行c＝c*6.5，c的值变为65，再执行f＝f/65,为浮点数的除法，f的值为1.53……，再把f的值赋给a，a为整型数据，执行强制类型转换，a的值为1。a对应的输出格式为％d，即输出1；c对应的输出格式为％d，输出65，f对应的输出格式％3.1f，即输出控制宽度为3位，保留小数点后一位小数，即输出1.5，x对应的输出格式也为％3.1f，输出6.5。
14， 答案是 D
float x=-123.456;说明x为单精度浮点数据，单精度浮点数据对应的输出格式应该为%f。
15， 答案是 C
m=(k+=i*=k);按从右到左结合,先执行i=i*k；即i被赋值为4，再执行k＝k＋4；k被赋值为6，最后把6赋给m，输出m和i的值。
16， 答案是 C
略（参考12题）
17， 答案是 D
－m＋＋遵循从右向左结合的原则；m＋＋的值为m自增之前的值，所以执行完x＝－m＋＋以后，x被赋值为－3；表达式x＝x＋8/++n中有加号除号，先算8/++n,++n的值为自增之后的值为5，8/5取整为1，即x＝x＋8/++n转化为x＝x＋1，即把x＋1的值赋给x，x的值变为－2。
18， 答案是 D
A 输入函数应为scanf();
B，C 输入数据列表必须是地址表达式；
19， 答案是 A
从键盘输入数据的格式必须与输入控制要求的格式一样
B答案三个之间不要有空格；C答案用逗号分开是多余的；D答案格式不匹配。
20， 答案是 A
格式控制要求输入的两个数据之间要用逗号隔开，A没有逗号所以错误，D两个输入数之间的回车换行可以忽略。
21， 答案是 C
x乘以100是为了把x小数点后的两位小数变为整数，再加上0.5，如果小数点后一位大于等于5则会进一位，如果小数点后一位小于5则不会出现进位的情况，再对其进行强制类型转换，采用舍去法丢掉小数部分，即对x乘上100后的数实现了小数位到整数位的四舍五入。最后再除以100.0，把数字变回原来的大小，整数与浮点数相除结果为浮点数，即实现了要求。
22， 答案是 C
从键盘输入数据的格式必须与输入控制要求的格式一样。
23， 答案是 B
输入控制中第一个数要求以“％2d”形式输入，即要求输入一个两位的数，而从键盘输入的数为876，所以从左到右取两位数字87，即把87赋值给整型变量a，余下的6再赋值给浮点型变量b，自动进行类型转换，b的值为6.000000，后面输入的543则没有赋值给变量。
24， 答案是 D
“％％”会输出一个“％”，“d”会照原样输出，因为没有格式说明，m,n无法输出到屏幕。
25， 答案是 D
第1个输出语句要求ch以%c（字符）形式输出所以为输出“a”，以%d（整数）形式输出为，字符转换为整型要使用ASCII码所以为“97”，k没有对应的输出符所以没有输出，第2个输出语句要求以整型方式输出k得到“12”。结果为“a,97,k=12”
26， 答案是 B
a+b的结果为30，按照“a+b=%d\n”的输出格式得到输出结果“a+b=30”B
27， 答案是 B
printf可以没有输出项，没有输出项的printf只是没有输出内容；整数不能以十二进制输出，getchar（）只能读入字符。
28， 答案是 A
getchar（）可以读入空格符合回车符。
二 填空题
1， 一条语句 分号
2， 88
首先将八进制数0210转化为十六进制的数0X88，输出格式说明要以十六进制无符号的形式输出，所以省略0X，直接输出88。
3， 11
把十进制数转化为八进制数，以无符号的形式输出
4， 25 21 37
b为八进制数025，c为十六进制数0X25，首先把b、c都转化为十进制的整数，分别为21、37，按照输出格式要求a、b、c以十进制整数形式输出，中间以空格分开，所以输出为25 21 37。
5， n1＝%d\nn2=%d
除了n1,n2的值之外，还必须加入“n1＝”“n2＝”照原样输出的字符，很明显在两个数据之间还加了换行符。
6， i=10,j=20<回车>
格式控制中加入了格式说明以外的其他字符，则在输入数据时这些字符也要同样输入。输入格式控制为i=%d,j=%d,所以则应该从键盘输入i=10,j=20
7， 261
a为十进制数177转化为八进制的数为0261,以无符号的形式输出为261
8， 16
a的初值为0，在表达式a+=(a=8)中，a首先被赋值为8，再执行操作a=a＋a,所以a最后被赋值为16，即输出a的值为16
9， printf(“a=%d,b=%d”, a, b);
10， B 66
B在ASCII码中派在A的后面A为65，那么B为66。
11， 10
012为八进制数，转换为十进制为10。
12， 12 34
在scanf函数中指定了宽度为2，输入123456，a=12，b=34，后面的567无效。
13， 12
程序运行时输入12，getchar（）函数只能接受单个字符，所以ch1=’1’,ch2=’2’。
n1=ch1-‘0，转化为ASCII码计算n1=50-49，n1的值为1。n2=n1*10+（ch2-‘0’）转化为ASCII码计算n2 = 1*10+（51-49），n2的值为12。
第三章 选择结构
一、选择题
1、D 此题主要是考语句的特征。一条语句只包含一个分号，D项有两个分号，应该是两条语句,所以选D。
2、C此题主要是考真假条件的等价。题目中的E为非0时条件为真，为0时为假。那么把非0和0带到选项中可知，C项正好是E为0时表达式为真，非0时为假，所以选C。
3、D 任意合法的表达式都可以作为逻辑运算符的运算对象
4、D 此题主要是考逻辑运算和关系运算的优先级别.只要掌握!、算术运算和&&的优先级别便可选对.这几种运算符的具体优先级关系见见教材P188，附录三。
5、A 此题主要是考逻辑运算符!、&&和||之间的优先级别。！最高，&&次之，||最低。先求得!a为0，所以不必计算!b的值，即!a&&!b的值为0，由c=0,!c=1,而0||1=1，所以选A。
6、A 此题主要是考了逻辑、关系和算术运算，熟练掌握逻辑运算、关系运算和算术运算的优先级别后，就不难了。A 选项中!a为0，所以!a==1为假，那么就不用计算&&后面的表达式了，因为0与任何数均为假；B项中先计算出a<b为假，则(a<b)&&!c也为假，而0||1=1； C项中a和b均为真，所以a&&b的值为1；D项中先计算出(b+b)&&(c-a)=1，又a=2,2||1=1 所以选A。
7、D 此题考到了++运算符以及逻辑运算。当计算机碰到a&&b时，先计算表达式a的值，若为真才会计算表达式b的值，否则将不会去计算b的值，因为一旦a=0,则0&&b必为0；而a||b则正好是相反的，即先计算表达式a的值，若a为假才会计算表达式b的值，否则将不会去计算b的值，因为一旦a=1,则1||b的值必为1,理解了这两点后，我们在看题目：i++==1的值为1，此时i为2，所以计算&&后的表达式，首先计算++j==3的值为1，j的值为3，由上面的原理我们可知，||后面的表达式不用再计算，所以此时i，j，k的值分别为2，3，3。
8、D 此题和题2非常的相似，也是考真假条件的转换，其中D项中只有k为0时，!k%2==1才成立，显然和A、B、C三项不同。
9、C 此题主要是考if和else的配对问题。见教材P51。
10、D 此题主要是考if和else的一般形式。if后面的语句要么是单条语句，要么是由{ }扩起来的复合语句，不能是if后有两条语句的，所以本题程序在运行的时候会出错。
11、C 此题考到了关系运算和逻辑运算及一定数学知识。|x-y|<10可等价为-10<x-y<10,首先选项A表示x-y的绝对值小于10，与题中的数学关系一样；将-10<x-y<10用逻辑表达式表示的话就是B选项；而D选项只是数学变换，所以选择C
12、D 此题也是考到了真假条件的变换和if-else语句。A、B、C三项都是表示a为真时输出x，为假时输出y,而D则是a为假时输出x,为真时输出y。
13、D 此题考查了赋值表达式的一般格式，=的左边是变量名，右边是表达式，所以D项错误。
14、C 此题主要是考查逻辑运算符||,当计算机碰到a||b, 先计算表达式a的值，若为假才会计算表达式b的值，否则将不会去计算b的值，因为一旦a=1,则0||b必为0。题中b>a为真，所以(n=b>a)为1，那么将不会去计算m=a<b的值,k被并赋值1，所以m依然为0 。
15、C 此题主要是考查if-else-if和if语句。具体分析见教材第49页例7。
16、C此题主要是考查if-else-if以及关系表达式的运算。首先判断第一个条件a>b>c的值为0，所以不执行第一条语句；在判断第二个条件，c-1>=c表达式的结果为假，所以也不执行其下面的语句，因此执行最后一条语句，将输出d+2的值为4 。
17、C 此题主要是考查条件表达式和条件运算符。首先要注意条件表达式的结合方向，它是从右至左的（可参照附录三）第一个条件表达式的值为a,第二个条件表达式的值为c ,而c=6,所以答案选C
。
18、A此题主要是考查if-else语句和条件表达式的转化。只要理解了if-else语句和条件表达式的运算规则的话，就很容易选出A
19、D 此题主要是考查在switch语句中break和default的作用及break的适用范围。详细说明可参看教材第三章 P53对switch的说明部分。
20、B
此题考查的是条件表达式求解问题。先看第一个条件表达式语句，a<b为真，所以k=b=2;再看第二个条件表达式语句，k>c为假，所以k=k=2选 B
21、A
此题考查的是条件表达式的求解顺序。参照附录三可知，它的结合方向是自右至左，所以先求得右边一个条件表达式的值为2，再求得左边一个的值为1，即选A
22、C
此题考查的是真假条件的等价问题。x-y为真表示x-y是非0的，也即x-y<0或x-y>0 即选C
23 答案是B
C语言的字符以其ASCII码的形式存在，所以要确定某个字符是大写字母，只要确定它的ASCII码在’A’和’Z’之间就可以了，选项A和C符合要求。大写字母的ASCII码值的范围为65到90，所以D选项符合要求，所以只有C是错误的。
24 答案是B
满足表达式（c>=2&&c<=6）的整型变量c的值是2，3，4，5，6。当变量c的值不为2,4,6时，其值只能为3或5，所以表达式c!=3和c!=5中至少有一个为真，即不论c为何值，B选项中的表达式的值都为真，所以B选项正确。
25 答案是A
条件x==0||x==1为真，所以执行y=1，然后执行
y=x*x-(x-2)*(x-2)=1-(-1)*(-1)=1-1=0，所以选择A。
26 答案是B
当表达式EXP为非0值时条件成立，即执行语句i++；当EXP等于0时执行语句j--；。这就等同于条件表达式“（EXP！=0）？i++:j—”。所以本题选择B。
27 答案是D
C语言的字符以其ASCII码的形式存在，所以要确定某个字符是大写字母，只要确定它的ASCII码在’A’和’Z’之间就可以了，选项B的书写格式错误，而选项C不符合要求。大写字母的ASCII码值的范围为65到90，所以A选项不符合要求，小写字母的ASCII码比大写字母的ASCII码大32，所以只有D是正确的。
28 答案是D
奇数和2求余一定不为0，所以当x为奇数时，x%2==0是不成立的，值为0，此题选择D。
29 答案是B
两个if语句的判断条件都不满足，程序只执行了c=a这条语句，所以变量c的值等于3，变量b的值没有变化，程序输出的结果是3，5，3。所以本题选择B。
30 答案是C
表达式y%3==0的值为1，所以执行下面的输出语句，表达式—y的值为8，所以输出结果是8。选择C。
31 答案是C
表达式x%3的值为2，非0所以执行下面的输出语句，将x--的值8输出，此时x的值变为7，然后再执行下一个输出语句，将--x的值6输出，x的值也变为6，所以选择C。
32 答案是D
这是嵌套形式的switch语句，因为break结构影响较大，而此程序中的第一个case后没有break语句，程序执行时，x=1，执行内嵌的switch语句，因y=0，执行a++，使变量a的值为1并终止内层switch结构，回到外层。程序继续执行case 2后面的语句a++;b++;，这使变量a,b的值分别为2和1，外层switch语句结束。所以此题选择D。
33 答案是D
break与continue语句都可用于switch语句中。选择D。
二、填空题
1、答案是：10 20 0
分析：多数同学得到的答案是10 20 1，显然是没有弄清楚第三条赋值语句：c=(a%b<1)||(a/b>1).这是将后面一个逻辑表达式的值给c，那么关于逻辑表达式的考题，无非就是考察运算符的优先级，也就是说先算哪个，后算哪个的问题。在这个题里面，先计算第一个圆括号里面的内容，a%b的值是10，所以10<1为假；a/b的值为0，0>1为假。在逻辑或运算的时候，两个运算对象都为假，则结果为假。所以c的值为0.答案是：10 20 0
2、答案是： 1
分析：程序中是一个if—else结构。这个题最容易出错的地方在于if的条件，注意，里面的是c=a是一个赋值表达式，不是将c与a的值进行比较。所以条件为真，输出赋值以后c的值，为1。
3、答案是：4，5，99
分析：题中的重点在于两个if结构，大家要注意两点：第一，如果if后面没有花括号，则它后面的第一条语句是它的结构体，并且只有一条语句。（如果后面是一个结构，则整个结构都属于if结构的结构体）。第二，变量在不断的被重新赋值，所以其值在不断的变化。
4、答案是：yes
分析：该题与第二题是同一回事。
5、答案是：1
分析：这个题还上一个if—else结构，考查点仍然是考察考生是否能够正确识别if后面括号里的表达式p=a!=0,根据运算符的优先级知道，这里应该先算a!=0，这是一个逻辑运算，a的值为5，所以a!=0为真，其逻辑值为1，将1赋值给p，所以条件为真，输出p的值，为1。
6、答案是：20，0
分析：见第3题分析。
7、答案是：585858
分析：题中有三个if结构，注意，这三个if结构是相互独立的，是互不相关的，只要他们的条件成立，就要执行其结构体（后面的输出语句）。通过键盘输入，得a的值为58，所以a>50为真，输出58；然后判断a>40，仍然为真，再输出58，最后判断a>30，肯定为真，所以再输出58，连续三次输出58。
8、答案是：0
分析：本题的关键在于关系运算符的运算次序，a=5,b=4,c=3.a>b>c看起来是真的，但是这这是数学里面是这样的，这里我们要一步一步的计算，先算a>b，a确实大于b，所以为真，逻辑值为1，后面的计算就变成了1>c，显然为假，逻辑值为0，并将它赋值给d，所以最后输出d的值为0。
9、答案是：3
分析：这个题主要考察条件运算符。程序要输出（P/3>0?p/10:p%3）这个条件表达式的值。P为30，所以p/3=10,10>0显然为真，所以整个表达式的值应该是p/10的值，p/10得3。
10、答案是：2 1
分析：题中是一个switch嵌套结构。里面的switch是case 1的语句，题的关键点在于这个语句（即里面的这个switch结构）的后面并没有跳出整个结构的break语句。所以，当x=1，与case相配以后，执行完后面的语句（即里面的这个switch结构），然后没有遇到break语句，所以并不跳出结构体，而是继续执行case 2后面的语句。所以最后得到的结果应该是2 1，而不是1 0。
11、答案是：0
字符空格的ASCII码不为0，所以本题中表达式!c的值为0，b=0&&1的结果显然为0。
12、答案是：1
执行“j=!ch&&i++”时，首先判断j=!ch的值，因为ch=’$’不为0，所以j=!ch=0，编译便不再计算表达式i++的值，i的值不变仍为1。
13、答案是：-4
表达式!n的值为1，所以执行x-=1后x=1；表达式m的值为非0值，所以执行其后的语句x-=2后x的值为-1，表达式x的值也为非0，所以执行其后的语句后x的值为-4，最后输出x的值即为-4。
14、答案是：#&
表达式c==5的值为真，所以表达式的值等于1，因此输出符号“#”，然后执行“break”，继而去执行“default：printf(“&”);”语句，输出符号“&”。
15、答案是：1
因为在条件表达式（a<b）a:b中，比较表达式a<b为真，所以x的值为a的值等于1。后面两个条件表达式中的比较表达式都真，所以最终x的值等于1。
16、答案是：a:b c:t1
条件表达式类似于if语句，根据“？”前面子表达式的逻辑值来判断应该计算“：”前面的子表达式还是后面的作为整个条件表达式的结果。题目要求输出a、b、c3个变量中的最小值，所以当a<b时，应该选a，否则选b，帮前一空应填a:b。同理，后一空应填c:t1。
第四章 循环结构
选择题：
1. 答案：B
① N的值为10，n>7为真，执行循环体，n的值减1后为9，输出n的值9
② N的值为9，n>7为真，执行循环体，n的值减1后为8，输出n的值8
③ N的值为8，n>7为真，执行循环体，n的值减1后为7，输出n的值7
④ N的值为7，n>7为假，结束循环。
2. 答案：A
k的值为5，进入循环，（--k）表达式的值为4（真），同时k的值改变为4，输出表达式k-=3的值1，同时k的值为1。k为1,表达式（—k）的值为0, 结束循环。
3. 答案：A
1．X=0,y=5,z=3,(z>0&&x<4)值为真，进入循环体，y值为4,z值为2, x值为1
2．(z>0&&x<4)值为真，进入循环体, y值为3,z值为1, x值为2
3．(z>0&&x<4)值为真，进入循环体, y值为2,z值为0, x值为3
4．(z>0&&x<4)值为假，结束循环。
5．输出x,y,z的值3,2,0
4. 答案：D
分析：
当K的值为3时，只执行case 3后面的语句n+=k，n的值为3;
当k的值为2时，先执行case 2后面的语句，但没有break，所以不会退出，继续执行case 3后面的语句n+=k，n的值为5;
当k的值为1时，先执行case 1后面的语句n+=k，n的值为6，先执行case 2后面的语句(没有)，继续执行case 3后面的语句n+=k，n的值为7。输出n的值7。
5. 答案：B
在循环体中有“s+=1;”s的初始值为0，要让s的值等于2必须是循环体执行两遍。当循环提执行两遍后a的值等于-3，所以在n=-3的时候循环体执行两遍后条件表达试（a!=0）为假，会退出循环。
6. 答案：A
分析：
t值为1，s的值为0。从键盘中输入－3后，n的值为－3.先执行循环体。
执行s=s+t;s的值为1，执行t=t-2;t的值为-1.再判断表达式的值
t!=n为真，再次执行循环体。执行s=s+t;s的值为0，执行t=t-2;t的值为-3.再判断表达式的值
t!=n为假，结束do..while循环。最后输出s的值0。
7. 答案：A
分析：x＝3; 先执行循环体，输出表达式x-=2的值1，同时x的值也改变成1，再判断表达式的值(!x),x的值为1（真），(!x)为假，循环结束。
8. 答案：B
分析：B选项每次进入循环体，都要先执行p=1;即1赋值给p.所以不能求出5！的值
9. 答案：D
分析：变量i每次增量为2，变化过程为：1->3->5->7->9，语句s+=1每次执行使s增加的数为：2,4,6,8,10,所以s的值为自然数1~10中偶数的值。
10. 答案：C
分析：C项s=s+1/n, 1/n首先运算，n为整型变量，1也是整型变量，当n=2…10时,1/n的值为整数0，故C不正确
11. 答案：A
执行第一次循环时，a= 7,b = 4,a!=b为真继续循环。第二次循环a = 3,b=1，a!=b为真继续循环。第三次循环a = 2,b = 1, a!=b为真继续循环。第四次循环a = 1,b=1,
a!=b为假退出循环。
12. 答案：C
13. 答案：C
分析：x的值为15。执行while循环，（x>10）为真，执行循环体。执行x++;x的值为16。再执行if语句。（x%3）为真，执行x++,x的值为17，再执行break;语句，退出循环体，结束while语句的执行。最后输出x的值17。
14. 答案：D
在循环中当x等于0，3，6，9时x%3等于0，这时会进入if语句执行printf语句，在输出前x会先自加。屏幕上输出14710。
15. 答案：D
分析：continue语句会提前结束此次循环体的执行，不会结束整个for语句的执行。
16. 答案：2345
选择中没有此答案。
解析：本题注意的是在循环第一次进入switch语句的时候是执行的default后面的语句块，由于没有break,所以还会执行case2:case4:后面的语句。
17. 答案：A
本题答案为A
解析：A首先执行++n，判断条件表达式n<=0为假退出循环。B条件表达式1永远为真是无限循环，C条件表达式n的值为10永远为真是无限循环，D没有条件表达式，所以没有退出条件，是无限循环。此题要注意的是0为假，非0为真。
18. 答案：A
do-while循环先执行后判断，先执行循环体中的printf语句输出n的值0，在while(i++)中i先执行再自加，所以while(i++)的等于while(0)为假退出循环。输出结果为 “0，0”。
19. 答案：D
分析：第一次循环x=8,x%3<>0,进入if语句输出x的值为8，然后x自减1，执行continue立即进行下次循环条件判断。第二次循环x=6,x%3=0,不进入if语句，执行if语句后面的printf(“%d,”,--x),x先自减1再输出得到5。第三次循环x=4,x%3<>0,进入if语句输出x的值为4，然后x自减1，执行continue立即进行下次循环条件判断。第四次循环x=2,x%3<>0,进入if语句，输出x的值为2，然后x自减1，执行continue立即进行下次循环条件判断。第五次循环x=0,判断表达式x>0为假。结束循环输出结果为8，5，4，2。答案D
20. C
第一次循环y=9，y%3=0，进入if语句y先自减，输出y的值为8。第二次循环y=7，y%3<>0，进入下次循环。第三次循环y=6，y%3=0，进入if语句y先自减，输出y的值为5。第四次循环y=4，y%3<>0，进入下次循环。第五次循环y=3，y%3=0，进入if语句y先自减，输出y的值为2。第六次循环y=1，y%3<>0，进入下次循环。第七次循环y=0，判断表达式y>0为假结束循环。输出结果为8，5，2。答案C
21. B
在第一层循环中，当i自加到值等于3的时候才会进入第二层循环55%3=1。输出m的值为1.
22. B
外层循环3次，i的值在内层循环中依次为1，2，3内层循环次数依次为3，2，1次。
23. D
代码“if(n%3!=0) continue;”无实际意义。当n自加到4的时候结束循环。答案D
24. B
需要填入的实际是每行输出“*”的个数，从图形看到每行“*”的个数是行数的两倍减一，i可以代表行数。所以填入的是“2*i-1”。答案B
25. A
0%任何数等于0，所以第一次循环的时候就进入了if语句退出了for循环。i=21，i<20为假，退出了while循环。a的值为21。
26. D
i的初值为0，第一次循环的时候满足i<0,进入第一个if语句，执行continue直接进行下次循环，i的值没有改变。第二次循环又重复了第一次循环的操作，所以是死循环。
二、 填空题：
1. 答案：－1
分析：此题的循环体是省略了大括号的空语句 ;，x的初值是2；执行while语句，先判断表达式的值，(x--)的值为1（真），同时x的值减1变为0，再执行循环体（空语句;）,再判断表达式(x--)的值，表达式的值为0，同时x值减1，变为－1，因为表达式的值为0（假），循环结束。最后输出x的值－1。
2. 答案：11
循环的判断表达式为i<5,i的初值是1，所以i得值依次是1，2，3，4。
sum=sum+1+2+3+4，sum的值等于11.答案是11
3. 答案：n=n/10
此题的解法是先用输入的数据%10可以得到个位数，再让输入的数据除以10，使十位变成个位。循环使用上面的方法。当只剩下个位的时候也就是n小于10的时候n/10等于0退出循环。所以填入的是“n=n/10”。
4. 答案：0
分析：i的值从5变化到0时，for语句中的第二个表达式都为真。t=5*4*3*2*1*0＝0。
最后输出i的值为0。
5. 答案：5
分析：for循环语句的循环体是空语句。
6. 答案：6
分析：此题属于循环的嵌套。当i=1时，输出0个＃号，当i=2时，输出1个＃号，当i=3时，输出2个＃号，当i=,4时，输出3个＃号，共输出6个＃号。
7. 答案：0
分析：getchar()只能获得单个字符，输入“1234567890”ch的值为‘1’。循环条件为假，循环一次也没有执行。答案为：0
8. 答案：23
分析：参考第3题。答案：54321
9. 答案：k<=n k++
分析：见书59，64页while和for循环的执行过程。答案：k<=n k++
10. 答案： ACE
分析：理解字符转化为整形数使用到ASCII码，‘a’的ASCII码是97，‘f’是102，‘A’是65。答案是ACE
11. 答案：120
分析：i的值是1，sum的值是1，执行while循环。①i<=5为真，sum的值为1，i自加1，值为2。②i<=5为真，sum的值为2，i自加1，值为3。③i<=5为真，sum的值为6，i自加1，值为4。④i<=5为真，sum的值为24，i自加1，值为5。⑤i<=5为真，sum的值为120，i自加1，值为6。⑥i<=5为假，结束循环。输出sum=120。
12. 答案： 23
分析：此题需理解的是在switch中case后面没有break的话会继续执行下一个case或default后面的语句。答案为23
13. 答案：1 3 2
分析：m=0,n=0,k=0,i=9
①当i值为9时，i<=11为真，执行switch语句，(i/10)的值为0，匹配case 0,执行m++,n++,再执行break语句，跳出switch体，再执行i++, i值为10;此时m值为1，n的值为1，k的值为0.
②当i值为10时，i<=11为真，执行switch语句，(i/10)的值为1，匹配default,执行k++,n++,结束switch体，执行i++,i值为11. 此时m值为1，n的值为2，k的值为1.
③当i值为11时，i<=11为真，执行switch语句，(i/10)的值为1，匹配default,执行k++,n++,结束 switch体，执行i++,i值为12. 此时m值为1，n的值为3，k的值为2.
⑤ i值为12时，i<=11为假，结束for循环。最后输出m,n,k的值132.
14. 答案： i<10 i%3
根据题意先得到100以内所有个位是6的数，在判断哪些能被3整除。答案为i<10 i%3!=0。
第五章 函数
一、选择题：
1. 答案：B
分析：在C语言中，函数可以在任何地方出现，而main函数作为函数中的一类，没有特殊的限制和要求，故也可以在任何地方出现。
2. 答案：B
分析：C语言默认规定
3. 答案：D
分析：选项A中”abc”和C中的’65’是一个字符串，而形参要求的是单个字符不符合要求，选项B是一个赋值语句，而fun函数没有返回值，所以不符合要求，只有选项D正确，将32传给ch字符变量，那么32就相当于是ASCII码值。
4. 答案：A
分析：sin（1/2）会当作sin（0）处理。实参的类型决定了重载函数的选择。
5. 答案：D
分析：函数的调用不可以作为一个函数的形参。
6. 答案：D
分析：fun(a,b)的作用是返回a、b中较大的。fun(x,y)=fun(3,8)=8, r=fun(fun(x,y),2*z)=fun(8,12)=12
7. 答案：C
分析：f1（x，y）的作用是返回x、y中较大的，f2（x，y）的作用是返回x、y中较小的。d=f1(a,b)=f1(4,3)=4
d=f1(d,c)=f1(4,5)=5
e=f2(a,b)=f2(4,3)=3
e=f2(e,c)=f2(3,5)=3
此时各值为a=4,b=3,c=5,d=5,e=3,f=a+b+c-d-e=4。所以答案d, f , e为5, 4, 3
8. 答案：A
分析：c程序的基本单位是函数。函数中不可以嵌套定义函数。main（）函数可以放在任意位置。被调用的函数只要在调用之前说明了即可。
9. 答案：B
分析：fun（x，y）的作用是求x、y的和。fun(a+c,b)=a+c+b=15,(int) fun(a+c,b)=(int)15=15。fun（(int) fun(a+c,b)，a-c）=fun（15，-6）=9。
10. 答案：D
分析：fun（x，y）的作用是选择x，y里面较小的一个。fun（9，8）=8，fun（8，7）=7；fun（fun（a，b），fun（b，c））=fun（8，7）=7
11. 答案：C
分析：fun1(a)=a2,fun2(x,y)=(int)(fun1(x)+fun1(y))=(int)( x2+ y2)，所以fun1(1.1,2.0)=(int)(1.21+4.0)=(int)5.21=5
由于w是double型的，所以w的值为5.0。
12. 答案：A
分析：函数的说明有其自己的格式，应该包括函数类型、函数名、以及形参类型，形参名可有可无，但是一定要统一，形参名随便取。
13. 答案：C
分析：允许这种函数说明的方式存在。如果只在主函数中说明，则只能在主函数中调用f；如果在主函数以前说明，则包括主函数的所有函数都可以调用，如果同时主函数又说明了，则不影响。
14. 答案：D
分析：函数的形参不可以传给对应的实参。
15. 答案：D
分析：形式参数的改变不影响实参。所以本题是一个迷惑题，不需要看函数体的内容。
16. 答案：C
分析：C语言中改变函数形参的值，不会改变对应实参的值；函数可以返回地址值，当函数没有指定返回值类型时，默认返回类型为void型，C语言的函数不能嵌套定义，所以本题选择C。
17. 答案：A
分析：本题答案为A，程序的执行总是从main函数开始，在main函数结束，无论main函数在程序的什么地方。
18. 答案：A
分析：在C语言中，函数返回值的类型取决于函数定义时在函数首部所说明的函数类型。
19. 答案：C
分析：函数f（int v,int w）的功能是将实参v和w进行交换，但是实参值的变化对形参没有影响，所以本题中x，y，z中的值不发生变化。
20. 答案：C
分析：因为fun(int x)函数是一个递归函数，所以主函数中的调fun(3)经过1次递归调用，其过程可以描述为fun(3)=3*3-f(3-2)=9-fun(1)=9-3=6。
21. 答案：D
分析：在内存中，实参单元与形参单元是不同的单元。在C语言中，仅在调用函数时，给形参分配存储单元，并将实参对应的值传递给形参，调用结束后，形参单元被释放，实参单元仍保留并维持原值。故本题答案为D。
22. 答案：C
分析：变量a，b，c的初始值分别为1，2，3。因此逗号表达式“a++,b++,a+b” 值等于5，表达式c++的值为3，这样主函数main()中调用子函数的表达式为fun(5,3)；其返回值等于8。所以变量sum的值等于8。本题选择C。
二、填空题：
1. 答案：a=1.0,b=1.0,s=1.0;
分析：分别求出变量的初始值。a=a*x为的是求xn ，所以其初始值为1，b=b*i
位的是求n！，所以其初始值为1，当n=0时，s=1，所以s的初始值为1。由
于定义的是double型的数据，所以答案为a=1.0,b=1.0,s=1.0;
2. 答案：m=fun(a,4)+fun(b,4)-fun(a+b,3);
分析： 由程序可以看出fun(x,n)=xn。fun(a,4)=a4,
fun(b,4)=b4,fun(a+b,3)=(a+b)3,当要计算m= a4+ b4+(a+b)3 时，函数调用语句
为m= fun(a,4)+ fun(b,4)+ fun(a+b,3)；
3. 答案：x x*x+1
分析：1）求f（x）的累加和，即为求f（0）+f（1）+ f（2）+ f（3）+ f（4）+……，函数SunFun来实现此功能。括号中应该填入累加的序号值，即为x。
2）f(x)=x2+1，F（int x）函数来实现这个功能，所以填写x*x+1。
4. 答案：-f fun(10)
分析：函数的作用为计算m=1-2+3-4+5-6+7-8+9-10，实际上为计算
m=1*1+(-1)*2+1*3+(-1)*4+……+1*9+(-1)*10，在循环体中，i为1，2，3…..
f为1的符号。每循环一次，f的符号应该变换一下，所以变换的语句为f=-f。
当n=1时，计算的是m=1；当n=2时，计算的是m=1-2……因为计算的是m=1-2+3-4+5-6+7-8+9-10，所以答案为n=10，即fun（10）。
5. 答案：9
分析：1）函数的意思为f(x,y)=(y-x)*
f（3，4）= (4-3)*3=3
f（3，5）=(5-3)*3=6
2)d=f(3,6)=(6-3)*3=9.
6. 答案：double max
分析：通过程序可以看出，main函数中使用了max函数，而其他地方没有对max函数进行说明。所以程序中应该对max函数进行说明。说明的格式为double max（double，double）。
7. 答案：3,2,2,3
分析：1）x=2，y=3，当调用fun（x，y）时，相当于执行fun（2，3）。
x=x+y; x=2+3=5;
y=x-y; y=5-3=2;
x=x-y; x=5-2=3;
此时x, y的值为3，2，所以输出的结果为3，2。
2）在main函数中，实参不会因为形参的改变而改变， x，y的值仍为2，3，所以所以输出的结果为2，3.
8、答案：1 3
分析：fun函数是一个递归函数，主函数中调用的fun(3)共递归两次，fun(3)中又调用fun(3/2)即fun(1)，先输出fun(1)中x的值，为1，然后再输出fun(3)中x的值为3。所以结果为13。
9、答案：m=9 k=14
i=5 j=5
分析：为变量i和j赋初值为4，调用fun(i++,++j)即fun(4，5)，在fun函数中计算m和k的值，m+=k即m=m+k=4+5=9，k+=m即k=k+m=5+9=14，分别输出m和k的值，即输出m=9,k=14；然后到主函数中输出自增1后的i和j的值，即i=5,j=5。
第六章 指针
一、选择题
1 答案：A
分析：本题主要考指针赋值，n2=n1；是把n2的值赋给n1，故根据指针赋值的定义可知选A，即把q所指对象的值赋给p所指对象。
2 答案：B
分析：本题主要考指针定义，因为p指向变量x，故输出其值的时候应该是x的值。
3 答案：C
分析：本题主要考指针的定义和赋值,C前面是定义一个量a并赋值为10,后面定义一个指针，并把a的值赋给这个指针。
4 答案：C
分析：本题主要考指针的定义及赋值，开始时使p指向a，q指向b，把它们的值交换，然后再显示。故得正确答案C。
5 答案：C
分析： 本题主要考函数指针的定义，函数前面的*号表求返回值是指针类型，void表示返回无值弄的。故选C。
6 答案：A
分析：本题主要考的是指针的变量的赋值，在使用scanf（）函数的时候，后面跟的是一个地址，由于pa本身保存的是地址，故选A
7 答案：D
分析：本题主要考的指针的赋值及指向指针的指针的赋值，根据定义知选D。B的正确形式是**q＝2；C的正确形式应该是q=&p。
8 答案：C
分析：本题主要考的是全局变量和局部变量，以及指针的用法，第一个f(&a)的返回值是5,第二个返回值是2。
9 答案：A
分析：本题主要考的是变量自加，指针传值，以及指针的赋值。通过第二行a=b可知p1,p2指向的变量的值相同，都指向了b所指的对象，也是p2所指的对象’a’,由于（*a）++;是实现a所指对象的自加，故由’a’变成’b’，故最终选A。
10 答案：A
分析：本题主考NULL，一般来说当我们把一个空值以整数的形式输出出来的时候，默认的情况是0。
11 答案：C
分析：本题考的是指针变量的赋值，虽然p没有赋值，表示没有指向某个具体的对象，但事实上系统会让它随机的指向存储单元里的一个对象，那么它的返回值应该是所指存储单元中的值。
12 答案：B
分析：本题主要考函数中参数变量的定义，在B中连续定义两个变量，这在函数中是不可以的。
13 答案：C
分析：本题主要考指针的指针，c先指向b,b是一个指针，它指向a，故c最终是指向a的，故其值是a中的值。
14 答案：A
分析：本题主要考指针的赋值,我们不能把一个具体的值赋给一个指针变量。B选项是w,p指向同一对象。C是p指向a。D是把w所指对象的值赋给p所指对象。
15 答案：B
分析：本题主要考指针传值，p,q分别指向a,b,然而r会指向它们的较小值。
16 答案：D
分析：在D中把一个整形变量的值赋给一个指针的地址，故而是错的。应该写成p=&a。
17 答案：D
分析：本题主要考调用函数时指针传值和一般的变量的传值区别。指针通过地址传值，而变量是直接传值。c指针指向b，故对c指针里面的值的修改等于直接修改b中的值。
18 答案：D
分析：本题主要考指针的定义及指针变量的值的输出方式，指针b指向a，故输出其值是511。
19 答案：C
分析：本题主要考指针标识符*和乘号*的区别，*p=*p1*(*p2)中第1,2,4个*号是指针标识符，而第三个是乘号，故其运算的结果是3。
20 答案：C
分析：本题主考函数的嵌套调用和数据的类型转换，注意的是(int)(a+b),所以得到5.0。
21 答案：A
分析：本题主要说的是函数的递归调用，函数fun()实现的功能是从1加到n，然后返回给主函数。
22 答案：D
分析：A不能把一个具体的值赋给一个指针变量。B q是指向指针的指针只能保存指针的地址。C同B。
23 答案：D
分析：A指针赋处初值时不能把一个具体的值赋给一个指针变量指向的地址。B语法错误，C不能发地址赋给浮点型变量。
24 答案：C
分析：指针只能存放地址。
25 答案：C
分析：scanf()函数的输入数据列表应该是合法的地址表达式。
26 答案：D
分析：A中b需要预先定义，B中字符变量b只能接收单个字符。C中二级指针应定义为**c。答案D
27 答案：D
分析：代码“s+=2”是错误的，s是数组的首地址，但S是常量不能改变它的值。
28 答案：A
分析：B的正确格式是“p=&n”,C的正确格式是“scanf(“%d”,p)”，D的正确格式是“printf（“%d\n”,*p）”。答案A
二、填空题
1 答案：8 4
分析：void f()函数里的x,y分别是一个指针变量和整型变量，指针x指向一个整型的变量，即指向主函数里的x，故在函数void f()里修改指针x的值，会影响到主函数里的x的值，但修改void f()里的y的值却不会影响到主函数里的y的值。因为主函数x传的是地址，y传的是值。
2 答案：k *k
分析：由于k是一个指针，故第一个空应该填k。
由于第二个空要输出指针k所指对象的值，故应该填*k表示该指针所指对象的值
3 答案：35
分析：p,q分别指向x,y,然后调用函数swap();它的功能是把两个指针所指向的对象交换，原来a,b分别指向x,y，但交换后分别指向y,x,所以并不把指向的对象的值交换。 函数返回后，p,q仍然分别指向x,y。故其值不变。
4 答案： n=n/10
分析：把n除以10,每执行一次就可以把数的阳未位去掉，因为两个整数相除，不会保留小数，故最低位会丢掉，并且把数缩小到十分之一。然后依次从个位到最高位把数字输出。
5 答案：3 5
第七章 数组
一、选择题
1答案：B
分析：此题考察一维数组的定义，一维数组的说明中，下标必须为正的整型常量，不能为变量，在一维数组的初始化中，指出在单纯的定义时不能省略数组的长度。
2答案：B
分析：首先i=0时，判断i++〈7 成立，进入循环体，但此时i=1,p[1]=12不满足if语句，不执行j+=p[i]。按照此方法，得到j=p[2]+p[4]+p[6]=45,即B正确。
3答案：D
分析：首先i=0<7&&p[0]%2!=0，满足循环条件，执行k=k+p[0],即k=11, 然后执行i++,再进行判断，满足循环条件，k=11+p[1],所以k=24,执行i++,i=2,，再进行判断，此时不满足循环条件，循环结束，输出k值，为24。
4答案：A
分析：此题主要考察循环嵌套，第一个循环体执行完是将x[0]，x[1]，x[2]，x[3]，进行从大到小排序，第二个循环体执行完是将x[4]，x[5]，x[6]，x[7]进行从小到大排序。
5答案：B
分析：此题考察二维数组的定义，单纯定义二维数组时，行和列都不能缺省。在初始化过程中，列不能缺省，赋值的行数和列数不能超过数组的行数和列数。
6答案：D
分析：同上题分析一样。
7答案：D
分析：同上。
8答案： C
分析：此题分别输出m[2][0],m[2][1],m[2][2]。
9答案：A
分析：此题考察在for循环后，i=0,i=1时，执行if语句，使得a[1][0],a[1][1] 的值分别减1，而当i=2时，执行else语句， a[1][2]=1。因此输出a[0][1]+a[1][1] +a[1][2]=2+4+1=7；
10答案：B
分析：此题考察for循环，计算aa[0][1],aa[1][1],aa[2][2],aa[3][1]的和，即为19。
11答案：C
分析：由于自增加运算符（++）的优先级别高于取地址运算符（&），所以选项C无法表示aa[1]的地址，其他 三个选项都可以。
12答案：D
分析：数组名实际代表数组的首地址，也就是数组中第一个元素a[0]的地址，那么a+i就代表数组a中下标为i的元素a[i]的地址，*(a+i)就代表a[i]这个元素，所以*(*(a+i))的表示是错误的，此题选择D。
13答案：A
分析：本题答案为A，指针p指向数组a中第一个元素，此时p中存放的是数组中a[0]的地址，将指针p+2不是单纯的加一个整数2，而是将指针后移，两个存储单元，指向了a[2]这个数组元素，所以输出的是a[2]中的值3。
14答案：B
分析：此题答案为B，通过程序我们可知指针p指向数组中元素a[3]，指针q指向元素a[5]，输出*p+*q即输出a[3]+a[5]=10，所以选择B。
15答案：C
分析：本题通过循环控件用y累计p[1]+p[2]的值，由于指针p指向数组中元素a[1]所以p[1]即数组中元素a[2]，p[2]即数组中元素a[3]，a[2]+a[3]=6+8=14。
16答案：A
分析：我们让指针p指向数组a中第一个元素，然后通过循环控制输出指针p每次后移一个存储单元，并输出其所指存储单元中的内容，而指针p指向数组a，所以就是输出数组a中的每一个元素，选择A。
17答案：D
分析：*p表示指针p所指存储单元中的内容，所以（*p）++表示将p所指存储单元中的内容加1，不符合题目要求，其他三项都符合要求，所以选择D。
18答案：A
分析：为指针赋一个NULL值，就是指针具有一个空值，让一个空指针去访问一个存储单元时，将会得到一个出错的信息。
19答案：D
分析：变量p是一个指针，所以我们只能为其赋一个地址值，不能为其赋一个表达式或一个常量值，所以A、B、C三个选项不符合要求，D选项中，a代表数组a的首地址，是一个地址值，所以D正确。
20答案：C
分析：让指针p指向数组中元素a[3]，那p[5] 即数组中元素a[7]，所以b中的值是8。
21答案：B
分析：与上一题同理，指针s指向数组元素a[3]，s[2]即数组中元素a[4]，即为0。
22答案：C
分析：数组名t代表数组的首地址，所以*（t+i）就代表t[i]元素中的值，通过循环控制求累加和s，实际上
s=a[0]+a[2]+a[4]+a[6]+a[8]=1+3+5+7+9=25。
23答案：B
分析：让指针p指向二维数组a的第一个元素，那么可用p[0]代表a[0][0]，用p[1]代表a[0][1]…………，用p[8]代表a[2][2]，通过循环为数组a中的每一个元素赋了一个值。输出a[1][2]即p[5]的值为6。
24答案：D
分析：让指针p指向二维数组a的第一个元素，那么可用p[0]代表a[0][0]，用p[1]代表a[0][1]…………，用p[8]代表a[2][2]，通过循环为数组a中的每一个元素赋了一个值。再通过循环输出a[1][0]、a[1][1]、a[1][2]，即p[3]、p[4]、p[5]的值，所以输出的是3、4、5。
25答案：B
分析：在这里我们通过(*ptr)[2]定义了一个行指针ptr，ptr存放的是含有两个整型元素的一维数组的首地址。a是二维数组名，就是数组的首地址，ptr=a+i就代表，将数组中第i行的首地址赋给行指针ptr。能过第一个循环控制，为第0行和第1的首元素赋值，也就是为a[0][0]和a[1][0]赋值，输入的是1、2、3，但是只赋给两个元素，所以取前面两个值，所以输出时，a[0][0]的值为1，a[1][0]的值为2，其他的默认都为0。
26答案：B
分析：int *p[3]是表示定义一个指针数组，数组名为p，其中包含3个元素，每个元素都是一个指向int类型的指针。
27答案：D
分析：通过(*p)[5]则定义了一个行指针，存放长度为5的一维数组的指针，通过p=c，让p指向二维数组c，那么p[i]就是指向数组c中第i行的指针。p[i]+n就是数组中第i行，第n列的地址，如果要引用第i行第n列的元素，就可以表示成*(p[i]+n)，所以本题选择D。
28答案：D
分析：二维数组元素的地址可以用表达式&a[i][j]求得，也可以通过每行的首地址来表示，第i行的首地址可以通过a[i]来表示，a[i]+j就表示第i行第j列的地址，等价于*（a+i）+j，如果要引用第i行第j列的元素，则可表示成*（a[i]+j），*（*（a+i）+j）或(*(a+i))[j]所以本题选择D。
29答案：C
分析：p是一个指针数组，通过p[0]=a[1]可知p[0]中存放的是数组a中第1行的首地址，所以p[0]+1就代表第1行第1列元素的地址，所以*(p[0]+1)就代表元素a[1][1]。
30答案：C
分析：通过(*ps)[5]则定义了一个行指针，存放长度为5的一维数组的指针，通过ps=s，让ps指向二维数组s，那么ps[i]就是指向数组s中第i行的指针，可用ps[i][j] 或*(ps[i]+j)表示第i行第j列的元素。所以选项C正确。
31答案：A
分析：通过(*pa)[3]定义了一个行指针pa指向二维数组a，这样p[i][j]就表示a[i][j]，通过循环语句控制将a[1][0]和a[1][1]中的值分别减1变为3和4，给a[1][2]赋值为1。a[0][1]+a[1][1]+a[1][2]=2+4+1=7，所以本题选择A。
32答案：B
分析：循环共执行3次：i=0并且j=0时：
t=t+b[0][b[0][0]]=1+b[0][0]=1+0=1，当i=1并且j=1时：
t=t+b[1][b[1][1]]=1+b[1][1]=1+1=2，当i=2并且j=2时：
t=t+b[2][b[2][2]]=2+b[2][2]=2+2=4。
33答案：B
分析：第一个for循环控制输出的空格，第二个for循环控制输出数组中元素， 分析可知，输出数组元素时，第0行输出0个空格，并从第0列元素开始输出，第1行输出1个空格后，并从第1列元素开始输出依此类推，第i行输出i个空格后，从第i列开始输出，所以空格处填i。
34答案：A
本题中通过嵌套循环找出数组中最小的元素的值，存放在min变量中，并且将相应的行号放在row变量列中，列号放在col变量中输出。
35答案：A
分析：p=s就表示让指针p指向数组s的首地址，数组中第一个元素，所以*p可以表示s[0]，A选项正确；数组s中的元素个数由定义数组时的下标决定，P所指的字符串长度由实际的字符个数决定，是不相等的，所以B错误，s数组名代表数组的首地址，是一个地址常量，不是变量所以C错误；数组s中存放的是数组中的每一个元素，而指针变量p中存放的是数组的首地址，所以D错误。
36答案：A
分析：通过pc=ch，让指针pc指向数组ch中的第一个元素，此时pc+i即表示ch[i]的地址，所以输出*（pc+5）即输出元素ch[5]中的字符“z”。
37答案：D
分析：swap1(a,a+1)是将数组中元素a[0]和a[1]的地址传递给形参c0和c1两个数组，然后在函数swap1中对它们进行交换，由于传递的是地址值，所以形参变化，对应的实参也发生改变；所以a[0]与a[1]中的值也相互交换；swap2(&b[0],&b[1])是将数组b中元素b[0]和b[1]的地址传递给形参指针变量c0和c1，然后对指针变量所指的存储单元中的值进行交换，所以b[0]和b[1]中的值相对也发生变化，因此最后输出的值为5 3 5 3。
38答案：C
分析：循环for (i=0;i<12;i++) c[s[i]]++; 共执行12次，分别为：c[1]++，c[2]++，c[3]++，c[4]++，c[4]++，c[3]++，c[2]++，c[1]++，c[1]++，c[1]++，c[2]++，c[3]++，其中c[1]自加了4次，c[2]自加了3次，c[3]自加了3次，c[14]自加了2次，所以c[1]的值为4,c[2]的值为3,c[3]的值为3,c[4]的值为2,输出结果为4 3 3 2。
39答案：C
分析：函数fun的功能是将数组中下标从i到j的元素倒序，在主函数中先通过调用fun(a,0,3)将a[0]到a[3]的元素倒序得到{4,3,2,1,5,6,7,8,9,0}，再通过fun(a,4,9)将a[4]到a[9]的元素倒序得到{4,3,2,1,0,9,8,7,6,5}最后再通过fun(a,0,9)，将a[0]到a[9]中的所有元素倒序得到{5,6,7,8,9,0,1,2,3,4}。
二、填空题
⒈ 答案：24
分析：此题分析过程同选择题3。
⒉ 答案：1111
分析：本题正确答案为1111。初始化时数组中每个元素的值都是0，通过循环让数组中n[1]到n[4]中每个元素的值都是其前一个元素的值乘以2后，值仍为0，然后输出每个元素的值加1，即1111。
⒊ 答案：30
分析：计算s=a[0][0]+a[0][2] +a[1][1] +a[1][1] +a[2][2] +a[2][0]=30
⒋ 答案：1 2 3（换行）0 5 6（换行）009
分析：在第一个for循环中，使得a[1][0],a[2][0],a[2][1]全部等于0，因此输出即得。
⒌ 答案：92
分析：i=0时，首先判断i++<4成立，执行循环体，此时i=1,在do-while内层循环中，得到 s=a[1][0]+a[1][1]+a[1][2]+a[1][3]=26；然后再进行条件判断i++<4,进入循环体，此时i=2，执行continue，再一次进行条件判断，进入循环体，此时i=3，因此计算s=a[3][0]+a[3][1]+a[3][2]+a[3][3]得到 s=92。
⒍ 答案：58
分析： i=0时， s=a[0][0]+a[0][1]=3；
i=1时，由于a[1][0]= =0。因此跳出内层循环；
i=2时，得到s=s+a[2][1]=3+23=26；
i=3时，得到s=s+a[3][1]=26+32=58。
7、 答案：6
分析：通过循环控制，让数组中的每个元素与x进行比较，如果该元素的值小于x，则将该元素的值赋给z，否则将x赋给z；y=0时，z=2；y=1时，z=4；y=2时，z=6，最后结果是6。
8、 答案：19
分析：该题通过循环控制用y来累计和，
y=y+a[1]+a[2]+a[3]=1+4+6+8=19。
9、答案：6
分析：指针p指向数组a的首元素，通过循环控制，将p所指元素中的值赋给数组中的每个元素，由于是同步的，所以数组a中元素的值并没有变化。
10、答案：5768
分析：p的地址为5732，所以p+9的地址为5732＋4×9＝5768。
11、答案：2
4
分析：指针p指向数组中的第一个元素，第一条输出语句，输出p所指的存储单元中的内容，即2；然后将指针p后移，指向下一个元素，由于k指向p，所以输出**k，也就是输出，p所指的存储单元中的内容，即4。
第八章 字符串
1 D
解析： 在C语言中，字符串常量是由双引号括起来的，由若干个字符所组成的序列。所以A选项中的字符是由一对单引号括起来，C选项中只有一个双引号，皆错。对于B选项，定义了一个字符变量，却给它赋了字符串常量，错误。若该改为 char str[] =”\x43”,则也正确。
2 A
解析：A选项中ss[1]可以看作是一个地址常量，其值不能改变，所以不可以对其赋值。但是在定义二维数组的时候，对其进行初始化是允许的，如选项B。 选项C和D定义的是字符指针变量，可以对其进行赋值。
3 A
解析：Str是地址常量，P是指针变量，两者类型不一致，选项B错误。Str数组的长度是20，而P所指的字符串遇到’\0’就结束，本题中其长度应该为7，选项C错误。同理，既然Str数组的长度与P所指字符串长度不同，所以存放的内容肯定不同，选项D错误。
4 C
解析：对于 数组P，只有三个元素，分别是’a’,’b’,’c’,所以sizeof(P)的输出结果应该是3 ，对于数组q，存储了四个元素，分别是’a’,’b’,’c以及’\0’。所以 sizeof（q）的输出结果是4。
5 C
解析：本题的分析同第4题。
6 C
解析：数组a中存储了7个字符，分别是’a’,’0’,’\0’,’0’,’a’,’0’,’\0’,当使用sizeof(a)统计计数的时候，会统计计算这7个字符，但是当用strlen（a）统计数组元素个数的时候，遇到’\0’的时候就会结束，所以最终的输出结果是7 2 。
7 B
解析：ps=s语句使ps指向数组s的首地址，即指向元素a，对于表达式*p+4，由于*的优先级高于+，所以进行间接访问运算，得到a，再+4，根据ascii码的顺序，最后的输出结果应该是e，答案为B。
8 B
解析：选项A的getc（）函数完成的是从文件中读入一个字符，而不是题目所要求的从键盘读入一个字符，错误。选项C的getchar（）函数每次读入的是一个字符变量，而不是字符串变量，错误。选项D的scanf（）函数，通过格式控制符%s可以读入字符串变量，但是遇到空格会作为输入数据的分隔符，不会被作为数据读入。选项B gets（）函数可以完成题目要求的功能，参见课本P1102 例6。
9 D
解析：选项A中的参数2的数据类型不匹配，应改为&x[4],选项B中的y是指针常量，不能进行++运算，错误。 选项C中参数1对应的数组长度小于参数2 的数组长度，错误。
10 B
解析：strlen（）函数统计字符串长度的时候，是在遇到’\0’的时候结束统计。所以对于数组q来说，定义了数组的长度为10，并给前三个字符赋了初值，则从第4个字符开始，系统将数组元素的值置为’\0’,所以strlen(q)的结果是3 。而对于数组p来说，数组长度为3，但是何时遇到’\0’无法确定，所以strlen（p）的值也无法确认。
11 D
解析：函数f（char *p[]，int n）完成的功能就是对字符串进行字典排序，根据题目，最后将排在第2位的字符串是“abbd”，所以strlen（p[1]）的输出结果应该是4。
12 A
解析：*运算符和++运算符的优先级相同，且结合方向都是自右向左，所以结果是15 ，答案为A。
13 D
解析：根据函数代码，若返回的是正数，则表示a字符串的字典排序在b字符串之后，若返回0，表示a和b中存储的字符串一样，若返回负数，表示a字符串的字典排序在b字符串之前。
14 A
解析： point（）函数传递的是指针变量的值，而不是指针变量本身的地址，仍然是一个传值而不是传地址的过程，实参的值没有改变，所以指针p仍然指向字符串的首地址，输出结果为a。
15 D
解析：比较字符串大小的时候，应该调用函数strcmp（），而不是直接进行比较，选项A错误。对于选项B，只要s1和s2不相等，无论s1所指串是大于或是小于s2所指串，其结果非0，都会执行语句S，与题意不符，错误。选项C的函数实参顺序错误。
16 B
解析：对于二维数组，第二行的首元素是接着第一行的最后一个元素的。所以p+10是指向字符串“Beijing”的首地址，所以正确答案是B。
17 D
解析：对于格式控制符%s，在输出的时候遇到’\0’才结束输出。所以答案为D
18 B
解析：gets（）函数需要的参数是指针类型的。所以ACD都满足条件，答案B中的a[0]是字符，不是指针类型，错误。
19 A
解析：P[4]指向的应该是第5个字符串的首地址，即字符串“cd”，所以strlen（p[4]）的结果是2。
20 C
解析：数组名是指针常量，不能对其进行赋值，所以选项C错误，需要注意一点：在定义字符数组的时候可以初始化，如选项A。
21 C
解析： swap函数实现了交换字符串首地址中对应的元素，所以输出结果为1bc，a23。
22 B
解析：fun函数统计首字符是’T’的字符串的个数,所以符合条件的有”Tue”和”Thu”,输出结果为2.
23 A
解析：fun1函数中的(*q)++将指针q所指向的字符进行一次自加运算,所以输出结果为A.
24 C
解析:注意字符串“3697”和存储了一个’\0’,所以j+=2，在字符’9’之后指向的数据是’2’,’8’,’4’,都不满足条件（p[i][j]-‘0’）%2,所以结果为C。
25 C
解析:二维数组str的第二维数是20,所以p+20保存的是字符串”Beijing”的首地址.strlen(p+20)输出的就是字符串”Beijing”的长度.结果为7。
26 A
解析:while中的语句是*p2=*p1，注意，这是赋值语句，不是比较语句，正确答案为A
27 C
解析 : p=s[1]语句使得指针p指向字符串“two”的首地址，所以*（p+1）的输出结果是“two”的第二个字符‘w’，正确答案为C。
28 B
解析: puts（）函数实现的功能是输出字符串，for循环 中，ps的值首先保存最后一个字符地址，逐一 递减，输出的结果为B。
29 D
解析: strlen（p）遇到‘\0’结束执行。所以只统计了指针p指向的前5个字符“abcde”, 结果为5 。
30 A
解析: 字符串s中的存储字符有下面9个：’\\’,’1’,’4’,’1’,’\141’,’a’,’b’,’c’,’\t’,所以strlen（s）的结果为9。
31 B
解析: ch[1] 可以看作是二维数组的行指针，指向第二个字符串的首地址，注意输出中的转义字符\” ,输出的结果是显示一个”.
32 A
解析：字符串常量“good！”赋给字符串变量时，再结尾自动加上字符’\0’,这样就一共需要6个存储单元，但是选项A中的数组str的长度只有5，所以错误。
33 D
解析：程序执行while循环，最后一次执行中，pb指向b1的首地址，所以将b1全部拷贝给b2，所以程序的输出结果为7。
二 、填空：
1 9
解析：IBM为3个长度，\n为1个长度，012为3个长度，\1为1个长度，\\为1个长度，故长度为9。
2 *2*4*6*8 *
解析： while循环实现的是将字符串的奇数位赋值为*，并输出，偶数位原样输出。
3 *t++
解析：注意变量t需要自加 。
4 efgh
解析：strlen（s）/2的值为4，所以指针变量p的起始地址是从字符‘e’的地址开始，格式控制符%s输出遇到‘\0’结束。所以输出efgh。
5 cdeab
解析：move函数实现的功能是将字符串循环左移。
6 s[i]>=‘0’&&s[i]<=’9’
解析：判断字符串中单个字符的ASCII码是否在“0”-“9”之间，就可以判断字符是否是数字。
7 p+n
解析：得到字符变量c的值在字符数组变量str中出现的位置，再让指针p前移这个位子的数字。
8 s-1 *s++
解析：要注意s=s-1是让指针变量后移一位，移到‘\0’前面。
9 *t
解析：注意，由于后面的循环体语句有t++，所以这里是*t 而不是*t++。
10 bcdefgha
解析：ss函数实现的是实现字符串循环左移的功能。
11、gae
解析： 循环的作用是输出字符串a和字符串b下标相同时字符也相同的字符。
12、 abcfg
解析：注意循环第3此取到的是‘\0’结束符。
13、 strlen（str）+str-1 t = =0 huiwen（str）
解析：用一个指针指向输入的字符串的头，一个指针指向输入的字符串的尾。然后对比指针的值，然后使头指针自加，尾指针自减，再对比值。
第九章 文件
知识点概要：
学习本章内容首先要弄清楚文件的概念，尤其是读文件和写文件的概念。这里对其中几个概念稍加解释一下：
1、顺序读写文件：进行读或写操作时总是从文件开头开始，从头到尾的读写，不能任意读写。
2、随机读写文件：可以不从开头读写，可从任意位置开始读写文件。
3、 ASCII文件(也称为文本文件)：这种文件在磁盘中存放时每个字符对应一个字节，用于存放对应的ASCII码。例如，整数5678的存储形式为：
ASC码： 00110101 00110110 00110111 00111000
↓ ↓ ↓ ↓
十进制码： 5 6 7 8 共占用4个字节。ASCII码文件可在屏幕上按字符显示，例如源程序文件就是ASCII文件，用DOS命令TYPE可显示文件的内容。 由于是按字符显示，因此能读懂文件内容。
4、二进制文件：是按二进制的编码方式来存放文件的。 例如，整数5678在计算机中的存储形式为： 00010110 00101110只占二个字节。如将其存放到二进制文件中，其存放的内容就是00010110 00101110。二进制文件虽然也可在屏幕上显示， 但其内容无法读懂。C系统在处理这些文件时，并不区分类型，都看成是字符流，按字节进行处理。输入输出字符流的开始和结束只由程序控制而不受物理符号(如回车符)的控制。因此也把这种文件称作“流式文件”。
1 C
定义fp的文件指针应为:FILE *fp,所以C选项不正确
2 B
打开文件data.dat,并且使得文件指针fp指向该文件，I的值为1,2,3,4,5时,满足条件2,依次将1,2,3,4,5输入到文件中，并且在I为3时满足(I%3==0),所以输入3之后换行,再输入的4,5.rewind(fp)使得文件指针fp指到文件的开头，然后将指针的当前位置开始，取两个数到变量k,n中，使得k=123,n=45,因为数据是以间隔符分开的.所以结果是123 45,选B.
3 D
fseek(fp,n,SEEK_SET)的作用是使得文件指针移动到文件开始后的的n个字节位置上，此处的n为0,所以就是移动到文件的开始处,这与rewind(fp)作用相同，所以选D。
4 C
fprintf(fp1,”abc”)是使得abc依次写到指针fp1指向的位置，所以abc覆盖good，所以f1.txt中的内容变为abc，选C。
5 B
通过第一个for语句,依次将1,2,3写入到文件中，并且1,2,3之间无间隔符,所以通过fscanf(fp,”%d%d”,&k,&n);将123赋给了k, n为赋值,仍为初始化的值,所以最后的结果为123 0,选B。
6 D
通过第一个for循环使得数组中的值依次写入文件中，fseek(fp,-2L*sizeof(int),SEEK_END), 使得指针移到3所在的字节的首位置，fread(&b,sizeof(int),1,fp);把指针fp所指的值放到变量b中，所以结果是3,选D
7 A
因为feof(文件指针)的作用是判断文件是否结束，是则返回1否则返回 0,本题中未遇到文件结束,所以应返回0,选A;
8 D
C系统在处理文件时，并不区分类型，都看成是字符流，按字节进行处理。 输入输出字符流的开始和结束只由程序控制而不受物理符号(如回车符)的控制。 因此也把这种文件称作“流式文件” ，按数据的存放形式我们可以将文件分为二进制文件和文本文件。
9 D
C语言中，顺序读写方式适用于二进制文件，所以选择D。
10 A
fopen中的文件名和打开方式都应该用双引号引起。
11 答案：A
解析：考察fprintf函数和fscanf函数。程序首先以写文本文件的形式向文件写入整数20，换行符号’\n’，然后再写入整数30，换行符号’\n’然后调用fscanf函数读出两个整数，分别赋给k,n。这里要注意的是在文件中存放的是2和0的ASCII值，换行符’\n’的ASCII码值，3和0的ASCII值，换行符’\n’的ASCII码值。所以读取整数时是先取出2和0的ASCII码值，当读到换行符’\n’时，发现其不是数字，不是整数的一部分，于是就将2和0作为整数，于是的到20。同样再读下一个整数时，先找到3和0，遇到换行符是停止，得到30。注意此题与第五题的区别。
12、答案：D
解析：概念的理解，参考课本。FILE可以指向二进制和文本文件。
13、答案：B
解析：考察文件路径的书写格式和fopen函数的写法。参看课本P115页打开文件部分。
14、答案：A
解析：程序开头用”wb”方式打开文件，即以写的方式打开二进制文件，注意这里不是追加，所以打开时文件指针指向文件头，通过fwrite写入“Fortran”后，通过fseek函数重新将文件指针移到了开头，所以后面的操作将会覆盖掉前面的。由于写入”Basic”为5个字节，所以原先的最后两个字符没有覆盖掉。故选“Basican”。
15、答案：B
解析：考查fseek函数，这个函数中预定义表示SEEK_END是指最后一个字符的后面。所以此题首先写入”abcd”,再从最后开始向前移动两个，即从字符“d”的后头开始向前移动2个，这是指向字符“c”。故选B。
16、答案：C
解析：在C语言中，我们既可对文件进行顺序存取，也可进行随机读写操作，所以A选项错误，如果以添加的方式打开文件，这时对文件进行写操作，文件中原来的内容不变，所以B选项错误；在一个程序中当对文件进行了写操作后，不用先关闭该文件再打开，也可读到第一个数据，只要移动指针到相应位置即可，所以D选项也错误，只有选项C正确。
17、答案：B
解析：getchar函数用于从终端读入字符，所以B选项是错误的。其他的都是正确的说法，因此选择B。
18、答案：C
解析：buffer是一个内存块的首地址；size是一个整型变量，代表每个数据块的字节数；count代表待读取数据块的个数；fp是一个文件指针，指向待读取的文件。所以本题选择C。
19、答案：B
解析：考察fprintf函数和fscanf函数。程序首先以写文本文件的形式向文件写入整数1、2、3，换行符号’\n’，然后调用fscanf函数读出一个整数，赋给n。这里要注意的是在文件中存放的是1、2和3的ASCII值，换行符’\n’的ASCII码值，所以读取整数时是先取出1、2和3的ASCII码值，当读到换行符’\n’时，发现其不是数字，不是整数的一部分，于是的到123。
20、答案：D
解析：程序首先以写文本文件的形式向文件写入整数1、2，换行符号’\n’，再写入整数4、5、6，换行符号’\n’，然后调用fscanf函数读出两个整数，赋给n和k。这里要注意的是在文件中存放的是1和2 的ASCII值，换行符’\n’的ASCII码值，以及4、5、6和’\n’的ASCII码值，所以读取整数时是先取出1、2的ASCII码值，当读到换行符’\n’时，发现其不是数字，不是整数的一部分，于是的到12给变量n，同理再读出456给变量k。所以选择D。
填空题
1、答案：Hell
解析：函数fgets,这里实际输入的字符个数比给定的要少一个。题目给定的是5，所以实际输入的应该是5-1=4，即Hell。
2、答案：“d1.dat”,”rb”
解析：此题考查函数fopen的用法，注意文件的打开方式，以读打开二进制文件的方式为”rb”。
3、答案：!feof(fp)
解析：考察函数feof的使用。如果文件结束返回1，否则返回0。所以这里如果还没有到文件结尾的时候就继续读入字符。
4、答案：“rb”
解析：考察文件的打开方式。题目首先是以写的方式打开二进制文件。然后关闭文件。重新打开文件时只要读取数据，所以以只读的方式打开就可。由此文件是二进制文件。所以用二进制方式打开。故答案为“rb”。
5、答案：“a”
解析：如果要在文件的后面续写内容，只要以添加的方式打开文件即可，所以打开文件的方式用“a”。
6、答案：“file.dat”，“r”
解析：题目中要求，从名为file.dat的文件中读入字符显示在屏幕上，那么就要求以读的方式打开文件，所以答案为“file.dat”，“r”。
第十章 对C语言的进一步讨论
一、 选择题
1：C
main()函数的参数通常是两个，第一个必须是int型，第二个必须是字符串的指针。
2：D
程序的含义表明将输入的参数命令行看作字符串，将第2，4个字符串即（abcd h3）的字符个数相加，存放到len中，输出。
3：D
Int*f()表示返回值是指针的函数
4 ：D
A,B,C选项正确，D选项中，f是指向函数的指针不能这样调用
5：B
函数的递归调用分为直接地归调用和间接递归调用两种，其中间接递归调用自己的称为间接递归调用
6：C
这是函数递归调用：
Fun(7)调用后等价于7-fun(5)，又去调用fun(5)，fun(5)又相当于5-fun（3）这时程序相当于计算7-(5-fun(3)),即7-5+fun（3）, 又去调用fun(3)，fun(3)又相当于3-fun（1）,程序相当于计算7-5+3-fun(1),结果为2。
7：A
这是函数递归调用：x的输入值为10，调用fun(10),相当于以下过程：
fun(10)=10+fun(9);
10+fun(9)=10+9+fun(8)
10+9+fun(8)= 10+9+8+fun(7)
10+9+8+fun(7)= 10+9+8+7+fun(6)
10+9+8+7+fun(6)= 10+9+8+7+6+fun(5)
..........
10+9+8+7+6+5+4+3+2+fun(1)= 10+9+8+7+6+5+4+3+2+1;
结果为55
8：D
A项：预处理命令不一定要放在程序开头，B：一行只能有一条预处理命令。C宏名可以小写，但一般用大写进行区别。
9：C
f（x）为代参数的宏，f(8)相当于8*8，f(4)相当于4*4，同样f(4+4)相当于4+4*4+4,f(2+2) 相当于2+2*2+2所以结果是4,3.
10：A
F(X,Y) 为代参数的宏,F(a++,b++)相当于（a++）*(b++),结果为12
11：C
M1+M2相当于(N*3)+(N*2),而N相当于5所以结果为25。
12：A
A正确，B作用域没有发生变化。C：未赋初值static类型的变量，系统会给它赋初值0。D：形参不能使用static类型的。
13:A
见教材P131
14：A
主函数中的printf(“%c%c”,a,b);中a,b用的是全局变量，执行fun1()后a,b的值以改变，而fun(‘E’,’F’)传递给的是函数fun2()的局部变量。所以答案是A。
15：D
f()中的i是static类型，所以其值会保留为上一次起算的结果。
16：A
malloc()函数的括号里是字节数，根据题意，选择A
17：A
指针ｐ和ｑ指向同意存储区域，因此，scanf(“%s%s”,p,q);实际是给一块内存区域进行了两次付值，值为def，因此输出为def def.
18：A
见教材P126
19：D
见教材P126，typedef说明3。
20：B
C语言必须经过编译解释成为机器语言，生成EXE文件，才能执行。
21：C
见教材P144
22：A
见教材P144
23：D
非执行语句不一定会转换成二进制代码，例如程序的注释部分。
24、D
见教材P144
25、D
见教材P144
26、A
C语言用整数来表示逻辑类型，0为假非0为真。结构体和共用体属于构造类型有称为集合类型。
27、答案为：D
预处理命令是在是由预处理程序在编译前做出处理。
28、答案为：B
宏的作用是使用标示符代替常量表达式。它属于预处理命令是由预处理程序在编译前做出处理。
29、答案为：A
见教材P126
30、答案为：C
此题求的是传给程序的参数的长度之和。注意argv[0]保存的是程序地址的指针。
31、答案为：D
注意由于#define HDY(A,B) A/B 不是事#define HDY(A,B) (A)/(B)。所以展开后是“1+3/2+4” 结果是6
32、答案为：B
i1=f(2)展开得到i1=2*5+1结果是11，i2=f(1+1)展开得带i1=1+1*5+1结果是7。
33、答案为：A
static和extern是在程序编译的时候就占用了内存单元。
34、答案为：B
要注意的是有个全局变量a,一个静态变量a，一个局部变量a。要清楚它们的作用域。
35、答案为：B
由于i，m是静态变量，在第二次调用fun()时i = 3,m=5。
36、答案为：B
见教材p140
37、答案为：C
见教材p140
38、答案为：A
这是一个递归程序，由于n=3，所以fun(n-1,&f1) 得到f1=1，fun(n-2,&f2) 得到f2=1，*p=2。
39、答案为：C
fun(7)=7-fun(5)，fun(5)=5-fun(3)，fun(3)=3-fun(1)，fun(1)=3。得到fun(7)=2。
二、 填空
1: c
解释：c作为实参用作宏定义的参数，起到临时存放变量值的作用。
2：findbig
解释：这是利用函数指针调用函数的题目，函数名相当于函数的入口地址，函数指针应该存放被调用函数的函数名。
3：/n
解释：fac初始值为１在循环中，利用/n相当于依次求取1、1/2，1/(1*2*3)…….1/(1*2*3*4*4*6*7*8*9*10),利用s把每一次fac的值进行累加，完成题目要求。
4：3*sizeof(double)
解释：mallo()函数是用来动态划分内存空间的，传递的参数是空间所占的内存大小，即字节数，按照题目要求分配3个double 型的内存单元，应该填入3*sizeof(double)。
5、p=malloc(sizeof(double));
6、16 11
解释：i=f(1+1)展开得到i=(1+1)*8得到16；j=f2(1+1)展开得到j=1+1*10得到11 。
7、40
解释：s1和s2是指向同一个地址，所以给*s2赋值20，实际此时*s1也等于20。
8、55
解释：k=N*N*5展开得到k=5+5*5+5*5。
9、10
解释：fun(a,3)展开得到，a[0]+fun(a+1,3-1)，fun(a+1,3-1)=a[1]+ fun(a+2,3-2)，
fun(a+2,3-2)=a[2]+ fun(a+3,3-3)，fun(a+3,3-3)=a[3]结果为：1+2+3+4
第十一章 结构体与共用体答案与解析
一、选择题
1、C
解析：在本题中TT为结构体名，用关键字typedef对结构体进行说明,CIN一个具体的结构体类型名等价于struct TT, 可以用CIN来直接定义结构体变量，而不用再写struct。A:答案不能用TT直接定义结构体变量，一般格式为（struct TT 结构体变量名）；B:答案概念错误，D:答案CIN不是结构体变量，是一个具体的结构体类型名。
2、D
解析：这是一个给结构体赋值的简单实例，A:答案是给结构体数组中的成员s[0]中的字符数组name赋初值，s[0].name表示该结构体中字符数组的首地址，B:选项中表示给结构体数组s中的结构体s[0]中的age变量赋初值，C:答案中&(ps->sex)等价于将结构体指针变量指向的结构体s[0]中的成员sex并进行取址运算，等价于&s[0].sex；D:答案明显错误，不能给变量直接赋值，用scanf函数必须用取址运算，ps->age，在这里等价于s[0].age.
3、C
解析：第三题的结构我们可以用以下关系表示：
答案A:实际上是将y指针变量所指向的数组a中的数组的第一个数字拿出来，所以a答案应该为1，答案B:是将pt结构体指针变量所指向的结构体数组c中c[0]的成员x的值取出来，所以我们可以知道答案B的结果为10；答案C由于指向运算符的优先级别高于自加运算，所以是pt结构体指针变量所指向的结构体数组c中c[0]的成员x的值自加之后的值结果为11；D答案结构体指针变量pt++表示将pt所指向的变量由c[0]改为c[1]的首地址，再将x的值取出来，由于x的值为20，所以答案D也可以排除。
4、D
解析：第三题的结构我们可以用以下关系表示：
A:答案实际上是将p所指向的变量由stu[0]改为stu[1]的首地址,并将stu[1]中的成员num取出所以A答案的结果为字符串常量“200402”；答案B将p所指向的stu[0]中的成员num取出所以结果为字符串常量“200401”；答案C是将p所指向的首地址为stu[0]中的成员num取出所以结果为字符串常量“200401”，C答案中的括号不能省略；答案D中不存在结构体变量stu[3]，所以不存在stu[3].age成员。
5、B
解析：表达式++(p->x)是将结构体指针p所指向的结构体变量date[0]中的成员x进行自加运算后的值，所以也就等价于stu[0].x++。
6、A
解析：选项B中不能将字符串常量赋值给字符变量，选项C、D错误十分明显。
7、D
解析：第七题主要是对链表的考察，答案A是将变量q->next的值赋值给p->next变量, q->next在这里指的是图中结构体指针变量r所指向的那个结构体变量存储空间的首地址，这时q->next变量中存储的是指针变量r所指向的那个结构体变量存储空间的首地址，所以能够完成具体操作；答案B中p->next->next等价于变量q->next所以答案A、B是等价的；答案C直接将r所指向的那个结构体变量存储空间的首地址赋值给p->next变量，所以也能够完成具体操作，答案D P=q->next实际上不是删除节点的操作，不能将结点删除，只是改变结构体变量p所指向节点的首地址，实际上完成D答案的操作后将使结构体指针p、r指向同一个节点。
8、C A B
解析：第一空是函数CreatList返回值得类型，我们可以从程序中得到返回值h为结构体指针变量，我们可以从程序中找到答案；第二空是给结构体指针p所指向的成员中的date变量赋值，这个值来自函数形参的传递值，所以我们选择答案A，结构体指针在这里只起一个传递的作用，具体结构如下图：第三空是在将新开辟的节点与链表联接后，将指针变量p所指向的首地址传递给结构体指针变量q，使结构体指针变量同时指向新开辟的单元的首地址，所以选B答案。
9、C
解析：对于占用两个字节的共用体， 第一次赋值，高位编译系统已经给其赋值为0，所以在输出的时候，高位已经有内容，而不是没有初始化。
10、B
解析：共用体和结构体一样，对于单个元素的引用(包括初始化以及数据输出)一定要用成员运算符‘.’。不能对共用体进行整体运算。
11、A
解析：A选项中，用typedef说明了一个结构体类型名REC，然后再用这个新类型名定义变量，是符合要求的；B选项中先说明了结构体类型，但定义变量时不符合要求，应该用struct REC t1,t2；C选项在用 typedef说明结构体类型时定义了变量是不符合要求的；D选项不是用typedef说明时，却说明了结构体类型名，是不符合要坟的，所以选择A。
12、A
解析：本题的重点是函数调，程序在调用f()函数时，将STU类型的结构体变量c的值传递给形参a，在函数f（）中对a的各个成员进行重新赋值，但是并没有将值返回，所以输出的仍是主函数中结构体变量c的原有值，所以选择A。
13、D
解析：本题首先在说明一个结构体类型的同时，定义了一个该类型的指针变量p，然后用该结构体类型定义了一个包含4个元素的结构体类型数组a，并让指针p指向数组a的首地址，并且通过循环控制输出a[0].x和a[1].x的值，即20和15。注意：每个数组元素中的成员y中存放的都是指向下一个元素的地址，所以p=p->y就是让指针p后移，指向下一个元素。
14、D
解析：本题的重点是函数调，程序在调用f()函数时，将STU类型的结构体变量a的值传递给形参c，在函数f（）中对c的各个成员进行重新赋值，但是并没有将值返回，所以输出的仍是主函数中结构体变量a的原有值，所以选择D。
15、A
解析：程序中说明了一个结构体类型，并用该类型说明了一个结构体类型的变量s，其中包含一个整数n和一个整型数组a，在主函数中调用函数f，交将结构体变量s的地址传递给形参结构体指针变量p，然后对p所指变量中的数组按从小到大的顺序排序，由于是址传递，所以形参值的变化也影响实参的值，所以主函数中输出的是排序之后数组a中的值。
16、C
解析：typedef类型说明并没有真正地定义新的数据类型，它只是相当于给某个已有的数据类型起了一个别名。在本题的typedef语句中“struct node{int data;struct node * next;}*”就是已有类型名，给这个已民用工业类型所起的别名就是NODE。所以，下面授定义语句可以将NODE用“struct node{int data;struct node * next;}*”替换掉，即完整的定义语句是“struct node{int data;struct node * next;}*p；”。由此可见，p是指向struct node结构变量的指针，所以选择C。
17、D
解析：本题考查共用体数据类型。共用体的特点是该类型变量与所有成员的起始地址都相同，且在每一个时刻所有的成员中只有一个有效，即当一个成员被赋值，其余的成员就不起作用了，所以选项D错误。本题选择D。
18、B
解析：第10题相同，解析见第10题。
二、填空题
1、2002Shangxian
解析：对字符串的操作strcmp(s1,s2)是比较两个字符串第一个不相同字母并返回首个不相同字母的ascall码的差值，若第i个字母不同则上述字符串的返回值为(s1[i-1]-s2[i-1]),结果为一个整数，题目先将结构体变量a赋值给d将,然后将结构体变量b赋值给d,由于程序第11行中if 后面的表达式不成立所以没有将结构体变量c的值给结构体变量d,题目前面又将结构体变量d的首地址赋值给结构体指针变量p所以此时，结构体指针p指向结构体变量d，那么题目最后输出的结果实际是结构体变量b中的内容。
2、struct node *
解析：自身结构体指针变量的类型必须和定义的结构体相同，由于是指针变量所以我们在后面加一个*号
3、sizeof(struct node)
解析：注意mallco函数的基本格式，后面表示在内存中动态分配一个长度为sizeof(struct node)的连续空间，在链表中非常常见。
4、struct DATE d = {2006, 10, 1}
5、p!=NULL p->next或者（p++）
解析：NULL表示空地址，一般是链表结束的标志。第二空实际上是一个改变链表中节点的首地址的操作、p=p->next的作用在这里实际上是输出结构体指针所指下的结点中相应的值，再将结构体指针指向下一个节点的首地址执行下一个节点中内容的输出操作。
6、->next->data
解析：p->next->date等价于图中q->date;由于链表时循环的r->next实际上是图中结构体指针p所指向的那个节点的首地址，要取出结构体指针r所指向的结点的值只需(r->next->next->next->date)或者p->next->next->date
7、p->next
解析：如果要找最小值，就要对每一个结点的data成员进行比较，空白处要求填的实际是结构体指针变量p的变化值，也就是指针p向后移，指向下一个结点的首地址，所以填p->next。
8、person[i].sex
解析：本题中说明了一个结构体类型SS，并定义了一个该类型的数组w，在主函数中调用fun函数，将数组w传递给形参数组person，在函数fun中利用for循环控制来统计person数组中sex为M的记录的个数，在空白处需要填写数组中第i（是循环变量）个元素的sex成员的值是否为M，所以空处应该写成person[i].sex。
9、5
解析：程序中建立了一个结构体类型的数组，其中包含3个元素，将这个3个数组元素建立成一个单向循环链表，每个元素是其中的一个结点，然后让p指向第一个结点（数组中第一个元素）；q指向第二个结点（数组中第二个元素）；r指向第三个结点（数组中第三个元素）。所以q->next->num就等价于r->num而r->next->next->num就等价于q->num，所以sum就是r->num+q->num=2+3=5。
第十二章 数组与函数
选择题
1、 D
此题关键是：搞清楚函数声明内形参表的数据类型要与函数首部的形参表的数据类型要一至 ,实际上形参表中传递的地址值，即指针形参选项A B C中，都有一个或者两个形参传递的不是指针形参
2、 A
程序分析题
void chang(int k[]) 的意义是将k[]数组中第五个元素的值赋值给第零个元素
注意：chang(&x[n])函数中传递的地址时变化的。故选A
3、C
考察静态局部变量
此地关键是：声明了静态局部变量---static int sum=0;静态变量在函数结束时其其值不会消失。故选C
4、C
排序题
sort(int a[],int n)函数实现的是将数组a[]中的数按从大到小排列，故选C
5、A
元素求和题
函数sum(&a[2])执行的实质是： a[2]=a[1]+a[3] 即a[2]=2+4=6，选A
6、D
元素交换题
函数swap1()和swap2()都是将形参表内的两个元素交换，关键是搞清楚数组名的另一层意思是数组的首地址，所以选D
7、C
程序分析题
函数fun(a,2,9)的作用是,a[10]=a[9],a[9]=a[8],a[8]=a[7]-----------a[3]=a[2]，所以选C
8、B
程序分析题
函数prt(int *m, int n)的作用是将数组m[]中的元素的值都加一。故选B
9、B
元素交换题
其中用于swap1()传递的是数组的地址，通过操纵数组地址实现元素的交换，而swap2()传递的是两个数，在执行完swap2()后，它函数体内的内容都消失了，所以最后没有实现元素的交换，选B
10、A
程序分析题
函数sum()实现的功能是移位，即将数组a的后一个元素的值赋值给前一个元素所以选A
11、B
求最值问题
if(*p>*s)通过指针来传递数据，A.错误，p>s比较的是两个指针地址的大小，所以选B
12、A
程序分析题
函数f(a,3,7)的功能是：x=a[3]+a[5]=3+5=8，所以选A
13、C
排序题
注意函数sort(&aa[3],5)参数表中是从aa[3]开始的5个元素的排列，即aa[3]~aa[7]中元素的从大到小的排列，故选C
14、C
排序题
偶数项按从大到小的顺序排列，关键注意：i=i+2和j=j+2，实际排列的数组成元是:aa[0],aa[2],aa[4],aa[6],aa[8]，故选C
15、D
元素交换题
while()循环实现的是将数组a[8]中的成员逆序重放，故选D
16、A
程序分析题
函数reverse()实现的是逆序重置，执行reverse(b,8)的结果是将b[0]与b[7]、b[1]与b[6]的值交换，故求和的结果s=b[6]+b[7]+b[8]+b[9]=2+1+9+10=22，选A
17、D
程序分析题
函数执行的结果是：s=b[0][0]+b[1][1]+b[2][2]+b[0][3]=1+2+9+4=16,故选D
18、A
解析：程序的主函数中定义了一个指针数组ss，其中包含5个字符串，其中每个元素，都是指向一个字符串首地址的指针。然后调函数fun，将数组的首地址传递给指针数组s，在函数fun中，对数组s中元素按照字符串长度由小到大的顺序排序，所以ss[0]指向长度最小的字符串，即输出xy，ss[4]中指向长度最大的字符串，即输出aaaacc。
19、C
解析：主函数中定义了一个指针变量s，指向一个字符串，调用fun函数，将指针变量s传递给形参指针变量a，将数组t的首地址传递给形参指针变量b，在fun函数中，第一个while语句中判断，如果a所指的字符是*，就将指针后移，真到遇到一个非*的字符，就从该字符开始将后面的字符都逐一的放到指针b所指的数组t中。所以输出t中的字符串即为：a*b****。
20、A
解析：主函数中定义了一个指针数组，其中的每个元素都是一个指向字符串首地址的指针，调用函数fun，将指针数组a的首地址传递给形参，一个指向指针的指针，所以p指向指针数组的首地址，也就是指向s[0]元素，通过++p将指针后移，使指针指向s[1]元素，输出内容是：Afternoon。
21、C
解析：p是一个指针数组，其中的每一个元素都是一个指向整型变量的指针，而数组a中的每一个元素是一个整型变量，所以p[0]=&a[1][2]是正确的，所以选择C。
二 填空题
1、18
解析：函数f的功能是利用递归的方法求aa[2]+aa[3]+aa[4]+aa[5]的和，结果为18。
2、11
解析：函数fun利用递归调用，通过9次调后，当n为1时，返回t[0]的值到调用处赋给变量m，最后输出值为11。
3、 2 2 4 6 8
解析：程序中定义了一个整型数组x，其中x[1]中的初值是2。for循环一共执行4次：i=0时p[0]=&x[1]，此时输出p[0][0]即x[1]为2;当i=1时p[1]=&x[3]，此时输出p[1][0]即x[3]的值为4；当i=2时，p[2]=&x[5]，此时输出p[2][0]即x[5]为6;当i=3时，p[3]=&x[7]，此时输出p[3][0]即x[7]的值为8，所以输出的结果为2468。
4、4
解析：首先定义一个整型数组a，然后让整型指针变量p指向数组a和首地址，也就是p指向数组中第一个元素a[0]，然后p++，使指针后移，指向数组中第2个元素a[1]，输出*p，即输出a[1]中的值4。
5、 br[i]
解析：在主函数中调用了fun函数求每行中的最大值，然后通过for循环控制输出数组b中的每一个元素，由此可知数组b是用来存放数组a中每行的最大值的，而在调用fun函数时，我们将数组b的首地址对应传给了指针变量br，所以空白处，应该将第i行找到的最大值x赋值给br[i]，所以空白处写br[i]。
6、a[k][i] *sum x, &s
解析：sumColumMin的功能是求每列元素中的最小值并计算它们的值，分析可知s是用来求每列元素最小值的和的，而每列元素最小值的行下标是用k来标记的，所以第一个空白处填写a[k][i]；第二个空很明显是用来返回所求得的和的，指针sum就是用来返回值的，所以第二个空填*sum，对应的在主函数中调sumColumMin函数时，传递的参数，应该与函数定义时相对应，应该将数组x的名字传递给数组a，将s的地址传递给指针sum，所以第三个空填x,&s。
7、j<i a[i][j]=a[j][i]
解析：对比两个已给的矩阵会发现，转置的规律是以对角线的方式进行交换的，a[0][0]与a[0][0]进行交换，a[0][1]与a[1][0]进行交换，a[0][2]与a[2][0]进行交换…由此可推出a[i][j]与a[j][i]进行交换。由于以对角线交换，所以列下标j小于行下标i，因此第一个空填j<i；第二个空实现a[i][j]和a[j][i] 交换，所以填a[i][j]= a[j][i]。
8、 x[i][i] x[i-1][j-1]+x[i-1][j]
解析：第0列元素和主对角线的元素都为1，所以可知x[i][0]=1，主对线的元素行下标和列下标相同，所以x[i][i]=0，因此可知第一个空填x[i][i]；其他元素x[i][j]是其左上方x[i-1][j-1]和正上方x[i-1][j]元素之和，所以第二个空填x[i-1][j-1]+ x[i-1][j]。
9、 max<a[row][col] min>max
解析：函数fun的第一个for循环用来控制行，第二个for循环用来控制列，row是行号，col是列号，max存放各行中最大数，min存放各行最大数中的最小数；max=a[row][0]是让max初始时放每行中第一个元素，接着让该行的其他元素逐个与max进行比较，当发现有大于max的元素，就将该元素的值赋给max，所以第一个空填max<a[row][col]；第一次循环（也就是row为0时）让min中放第一行的最大数，以后的每一行，都用找出的该行最大数与min进行比较，如果有比min小的，则将该行比较小的最大数放在min中，所以知二个空填min>max。
10、row a[row][colum]
解析：在主函数中将数组a传递给形参数组a，然后将变量n的地址传递给形参指针n。然后通过循环找出数组中最大值的行下标row以及列下标colum。通过指针n将最大值的行下标传回主函数，所以第一个空填row；同时也要求将找出的最大值返回到主函数，所以第二个空填a[row][colum]。
11、j+1 i%2==1
解析：使用的是冒泡排序的方法。I控制行，j和k控制列。本题的关键在于语句：
If((i%2)?a[i][j]<a[i][k]:a[i][k]>a[i][k])。表达式(i%2==1)的真假控制行数的奇偶，如果是奇数行if判断a[i][j]>a[i][k]为真就执行换位，实现从小到大排序。如果是偶数行if判断a[i][j]<a[i][k]为真就执行换位，实现从大到小排序。
posted on 2009-12-26 20:28
asiawang 阅读(560)
评论(0) 编辑 收藏