第2章 算法——程序的灵魂
1以下叙述中正确的是（ ）。
A．在C语言程序中，main函数必须放在其他函数的最前面
B．每个后缀为.c的C语言源程序都可以单独进行编译
C．在C语言程序中，只有main函数才可以单独进行编译
D．每个后缀为.c的C语言源程序都应该包含一个main函数
【答案】B
【解析】main函数可以在程序的任何位置。每一个可执行的C程序都必须有一个且只能有一个主函数。后缀名为.c的C语言源程序都可以单独进行编译。main函数只是让执行程序的系统知道该从哪里开始执行程序（从主函数处执行），其他有关这个程序的子函数是通过函数调用来实现其功能（不需main函数）。答案选择B选项。
2以下叙述中错误的是（ ）。
A．C语言编写的函数源程序，其文件名后缀可以是.c
B．C语言编写的函数都可以作为一个独立的源程序文件
C．C语言编写的每个函数都可以进行独立的编译并执行
D．一个C语言程序只能有一个主函数
【答案】C
【解析】C源程序经过C编译程序编译之后生成一个后缀为.obj的二进制文件（称为目标文件），然后由称为“连接程序”（Link）的软件，把此.obj文件与C语言提供的各种库函数连接起来生成一个后缀为.EXE的可执行文件。只有含有main函数的经过编译链接才能执行。答案选择C选项。
3以下叙述中错误的是（ ）。
A．一个C程序可以包含多个不同名的函数
B．一个C程序只能有一个主函数
C．C程序在书写时，有严格的缩进要求，否则不能编译通过
D．C程序的主函数必须用main作为函数名
【答案】C
【解析】一个C程序有且只有一个主函数main。一个C程序可以包含多个不同名字的子函数。C程序在书写时没有严格的缩进要求。答案选择C选项。
4以下叙述中正确的是（ ）。
A．C语言规定必须用main作为主函数名，程序将从此开始执行
B．可以在程序中由用户指定任意一个函数作为主函数，程序将从此开始执行
C．C语言程序将从源程序中第一个函数开始执行
D．main的各种大小写拼写形式都可以作为主函数名，如：MAIN，Main等
【答案】A
【解析】用户不能指定某函数为主函数，C语言规定，程序从main函数开始执行，从main函数退出，C语言函数名区别大小写。答案选择A选项。
5下列叙述中错误的是（ ）。
A．C程序可以由一个或多个函数组成
B．C程序可以由多个程序文件组成
C．一个C语言程序只能实现一种算法
D．一个C函数可以单独作为一个C程序文件存在
【答案】C
【解析】一个C程序可以有一个或多个程序文件，也可以有一个或多个函数，所以一个C语言程序可以实现多种算法，答案选择C选项。
6下列叙述中错误的是（ ）。
A．C程序在运行过程中所有的计算都以二进制方式进行
B．C程序在运行过程中所有的计算都以十进制方式进行
C．所有的C程序都需要在连接无误后才能运行
D．C程序中整型变量只能存放整数，实型变量只能存放浮点数
【答案】B
【解析】在C程序运行过程中，编译器的作用是将程序转换为目标代码，目标代码都是二进制的。答案选择B选项。
7以下叙述正确的是（ ）。
A．C语言程序是由过程和函数组成的
B．C语言函数可以嵌套调用，例如：fun(fun(x))
C．C语言函数不可以单独编译
D．C语言中除了main函数，其他函数不可作为单独文件形式存在
【答案】B
【解析】一个函数的返回值可以作为参数然后传给另一个函数，因此函数是可以嵌套调用的。A项错误，C语言程序只有函数构成，没有过程；C项错误，编译系统的任务在于检查语法错误，只要符合语法规则的C程序都可以通过编译，就算是单独的函数也可以；D项错误，在C语言中除main()函数以外的其他函数可以和main()函数在同一个C文件中，也可以单独处于其他的C文件，只要在使用到这些函数的main()函数的C文件中用预编译指令“#include”包含进来即可。答案选择B选项。
8对于一个正常运行的C程序，以下叙述中正确的是（ ）。
A．程序的执行总是从程序的第一个函数开始，在main函数结束
B．程序的执行总是从main函数开始
C．程序的执行总是从main函数开始，在程序的最后一个函数中结束
D．程序的执行总是从程序的第一个函数开始，在程序的最后一个函数中结束
【答案】B
【解析】一个正常运行的C程序总是从main函数开始执行，最后返回到main函数结束。答案选择B选项。
9下列叙述中正确的是（ ）。
A．每个C程序文件中都必须要有一个main函数
B．在C程序中main函数的位置是固定的
C．C程序中所有函数之间都可以相互调用
D．在C程序的函数中不能定义另一个函数
【答案】D
【解析】在C程序中，main函数的位置可以任意，而且不管main函数位置怎么变化，程序都会以main函数作为入口，选项B错误；每个C程序（而不是每个C程序文件）必须有且只能有一个main函数，选项A错误；main函数不能被其他函数调用，选项C错误；函数的定义不能放在另一个函数体内，但是声明可以，答案选择D选项。
10以下叙述正确的是（ ）。
A．C程序总是以main()作为程序执行的起始行
B．main()函数若不带参数，其后面的一对圆括号可省略
C．函数体内的定义语句和可执行语句允许任意穿插出现
D．C语言中的语句之间必须用分号作为分隔符
【答案】A
【解析】main函数后面的括号告诉编译器这是一个函数，不可以省略，排除B选项；在复合语句中，不仅可以有执行语句，还可以有定义语句，定义语句应该出现在执行语句的前面，故排除C选项；C语言中的某些语句可以不用分号，例如if语句，宏定义，故D选项错误。答案选择A选项。
11以下关于C语言的叙述中正确的是（ ）。
A．C语言中的注释不可以夹在变量名或关键字的中间
B．C语言中的变量可以在使用之前的任何位置进行定义
C．在C语言算术表达式的书写中，运算符两侧的运算数类型必须一致
D．C语言的数值常量中夹带空格不影响常量值的正确表示
【答案】A
【解析】A项正确，C语言中，程序中的注释可以出现在程序中任何合适的地方，但是，不能写在变量名或关键字的中间，一旦写在其中间，将会失去变量名或关键字的意义，导致报错；B项错误，条件没有说全，应该是在有效的范围内，变量可以在任何位置定义，例如注释中定义无效。C项错误，在C语言的算术运算符中，取余运算符“%”的两个运算分量必须是整数，但对于其他运算符，如“+”，“-”来说，两侧的运算符类型也可以不一样，例如左侧为一个字符类型，右侧为一个整数类型，系统在执行程序时会自动将字符类型转换为ASCII值进行运算；D项错误，C语言的数值表示时各个数位必须紧靠在一起，否则编译系统只会识别紧靠运算符的一部分数值，另一部分数值会发生语法错误。答案选择A选项。
12以下叙述中正确的是（ ）。
A．C程序的基本组成单位是语句
B．C程序中的每一行只能写一条语句
C．简单C语句必须以分号结束
D．C语言必须在一行内写完
【答案】C
【解析】C程序的基本组成单位是函数，A项错误；C程序以分号作为每个语句结尾，一行能写多条语句，也可以将一条语句分几行书写，B、D两项错误；C语言中语句分为简单语句和复合语句。简单语句以分号作为结束。其中简单语句里面又有赋值语句、声明语句、结构化语句、函数调用语句和空语句。复合语句指用花括号{}将简单语句甚至另一些复合包起来，所以就以}作为语句结束的标记。答案选择C选项。
13以下选项中叙述正确的是（ ）。
A．函数体必须由{开始
B．C程序必须由main语句开始
C．C程序中的注释可以嵌套
D．C程序中的注释必须在一行完成
【答案】A
【解析】函数体是函数首部下面的花括号内的部分，所以函数体必须由{开始，A选项正确。一个源程序文件可以包括预处理命令、全局声明、函数定义，程序总是从main函数开始执行的，不是main语句，B选项错误。函数可以嵌套，注释不能嵌套，C选项错误。C程序中允许两种注释，以//开头的单行注释；以/*开始，以*/结束的块式注释，D选项错误。答案选择A选项。
14以下叙述中正确的是（ ）。
A．C程序中的注释只能出现在程序的开始位置和语句的后面
B．C程序书写格式严格，要求一行内只能写一个语句
C．C程序书写格式自由，一个语句可以写在多行上
D．用C语言编写的程序只能放在一个程序文件中
【答案】C
【解析】C程序的注释可以出现在C程序的任何位置，注释符号：“//”或“/*…*/”，选项A错误。C程序中，一行内可写多个语句，每条语句用分号“;”结束，选项B错误，选项C正确。用C语言编写的程序可以放在多个程序文件中，用#include命令行实现文件包含功能，选项D错误。答案选择C选项。
15以下叙述中错误的是（ ）。
A．书写风格良好的程序执行效率高
B．书写风格良好的程序易读性好
C．C程序可以在一行上写多条语句
D．C程序允许将一条语句分写在多行上
【答案】A
【解析】书写风格与程序执行效率无关，程序执行效率与程序的数据结构有关，由算法的时间复杂度和空间复杂度决定，但书写风格会深刻地影响软件的质量和可维护性，良好的程序设计风格可以使程序结构清晰合理。良好的书写习惯一般一行写一条语句，这样方便阅读，但是一行写多条语句或者将一条语句分写在多行上是符合C程序编写规则的。答案选择A选项。
19以下四个程序中，完全正确的是（ ）。
A．
#include <stdio.h>
main()
{
/*/programming/*/
printf("programming!\n");
}
B．
#include <stdio.h>
main()
{
/*programming*/
printf("programming!\n");
}
C．
#include <stdio.h>
main()
{
/*/*programming*/*/
printf("programming!\n");
}
D．
include <stdio.h>
main()
{
/*programming*/
printf("programming!\n");
}
【答案】B
【解析】A项中，“main()”函数后面不能加分号；C语言中注释语句的注释方法是：/*注释内容*/或//注释一行，且“/*”和“*/”不能嵌套使用，C项错误；D选项中预编译命令“include <stdio.h>”前缺少“#”号。答案选择B选项。
17有以下程序
#include <stdio.h>
main()
{
int a=0,b=0;
/*给a赋值a=10;
b=20;给b赋值*/
printf("a+b=%d\n",a+b);/*输出计算结果*/
}
程序运行后的输出结果是（ ）。
A．a+b=0
B．a+b=30
C．a+b=10
D．出错
【答案】A
【解析】注释/*和*/之间的代码不参与编译，所以a、b的值仍为0。答案选择A选项。
18关于C语言的变量名，以下叙述正确的是（ ）。
A．变量名不可以与关键字同名
B．变量名不可以与预定义标识符同名
C．变量名必须以字母开头
D．变量名是没有长度限制的
【答案】A
【解析】合法的标识符由字母（大、小写均可）、数字和下划线组成，并且必须以字母或下划线开头。关键字是指被C语言保留的，不能用作其他用途的标识符，它们在程序中都代表着固定的含义，用户不可重新定义，A项正确、BC两项错误。变量名没有长度限制，但不可超过编译器可以辨识的范围，D项错误。答案选择A选项。
19以下选项中叙述正确的是（ ）。
A．C语言的标识符可分为关键字、预定义标识符和用户标识符三类
B．C语言的标识符可分为语句、变量和关键字三类
C．C语言的标识符可分为函数名、变量和预定义标识符三类
D．C语言的标识符可分为运算符、用户标识符和关键字三类
【答案】A
【解析】C语言的标识符可分为关键字、预定义标识符和用户标识符三类，答案选择A选项。
20C语言中的标识符分为关键字、预定义标识符和用户标识符，以下叙述中正确的是（ ）。
A．预定义标识符（如库函数中的函数名）可用作用户标识符，但失去原有含义
B．用户标识符可以由字母和数字任意顺序组成
C．在标识符中大写字母和小写字母被认为是相同的字符
D．关键字可用作用户标识符，但失去原有含义
【答案】A
【解析】C语言允许把预定义标识符重新定义另作他用，但这将失去预先定义的原意。B项，标识符的第一个字符必须为字母或下划线；C项，标识符区分大小写；D项，关键字是指被C语言保留的，不能用作其他用途的标识符。答案选择A选项。
21关于C语言标识符，以下叙述错误的是（ ）。
A．标识符可全部由数字组成
B．标识符可全部由下划线组成
C．标识符可全部由小写字母组成
D．标识符可全部由大写字母组成
【答案】A
【解析】C语言标识符只能由字母、数字、下划线构成，且只能以字母、下划线开头，故答案选择A选项。
22按照C语言规定的用户标识符命名规则，不能出现在标识符中的是（ ）。
A．大写字母
B．连接符
C．数字字符
D．下划线
【答案】B
【解析】C语言中标识符只能由下划线、字母和数字组成，且不能以数字开头。答案选择B选项。
23以下C语言用户标示符中，不合法的是（ ）。
A．_1
B．AaBc
C．a_b
D．a--b
【答案】D
【解析】C语言中的标识符只能由字母、数字和下画线构成，且第一个字符必须是字母或下画线，同时不能与C语言中的关键字相同。D项还有非法字符“-”。答案选择D选项。
24以下选项中，能用作用户标识符的（ ）。
A．void
B．8_8
C．_0_
D．unsigned
【答案】C
【解析】标识符是由若干个字符组成的字符序列，用来命名程序的一些实体。C语言定义标识符应遵循以下六种规则：①标识符由字母、数字或下划线组成；②第一个字符必须是字母或下划线；③标识符最多由274个字符组成；④在标识符中严格区分大小写字母；⑥关键字不能作为自定义的标识符在程序中使用。A、D项皆为C语言的关键字，B项第一个字符为数字，错误。答案选择C选项。
25以下选项中可用作c语言中合法用户标识符的是（ ）。
A．_123
B．void
C．-abc
D．2a
【答案】A
【解析】合法标识符的命名规则是：标识符可以由字母、数字和下划线组成，并且第一个字符必须为字母或下划线，其中，关键字在程序中都代表着固定的含义，不能另作他用。B项中void是关键字，不合法。C项和D项没有以字母或下划线开头，不合法。答案选择A选项。
26以下选项中合法的标识符是（ ）。
A．1_1
B．1-1
C．_11
D．1_ _
【答案】C
【解析】C语言的标识符命名规则为：①只能由字母、数字和下划线3种字符组成；②标识符首位必须是字母或下划线；③不能与C语言中的关键字或保留字相同。AD两项，标识符首位不能为数字；B项，标识符首位不能为数字且“-”为不合法的字符。答案选择C选项。
27以下选项中不合法的标识符是（ ）。
A．print
B．FOR
C．&a
D．_00
【答案】C
【解析】标识符是由若干个字符组成的字符序列，用来命名程序的一些实体。语法规则为：①标识符由字母、数字或下划线组成；②第一个字符必须是字母或下划线；③标识符最多由274个字符组成；④在标识符中严格区分大小写字母；⑤关键字不能作为自定义的标识符在程序中使用。C中有非法字符&。答案选择C选项。
28下列定义变量的语句中错误的是（ ）。
A．double int_;
B．float US$;
C．char For;
D．int _int;
【答案】B
【解析】标识符由字母、数字、下划线组成。$是非法字符，不能出现在标识符中。答案选择B选项。
29以下叙述中错误的是（ ）。
A．非零的数值型常量有正值和负值的区分
B．常量是在程序运行过程中值不能被改变的量
C．定义符号常量必须用类型名来设定常量的类型
D．用符号名表示的常量叫符号常量
【答案】C
【解析】在C语言程序中，可以用一个符号名来代表一个常量，称为符号常量，符号常量在定义是不需要类型，其本身就能表达其类型。答案选择C选项。
30以下选项中关于C语言常量的叙述错误的是（ ）。
A．所谓常量，是指在程序运行过程中，其值不能被改变的量
B．常量分为整型常量、实型常量、字符常量和字符串常量
C．常量可分为数值型和非数值型常量
D．经常被使用的变量可以定义为常量
【答案】D
【解析】常量是指在程序运行过程中其值不能被改变的量。在C语言中，有整型常量、实型常量、字符常量和字符串常量等类型。整型常量和实型常量又称数值型常量，它们有正值和负值的区分。所谓变量是指在程序运行过程中其值可以改变的量。C语言规定，程序中所有变量都必须先定义后使用。变量和常量有明显的区分。D项，常量指在程序运行过程中，其值不能被改变的量，而变量是指在程序运行过程中，其值能被改变的量，因此变量不可以定义成常量。答案选择D选项。
31以下选项中不能用作C程序合法常量的是（ ）。
A．1,234
B．"\123"
C．123
D．"\x7D"
【答案】A
【解析】常量分为数值常量和字符串常量，A项错误。BD两项为字符常量；C项为数值常量。答案选择A选项。
32以下选项中能表示合法常量的是（ ）。
A．整数：1,200
B．实数：1.5E2.0
C．字符斜杠：'\'
D．字符串："\007"
【答案】D
【解析】A项错误，表达错误；B项错误，E后面应为整数，不能是小数；C项错误；字符斜杠的表示方法为'\\'，因为第一个\表示是转义字符；D项正确，表示空字符串，第一个字符为"\0"，正确。答案选择D选项。
33以下选项中不能作为C语言合法常量的是（ ）。
A．'cd'
B．0.1e+6
C．"a"
D．'\011'
【答案】A
【解析】常量包括整型常量、实型常量、字符常量和字符串常量等。单引号表示字符常量，但不能包含字符串。表达字符串常量时需用双引号。A项，在C语言中，字符常量是用单引号括起来的一个字符，'cd'包含了2个字符；B项，0.1e+6是实型常量的指数形式，代表0.1×106；C项，"\a"是合法的字符串常量，\a是一个非打印的转义字符表示响铃；D项，'\011'是一个字符常量，\011是一个用3位八进制表示的转移字符。答案选择A选项。
34以下选项中，合法的C语言常量是（ ）。
A．1.234
B．'C++'
C．"\2.0
D．2Kb
【答案】A
【解析】C语言中的常量：①整型常量，用不带小数点的数字表示；②实型常量，用带小数点的数字表示；③字符型常量，用带有单引号的一个字符表示；④字符串常量，用一对双引号括起来的一串字符。1.234为实型常量，A项正确；'C++'不合法，若改成"C++"则为字符串常量，B项错误；"\2.0不合法，不是任何类型常量，C项错误；2Kb不合法，若加上双引号"2Kb"为字符串常量，D项错误。答案选择A选项。
35以下选项中，能用作数据常量的是（ ）。
A．115L
B．0118
C．1-5e1.5
D．o115
【答案】A
【解析】C语言中实型常量有两种表示：小数形式和指数形式。在指数形式中，字母e（或E）之前必须要有数字，且e或E后面的指数必须为整数，故C项错误；八进制整数常量以数字0开始，而不是o，故D项错误。在八进制数中的有效数字为0～7，故B项错误；L是长整型数据标识，115L为长整型常数即long int，A项正确。答案选择A选项。
36以下选项中，合法的数值型常量是（ ）。
A．3.2
B．'X'
C．099
D．0xEH
【答案】A
【解析】A项正确，3.2是合法的实型常量；B项错误，'X'为字符型常量不是数值型常量；C项错误，以0开头，表示八进制，但八进制的每位由0～7中的一个组成；D项错误，0x和H冲突，都是表示十六进制。答案选择A选项。
37以下选项中，合法的一组C语言数值常量是（ ）。
A．12. 0Xa23 4.5e0
B．028 .5e-3 -0xf
C．.177 4e1.5 0abc
D．0x8A 10,000 3.e5
【答案】A
【解析】A项，C语言中小数必须要有小数点，但是小数部分可以省略，12.是合法的常量；C语言中十六进制数以0X或0x开头，0Xa23是指十六进制数a23；在C语言中，“e”或“E”后跟一个整数来表示以10为底的幂数，4.5e0表示4.5*100。B项，028表示的是八进制，以0开头，0后面的数字只能在0～7之间。C项，4e1.5，e后面只能跟整数，0abc表示八进制，0后面的数字只能在0～7之间；D项，10,000中不能有逗号。答案选择A选项。
38以下选项中正确的定义语句是（ ）。
A．double a;b;
B．double a=b=7;
C．double a=7,b=7;
D．double,a,b;
【答案】C
【解析】同一类型变量的定义时，不同变量之间需要用“,”分隔，选项A错误；定义变量时初始化赋值不能用等号连接，选项B错误；变量类型说明后面不能用逗号，而是用空格分离，选项D错误。答案选择C选项。
39以下定义语句中正确的是（ ）。
A．int a=b=0;
B．char A=65+1,b='b';
C．float a=1,*b=&a,*c=&b;
D．double a=0.0;b=1.1;
【答案】B
【解析】A项错误，变量定义的时候不能用连续用等号，等号在定义是初始化的一种；C项错误，b是指针变量，*c=&b表示将一个二级指针赋值给一个一级指针，应该为*c=b或者**c=&b；D项，变量前为分号“;”表示前面的语句定义完毕，变量b的定义没有指明变量类型。答案选择B选项。
40以下关于C语言数据类型使用的叙述中错误的是（ ）。
A．若只处理“真”和“假”两种逻辑值，应使用逻辑类型
B．若要保存带有多位小数的数据，可使用双精度类型
C．若要处理如“人员信息”等含有不同类型的相关数据，应自定义结构体类型
D．整数类型表示的自然数是准确无误差的
【答案】A
【解析】A项错误，C语言中没有逻辑类型，在C++中才引入的；B项正确，float类型称为单精度类型，double类型称为双精度类型，一般系统中，为float类型的变量分配4个字节的存储单元，为double类型的变量分配8个字节的存储单元。C项正确，struct结构体，可以用来描述包含多种基本类型的复杂对象。D项正确，整数的表示是不存在误差的。答案选择A选项。
41设有两行定义语句：
int scanf;
float case;
则以下叙述正确的是（ ）。
A．两行定义语句都不合法
B．两行定义语句都合法
C．第1行语句不合法
D．第2行语句不合法
【答案】D
【解析】预定义标识符是系统已经有过定义的标识符，用户可以重新定义，可以作为变量名。scanf为库函数名，属于预定义标识符，可以被用户重定义，第一行语句合法。C语言关键字是被保留的，不能用作其他用途的一些标识符，它们在程序中都代表着固定的含义，用户不可重新定义。case是选择结构switch语句中的关键字，不可被用户重定义，第二行语句不合法。答案选择D选项。
42阅读以下程序：
#include <stdio.h>
main()
{
int case;
float printF;
printf("请输入2个数:");
scanf("%d %f",&case,&printF);
printf("%d %f\n",case,printF);
}
该程序编译时产生错误，其出错原因是（ ）。
A．定义语句出错，case是关键字，不能用作用户自定义标识符
B．定义语句出错，printF不能用作用户自定义标识符
C．定义语句无错，scanf不能作为输入函数使用
D．定义语句无错，printf不能输出case的值
【答案】A
【解析】在C语言中，关键字又称保留字，它是系统预先定义的，具有特定含义的标识符，故不允许用户重新定义。case为C语言中的关键字，因此用户不能再定义标识符为case的变量。答案选择A选项。
43C语言中，最基本的数据类型包括（ ）。
A．整型、实型、逻辑型
B．整型、字符型、数组
C．整型、实型、字符型
D．整型、实型、结构体
【答案】C
【解析】C语言中，最基本的数据类型包括整型、实型、字符型，答案选择C选项。
44C语言整数不包括（ ）。
A．带小数点的整数
B．正整数
C．负整数
D．无符号整数
【答案】A
【解析】C语言整数包括正整数，负整数，无符号整数，不含带小数点的整数。答案选择A选项。
45C源程序中不能表示的数制是（ ）。
A．二进制
B．八进制
C．十进制
D．十六进制
【答案】A
【解析】C语言中整型常量可以用十进制、八进制数、十六进制数来表示。虽然计算机只能识别二进制数，但二进制不能用源程序表示。答案选择A选项。
46有以下程序：
#include<stdio.h>
main()
{
int x=011;
printf("%d\n",++x);
}
程序运行后的输出结果是（ ）。
A．12
B．11
C．10
D．9
【答案】C
【解析】x=011表示按照八进制赋值，则十进制数为9，所以输出++x的结果为10。答案选择C选项。
47有以下程序，其中k的初值为八进制数
#include<stdio.h>
main()
{
int k=011;
printf("%d\n",k++);
}
程序运行后的输出结果是（ ）。
A．12
B．11
C．10
D．9
【答案】D
【解析】整型变量k的值“011”是用八进制表示的，即十进制的“9”，而输出格式为%d，即十进制格式，所以输出为“9”，然后k自增1。答案选择D选项。
48有如下程序：
#include<stdio.h>
main()
{
int x=072;
printf("%d\n",x+1);
}
程序运行后的输出结果是（ ）。
A．59
B．73
C．115
D．72
【答案】A
【解析】整型常量有3种，①十进制整常量，没有前缀，输出格式控制符为%d；②八进制整常量，以0作为前缀，输出格式控制符为%o；③十六进制整常量，以0X或0x作为前缀，输出格式控制符为%x。八进制数072表示成十进制数为58，即x=072=58，以十进制格式输出x+1=59，答案选择A选项。
49有如下程序：
#include<stdio.h>
main()
{
int x=0x13;
printf("%d\n",x+1);
}
程序运行后的输出结果是（ ）。
A．12
B．14
C．20
D．13
【答案】C
【解析】整型常量中，十进制整常量没有前缀，输出格式控制符为%d；八进制整常量以0作为前缀，输出格式控制符为%o；十六进制整常量以0X或0x作为前缀，输出格式控制符为%x。十六进制数0x13表示成十进制数为19，以十进制格式输出x+1=19+1=20，答案选择C选项。
50有以下程序：
#include<stdio.h>
main()
{
int x=0x13;
printf("INT:%d\n",x+1);
}
程序运行后的输出结果是（ ）。
A．INT:14
B．INT:13
C．INT:12
D．INT:20
【答案】D
【解析】0x13是十六进制数，%d需要输出十进制数，换算成十进制：16×1+160×3=16+3=19，输出INT=x+1=20，因此答案选择D选项。
51若函数中有定义语句：
int k;
则（ ）。
A．系统将自动给k赋初值0
B．这时k中的值无定义
C．系统将自动给k赋初值-1
D．这时k中无任何值
【答案】B
【解析】int k;这条语句是定义一个整型变量k，这是动态定义，编译程序仅为k开辟存储单元，而没有在存储单元中存放任何初值，此时变量中的值时无意义的。若是静态定义，则会自动初始化，其默认值为0。答案选择B选项。
52有以下程序
#include<stdio.h>
main()
{
int s,t,A=10;
double B=6;
s=sizeof(A);
t=sizeof(B);
printf("%d,%d\n",s,t);
}
在VC++2010平台上编译运行，程序运行后的输出结果是（ ）。
A．2,4
B．4,4
C．4,8
D．10,6
【答案】C
【解析】sizeof的作用就是返回一个对象或者类型所占的内存字节数。在VC++2010中整型占4个字节，双精度实型占8个字节。答案选择C选项。
53关于C语言中数的表示，以下叙述中正确的是（ ）。
A．只有整型数在允许范围内能精确无误地表示，实型数会有误差
B．只要在允许范围内整型和实型都能精确表示
C．只有实型数在允许范围内能精确无误地表示，整型数会有误差
D．只有八进制表示的数才不会有误差
【答案】A
【解析】实型数据在内存中存储的二进制位数是有限的，而一个十进制实数转化为二进制实数时，其有效数字位数有可能会超过尾数的存储长度，从而导致有效数字丢失而产生误差。在整型数允许范围之内，二进制可以表示任意一个整数。答案选择A选项。
54下列形式中不合法的常量是（ ）。
A．2.E8
B．-.28
C．-028
D．2e-8
【答案】C
【解析】-028表示的是八进制的整型常量，但八进制的数字只能用0～7表示。AD两项为指数形式的实数表示，在e或E的前面必须要有数字，且e或E后面的指数必须为整数；B项，为整数常量。答案选择C选项。
55以下选项中表示一个合法的常量是（说明：符号u表示空格）（ ）。
A．9u9u9
B．0Xab
C．123E0.2
D．2.7e
【答案】B
【解析】十六进制数用0x或0X开头。0Xab是指十六进制数，是合法的常量，B项正确。A项多位数字之间不能用空格间隔，A项错误；当用指数形式表示浮点数据时，E的前后都要有数据，并且E的后面数要为整数，C、D错误。答案选择B选项。
56以下选项中可用作C程序合法实数的是（ ）。
A．.1e0
B．3.0e0.2
C．E9
D．9.12E
【答案】A
【解析】C程序的合法实数有小数和指数两种表示形式。其中，对于用指数形式表示的实数来说，字母e或E之前必须要有数字，且字母e或E后面的指数必须为整数。B项，e后的指数不能为小数形式；C项，E前必须要有数字；D项，E后缺少整数形式的指数。答案选择A选项。
57以下选项中，能用作数据常量的是（ ）。
A．o115
B．0118
C．1-5e1.5
D．115L
【答案】D
【解析】C语言中实型常量有两种表示：小数形式和指数形式。在指数形式中，字母e（或E）之前必须要有数字，且e或E后面的指数必须为整数，故C项错误；八进制整数常量以数字0开始，而不是o，故A项错误。在八进制数中的有效数字为0～7，故B项错误；L是长整型数据标识，115L为长整型常数即long int，D项正确。答案选择D选项。
58以下选项中，合法的C语言实数是（ ）。
A．3.1e0.4
B．.2e0
C．E13
D．7.12E
【答案】B
【解析】实型常量指数形式由十进制数加阶码标志“e”或“E”以及阶码（只能为整数，可以带符号）组成。.2e0为指数形式实数，B项正确。3.1e0.4，阶数不是整数，A项错误。E13阶码标志前缺少十进制数，C项错误。7.12E缺少阶码，D项错误。答案选择B选项。
59以下不合法的数值常量是（ ）。
A．8.0E0.5
B．1e1
C．011
D．0xabcd
【答案】A
【解析】实型常量指数形式中，字母e（或E）前后必须都要有数字，且e（或E）后面的指数必须为整数。答案选择A选项。
60以下选项中，合法的数值型常量是（ ）。
A．3.1415
B．"A"
C．092
D．0xDH
【答案】A
【解析】数值型常量包括整型常量和实型常量。整型常量有三种：①十进制常量，用0～9表示，不能以0开头；②八进制常量，用0～7表示，必须用0开头；③十六进制常量，用0～9和A～F（a～f）表示，必须以0x或0X开头。实型常量：用带小数点的数字表示，其值有两种表达形式，分别为十进制小数形式和指数形式。3.1415为实型常量，A项正确。"A"为长度为1的字符串常量，B项错误。092按照格式来说是八进制整型常量，但是八进制不会出现9，C项错误。0xDH按照格式说是十六进制整型常量，但是不应该出现H，D项错误。答案选择A选项。
61在C语言中，以下选项中不能正确表示10×1000之值的是（ ）。
A．1.0E4.0
B．1.E4
C．10E3
D．1.0e4
【答案】A
【解析】实型常量用带小数点的数字表示，其值有两种表达形式，分别为十进制小数形式和指数形式。指数形式由十进制数加阶码标志“e”或“E”以及阶码（只能为整数，可以带符号）组成，而A项中阶码4.0是浮点数，所以A项不能正确表示10×1000之值，B、C、D项都表示正确并且值为10000，答案选择A选项。
62若有定义语句：
int a=10;double b=3.14;
则表达式'A'+a+b值的类型是（ ）。
A．char
B．int
C．double
D．float
【答案】C
【解析】在多目运算符相关联的运算数中，如果类型不一致，系统将自动进行类型转换，使两边的类型达到一致后，再进行运算，转换的规则是由“低到高”。'A'是字符型，a是整型，b是double型。字符型数据占1个字节，整型占2个字节，doub1e型占8个字节，故三者相加后为double型，答案选择C选项。
63若有定义：
int a=1,b=2,c=3;
则执行表达式(a=b+c)||(++b)后，a、b、c的值依次为（ ）。
A．1,2,3
B．5,3,2
C．5,2,3
D．5,3,3
【答案】C
【解析】||表示或运算，当第一个表达式为真时，第二个表达式不执行。根据运算符的优先级规则，先计算(a=b+c)，将b+c的值赋值给a，则a=5，而||右边的括号不会被执行，所以b=2，c=3。答案选择C选项。
64C语言程序中，运算对象必须是整型数的运算符是（ ）。
A．&&
B．/
C．%
D．*
【答案】C
【解析】模运算中不能出现浮点数，运算对象只能是整数。答案选择C选项。
65以下不能用于实型数据的运算符是（ ）。
A．%
B．/
C．*
D．+
【答案】A
【解析】“%”符号两边必须是整数，答案选择A选项。
66设x，y，z均为实型变量，代数式
在C语言中的正确写法是（ ）。
A．x/y*z
B．x%y%z
C．x/y/z
D．x*z/y
【答案】C
【解析】%是取余运算符，不符合。运算符*、/的结合顺序是从左到右，所以x先除以y，再除以z。答案选择C选项。
67以下不能正确表示代数式
的C语言表达式是（ ）。
A．2*a*b/c/d
B．a*b/c/d*2
C．a/c/d*b*2
D．2*a*b/c*d
【答案】D
【解析】*与/优先级相同，采用左结合的方式。D项若改为：2*a*b/(c*d)则为正确。答案选择D选项。
68若在程序中变量均已定义成int类型，且已赋大于1的值，则下列选项中能正确表示代数式1/abc的表达式是（ ）。
A．1.0/a/b/c
B．1/(a*b*c)
C．1.0/a*b*c
D．1/a/b/(double)c
【答案】A
【解析】abc均大于1，所以表达式1/abc小于1，需要用浮点类型表示。若要计算表达式值，需要使其自动转化成浮点类型，A项正确。B项变量与常量均为整型，不会自动转换为浮点类型，B项错误。C项表示表达式bc/a，错误。D项，算数运算法结合性自左向右，先计算1/a，结果为0，之后的计算无论是否转换数据类型结果均为0，D项错误。答案选择A选项。
69设变量x为long int型并已正确赋值，以下表达式中能将x的百位上的数字提取出来的是（ ）。
A．x/10%100
B．x%10/100
C．x%100/10
D．x/100%10
【答案】D
【解析】x/100结果的个位数上的数字是原来x的百位数上的数字，则要得到这个数字只需要再%10即可。答案选择D选项。
70以下可以将任意一个两位整数n的个位数与十位数对换的表达式为（ ）。
A．(n-n/10×10)×10+n/10
B．n-n/10×10+n/10
C．n/10+(n-n/10)
D．(n-n/10)×10+(n/10)
【答案】A
【解析】A项n/10得到十位数字，n-n/10得到个位数字，将个位数乘以10加上十位数字，(n-n/10×10)×10+n/10实现将任意一个两位整数个位数与十位数对换，A项正确。B项n-n/10×10得到个位数字，n/10为十位数字，n-n/10×10+n/10实现两位整数个位数与十位数之和，B项错误。C项n/10+(n-n/10)=n，不能实现题目中要求，C项错误。D项n/10是十位数字，n-n/10为原两位整数减去十位数字，不是个位数字，D项错误。答案选择A选项。
71设有以下程序段：
int y;
y=rand()%30+1;
则变量y的取值范围是（ ）。
A．0≤y≤30
B．0<y≤30
C．1<y<30
D．1<y≤30
【答案】B
【解析】rand函数产生随机整数，任何整数对30求余得到的整数范围为0～29，则y的取值范围为1≤y≤30或者0<y≤30，y是整数，0<y≤30。答案选择B选项。
72若有定义语句：int x=12,y=8,z;，在其后执行语句z=0.9+x/y;，则z的值为（ ）。
A．1.9
B．1
C．2
D．2.4
【答案】B
【解析】由于x，y，z都是整型数据，所以x除以y的值为整型数值1，之后1和0.9相加得到1.9，再转换为整型数1赋给整型变量z。答案选择B选项。
73表达式：(int)((double)9/2)-9%2的值是（ ）。
A．0
B．3
C．4
D．5
【答案】B
【解析】运算符“/”“%”的优先级高于“-”，所以先进行除法和求余运算，再进行减法运算。强制类型转换表达式的形式：（类型名）（表达式）。“9/2”结果为4，转换成double类型再转换成int类型结果依然为4，9%2的结果为1，最后结果为4-1=3。答案选择B选项。
74设有定义：int x=7,y=12;，则以下表达式值为3的是（ ）。
A．(y%=x)-(x%=5)
B．y%=(x%=5)
C．y%=x-x%5
D．y%=(x-x%5)
【答案】A
【解析】A项正确，a%=b表示a=a%(b)，A项可改写成y=y%x，x=x%5，再计算y-x计算的结果为3，满足题意；B项为0，C项为2，D项等同于C项。答案选择A选项。
75表达式3.6-5/2+1.2+5%2的值是（ ）。
A．4.8
B．3.8
C．3.3
D．4.3
【答案】B
【解析】3.6-5/2+1.2+5%2 = 3.6-2+1.2+1=3.8。需要注意的是，两个整数相除仍然得到整数，小数部分被省略，5/2=2。答案选择B选项。
76表达式a+=a-=a=9的值是（ ）。
A．9
B．-9
C．18
D．0
【答案】D
【解析】a+=a-=a=9计算顺序为a+=(a-=(a=9))，首先a=9，a-=9，即a=a-9=9-9=0；最后a+=0，即a=a+0=0+0=0。答案选择D选项。
77以下能正确表述算式sin(2πr+30°)的C语言表达式是（ ）。
A．sin(2*3.14*r+3.14*30/180.0)
B．sin(2*π*r+30)
C．sin(2*3.14*r+30)
D．sin(2*3.14*r+30*3.14/360.0)
【答案】A
【解析】A项正确。sin是库函数，其参数中的角度要求用弧度制表示。C语言中π不是已定义的常量，需要用户自定义或者直接使用3.14代替π。B项未替换π也没有将30度换算成弧度，错误。C项没有将30度换算成弧度，错误。D项弧度换算错误，π对应于180°，应该除以180.0而不是360.0。答案选择A选项。
78有以下定义
int a;
long b;
double x,y;
则以下选项中正确的表达式是（ ）。
A．a%(int)(x-y)
B．a==x!=y
C．(a*y)%b
D．y=x+y=a
【答案】A
【解析】%运算是取两整数相除后余数的运算符，它只适用于整数的运算。A项正确，x-y结果为double型，但是通过强制类型转换将其转换为int型；B项错误，a==x!=y中==和!=是同一个优先级的，先运行a==x，而因为double是占8位的，不能自动转换，必须要强制类型转换，a==(double)x!=y才是正确的；C项错误，(a*y)%b中的(a*y)为double型；D项错误，x+y不能作为左值。答案选择A选项。
79设有定义：
int x=2;
以下表达式中，值不为6的是（ ）。
A．x*=x+1
B．x++,2*x
C．x*=(1+x)
D．2*x,x+=2
【答案】D
【解析】A项，因为赋值运算优先级最低，故先执行x+1，赋值符号右侧为3，然后再计算x*=3，所以x=2*3=6；B项，x++得3然后2*x得6；C项与A项原理一致。D项，2*x虽然结果为4，但没有赋值，此时x的值仍为2，所以最终为4。答案选择D选项。
80若变量x、y已正确定义并赋值，以下符合C语言语法的表达式是（ ）。
A．x+1=y
B．++x,y=x--
C．x=x+10=x+y
D．double(x)/10
【答案】B
【解析】B项正确，++x是前缀表达式，y=x--是复合语句，先进行x--，然后把自减后的值赋给y。A项错误，x+1是右值，不能被赋值；C项错误，x+10是右值，不能被赋值；D项错误，应改成(double)x/10，double (x)/10是表示声明了一个double变量，它名字是(x)/10，显然不符合C语言语法。答案选择B选项。
81已知大写字母A的ASCII码是65，小写字母a的ASCII码是97。以下不能将变量c中的大写字母转换为对应小写字母的语句是（ ）。
A．c=('A'+c)%26-'a'
B．c=c+32
C．c=c-'A'+'a'
D．c=(c-'A')%26+'a'
【答案】A
【解析】A项，模26运算后得到0~25之间的数，再与'a'相减结果是负数；B项，ASCII码表中，同一字母的小写码比大写码数值上大32；C项，'a'-'A'=32；D项，c-'A'取值在0～26，等价于C项。答案选择A选项。
82以下选项中，当x为大于1的奇数时，值为0的表达式是（ ）。
A．x%2==1
B．x/2
C．x%2!=0
D．x%2==0
【答案】D
【解析】当x为大于1的奇数，x%2==1，则表达式x%2==0为假（即值为0），答案选择D选项。
83以下选项中，值为1的表达式是（ ）。
A．'1'-0
B．1-'0'
C．1-'\0'
D．'\0'-'0'
【答案】C
【解析】ASCII码表，'0'～48，'1'～49，'\0'～0，答案选择C选项。
84有以下程序：
#include<stdio.h>
main()
{
int a;
a=(int)1.99*3;
printf("%d\n",a);
}
程序的运行结果是（ ）。
A．3
B．5
C．6
D．结果不确定
【答案】A
【解析】()的优先级大于*，故先将1.99强制转化为1，执行语句a=(int)1.99*3；计算得a=1×3=3。答案选择A选项。
85有以下程序：
#include <stdio.h>
main()
{
int A=0,B=0,C=0;
C=(A-=A-5);
(A=B,B+=4);
printf("%d,%d,%d\n",A,B,C);
}
程序运行后输出的结果是（ ）。
A．0,4,5
B．4,4,5
C．4,4,4
D．0,0,0
【答案】A
【解析】C语言中可以将多条语句放在同一行，用“;”隔开。赋值运算和逗号运算都是从左到右结合。首先执行A-=A-5，即A=A-(A-5)，得A的值为5，然后执行C=(A-=A-5)，即将A的值5赋给变量C，使得C的值也为5。然后执行下句逗号表达式中的A=B，把B的值0赋给A，此时A的值为0，然后执行B=B+4，使得B的值为4，最后打印输出。答案选择A选项。
86有以下程序
#include<stdio.h>
main()
{
int a,b,k,m,*p1,*p2;
k=1,m=8;
p1=&k,p2=&m;
a=/*p1-m;
b=*p1+*p2+6;
printf("%d",a);
printf("%d\n",b);
}
编译时编译器提示错误信息，你认为出错的语句是（ ）。
A．a=/*p1-m
B．b=*p1+*p2+6;
C．k=1,m=8;
D．p1=&k,p2=&m;
【答案】A
【解析】a=/*p1-m;语句不符合语法规范，可写作a/=(*p1-m);，表示a=a/(*p1-m);。答案选择A选项。
87有以下程序：
#include<stdio.h>
int sub(double a,double b)
{
return(int)(a-b);
}
main()
{
printf("%d\n",sub(3.8,2.1));
}
程序运行后的输出结果是（ ）。
A．2.0
B．1.7
C．2
D．1
【答案】D
【解析】在类型转换过程中，如果较高类型转换成较低类型，直接忽略多余位数。程序执行过程为：调用函数sub(3.8,2.1)，3.8-2.1=1.7（double类型），(int)强制转换将1.7转换成int类型1，然后返回1并输出。答案选择D选项。
88有以下程序：
#include<stdio.h>
int sub(double a,double b)
{
return(int)(a-b-1.3);
}
main()
{
printf("%d\n",sub(3.2,4.1));
}
程序运行后的输出结果是（ ）。
A．-2
B．1.7
C．-3
D．2.0
【答案】A
【解析】sub函数输出(int)(a-b-1.3)将结果强制转化为整型。(a-b-1.3)=-2.2，(int)(-2.2)=-2，sub(3.2,4.1)=-2，答案选择A选项。
89有以下程序：
#include<stdio.h>
float fun(double a)
{
double x;
x=a-(int)a;
return x;
}
main()
{
double a=3.1415;
printf("%f\n",fun(a));
}
程序的运行结果是（ ）。
A．3.000000
B．3.141500
C．0.141500
D．0.000000
【答案】C
【解析】在fun函数中，x=a-(int)a表示x取值为a的小数部分，因此，输入a为3.1415，输出x=0.141500。答案选择C选项。
90有以下程序：
#include <stdio.h>
#include <math.h>
main()
{
int a = 1,b=4,c = 2;
double x = 10.5,y = 4.0,z;
z = (a + b)/c + sqrt(y)*1.2/c+x;
printf("%f\n",z);
}
程序运行后的输出结果是（ ）。
A．13.700000
B．14.000000
C．15.400000
D．14.900000
【答案】A
【解析】sqrt为平方根计算函数，a、b、c三个变量都是整型变量，(a+b)/c结果也取整型得2，所以有z=(1+4)/2+2*1.2/2+10.5=13.7。%f格式输出后为13.700000。答案选择A选项。
91若变量已正确定义并赋值，则错误的赋值语句是（ ）。
A．a=a+1;
B．a=sizeof(double);
C．a=d||c;
D．a+1=a;
【答案】D
【解析】赋值号的左边必须是一个代表某个存储单元的变量名，赋值号的右边必须是C语言中合法的表达式。赋值运算的功能是先求出右边表达式的值，然后把此值赋给赋值号左边的变量。答案选择D选项。
92设a、b、c是整型变量且均已赋值，则以下选项中错误的赋值语句是（ ）。
A．a=(b=3)=1;
B．a=(b=2)+c;
C．a=b=c+10;
D．a=1+(b=c=2);
【答案】A
【解析】赋值运算结合性为由右向左结合，赋值运算符左值为变量，右值为变量或常量或表达式，且左右两边数据类型相同才能实现赋值。A项中，赋值运算(b=3)=1，左值为表达式，不是变量不能被赋值，A项错误。B项运算过程为，先赋值b=2，再计算b+c，将结果赋给a，是正确的赋值语句。C项运算过程为，先计算c+10将结果赋给b，再将b赋给a，是正确的赋值语句。D项运算过程为，先将2赋给c，再将c赋给b，然后计算1+b，将结果赋给a，是正确的赋值语句。答案选择A选项。
93设有定义：
int a=0,b=1,c=1;
以下选项中，表达式值与其他三个不同的是（ ）。
A．b=a==c
B．a=b=c
C．a=c==b
D．c=a!=c
【答案】A
【解析】赋值运算结合性为由右向左结合，成功实现赋值后以左值为返回值。逻辑表达式成立则返回1，不成立返回0。A项，逻辑表达式a==c不成立，则b=0，表达式值为0；B项，将c赋值给b，b=1，再将b赋给a，a=1，表达式值为1；C项，逻辑表达式c==b成立，则a=1，表达式值为1；D项，逻辑表达式a!=c成立，则c=1，表达式值为1。A项与其他项不同。答案选择A选项。
94若有定义：
int a,b,c;
以下选项中的赋值语句正确的是（ ）。
A．a=(b=c)+1;
B．(a=b)=c=1;
C．a=(b==c)=1;
D．a+b=c;
【答案】A
【解析】赋值运算结合性为由右向左结合，赋值运算符左值为变量，右值为变量或常量，且左右两边数据类型相同才能实现赋值。A项中，将c赋值给b，然后将b加1赋值给a，是正确的赋值语句，正确。B项中，将1赋值给c，赋值运算(a=b)=c中左值为表达式，不是变量不能被赋值，错误。C项中赋值运算(b==c)=1左值为逻辑表达式，不是变量不能被赋值，错误。D项左值a+b为表达式，不是变量不能被赋值，D项错误。答案选择A选项。
95设a、b、c是整型变量，且已正确赋初值，以下选项中错误的赋值语句是（ ）。
A．a=1%(b=c=2);
B．a=(b=3)*c;
C．a=b=c/10;
D．a=2=(b=9)=1;
【答案】D
【解析】D项，“()”具有最高优先级，b先赋值9，再根据赋值运算符号自右向左进行赋值，再给b赋值为1，再计算2=b，赋值运算符左边必须是一个变量，但数值2是常量，语法错误。答案选择D选项。
96若已有定义语句：int a,b,c;，且变量已正确赋初值，则以下选项中正确的赋值表达式是（ ）。
A．a=(b=c)+8;
B．(a=b)=c=9;
C．a=(b==c)='A';
D．a+b=c+1;
【答案】A
【解析】A项正确，将c赋值给b后又加上8，然后再赋值给a；B、D项错误，赋值运算符左边必须是一个变量；C项错误，(b==c)是个表达式，语法错误。答案选择A选项。
97若想给已定义为int型的变量a、b、c、d赋整数1，以下选项中错误的语句是（ ）。
A．a=b,b=c,c=d,d=1;
B．a=b=c=d=1;
C．a=1,b=a,c=b,d=c;
D．d=1,c=d,b=c,a=b;
【答案】A
【解析】由于C语言逗号表达式的的执行顺序是从左向右，赋值运算符是自右向左，A选项先执行a=b时，b为空值，故不正确；所以在连续赋值时一定要保证赋值运算符的右项有确定的值。答案选择A选项。
98若有定义
double a=22;int i=0,k=18;
则不符合C语言规定的赋值语句是（ ）。
A．a=a++,i++
B．i=(a+k)<=(i+k)
C．i=a%11
D．i=!a
【答案】C
【解析】C项错误，在C语言的算术运算符中，取余运算符“%”的左右两侧的两个运算分量必须是整数。A项，赋值运算符的优先级高于“,”运算法，先进行赋值；B项，将“=”右边的逻辑表达式的计算结果赋给变量i；D项，首先对变量a求逻辑非操作，然后将结果赋值给变量i。答案选择C选项。
99设变量已正确定义并赋值，以下正确的表达式是（ ）。
A．x=y*5=x+z
B．int(15.8%5)
C．x=y+z+5,++y
D．x=25%5.0
【答案】C
【解析】赋值运算左边必须是单一变量名。A项错误，“y*5=x+z”部分是非法赋值。BD两项错误，求余运算中的操作对象只能是整型。C项，为逗号表达式。答案选择C选项。
100若变量均已正确定义并赋值，以下合法的C语言赋值语句是（ ）。
A．x=y==5;
B．x=n%2.5;
C．x+n=i;
D．x=5=4+1;
【答案】A
【解析】A项正确，y==5返回0或者1，然后赋值给x。B项错误，浮点数不能参与模运算；C项错误，赋值运算符左边只能是单一变量，x+n是右值，不能给它赋值；D项错误，5是常量，不能被赋值。答案选择A选项。
101以下选项中合法的C语言赋值语句是（ ）。
A．++i;
B．a=b=34
C．a=3,b=9
D．k=int(a+b);
【答案】A
【解析】B项和C项缺少分号，不合法。D项类型转换不合法，应为k=(int)(a+b)。答案选择A选项。
102设有定义：
int x=11,y=12,z=0;，
以下表达式值不等于12的是（ ）。
A．(z,x,y)
B．(z=x,y)
C．z=(x,y)
D．z=(x==y)
【答案】D
【解析】逗号表达式的计算过程是从左到右逐个求每个表达式的值，取最右边一个表达式的值作为该逗号表达式的值。赋值运算结合性为由右向左结合，赋值运算符左值为变量，右值为变量或常量或表达式，且左右两边数据类型相同才能实现赋值。成功实现赋值后以左值为返回值。逻辑表达式成立则返回1，不成立返回0。D选项逻辑表达式x==y不成立，则z=0，表达式值为0。B选项逗号表达式x，y取y值为表达式值，然后赋值给z=12，表达式值为12。C选项逗号表达式(x,y)取y值为表达式值，然后赋值给z=12，表达式值为12。A选项逗号表达式(z,x,y)取y值为表达式值12。答案选择D选项。
103若有定义语句：
int x=10;
则表达式x-=x+x的值为（ ）。
A．-20
B．-10
C．0
D．10
【答案】B
【解析】单目加运算符优先级高于赋值运算符，所以先做x+x结果为20，再做x-20，结果为-10，然后赋值给x。所以答案选择B选项。
104若有定义语句：
int a=12;
则执行语句：a+=a-=a*a;后，a的值是（ ）。
A．-264
B．552
C．144
D．264
【答案】A
【解析】赋值运算结合性为自右向左，a+=a-a*a相当于a=a-a*a，a=a+a；自右向左计算过程为a=a-a*a=-132，a=a+a=-264。答案选择A选项。
105有以下定义
int a;
long b;
double x,y;
则以下选项中正确的表达式是（ ）。
A．(a*y)%b
B．a==x<>y
C．a%(int)(x-y)
D．y=x+y=a
【答案】C
【解析】%运算是取两整数相除后余数的运算符，它只适用于整数的运算。A项错误，(a*y)%b中的(a*y)为double型；B项错误，C语言中没有<>运算符；C项正确，x-y结果为double型，但是通过强制类型转换将其转换为int型； D项错误，x+y不能作为左值。答案选择C选项。
106有以下程序
#include <stdio.h>
#include <math.h>
main()
{
int a = 3;
printf("%d\n",(a+=a-=a*a));
}
程序运行后的输出结果是（ ）。
A．-12
B．9
C．0
D．3
【答案】A
【解析】C语言中，表达式从右向左计算。a+=a-=a*a;可以写成a-=a*a; a+=a;，而a-=a*a等价于a = a-(a*a) = 3-(3*3) = -6；a+=a等价于a = a+a =(-6)+(-6) = -12。答案选择A选项。
107设有定义：
int k=0;
以下选项的四个表达式中与其他三个表达式的值不相同的是（ ）。
A．++k
B．k+=1
C．k++
D．k+1
【答案】C
【解析】后缀表达式，先赋值，后自增。k++表达式值为k的值0；其余三项为k+1的值，即1。答案选择C选项。
108设变量均已正确定义并且赋值，以下与其他三组输出结构不同的一组语句是（ ）。
A．x++;printf("%d\n"，x);
B．n=++x;printf("%d\n",n);
C．++x;printf("%d\n",x);
D．n=x++;printf("%d\n",n);
【答案】D
【解析】“++”和“--”运算，当以前缀形式出现时，则先进行加一或减一操作，再取值，当以后缀形式出现时，则先取值，再进行加一或减一操作。++x表示先将x值加1后再用，x++表示先使用x值，用后再加1，所以本题中ABC选项都会输出x+1的值。答案选择D选项。
109有以下程序：
#include<stdio.h>
main()
{
int x=010,y=10;
printf("%d,%d\n",++x,y--);
}
程序运行后的输出结果是（ ）。
A．10,9
B．11,10
C．010,9
D．9,10
【答案】D
【解析】整型常量有3种表示方法，分别是十进制数表示法、八进制数表示法和十六进制数表示法，八进制整常量以0作为前缀。自增和自减运算符的两种用法：前置运算，运算符放在变量之前，规则是先使变量的值增（或减）1，然后以变化后表达式的值参与其他运算；后置运算，运算符放在变量之后，规则是变量先参与其他运算，然后再使变量的值增（或减）1。x=010，即十进制的8，y=10，++x先自加后取值，输出9，y--先取值输出10，再自减y=9，答案选择D选项。
110有以下程序：
#include<stdio.h>
main()
{
int i,j,k,a=5,b=6;
i=(a==b)?++a:--b;
j=a++;
k=b;
printf("%d,%d,%d\n",i,j,k);
}
程序的运行结果是（ ）。
A．7,6,5
B．5,5,5
C．7,5,5
D．5,6,5
【答案】B
【解析】条件表达式i=(a==b)?++a:--b;中先执行a==b，值为假，根据三元运算符语法规则，执行--b，此时b为5，赋给i，i=5。j=a++，将a=5先赋给j，再进行a++，j=5，a=6，k=b=5，故最后输出的是5,5,5。答案选择B选项。
111有以下程序：
#include<stdio.h>
main()
{
int a;
scanf("%d",&a);
if(a++<9)printf("%d\n",a);
else printf("%d\n",a--);
}
程序运行时键盘输入9<回车>，则输出的结果是（ ）。
A．10
B．11
C．9
D．8
【答案】A
【解析】“++”和“--”运算，当以前缀形式出现时，则先进行加一或减一操作，再取值，当以后缀形式出现时，则先取值，再进行加一或减一操作。判断条件中if(a++<9)是先用后加，即a的值为9，所以条件不成立，但是a已经进行了自增1操作，a的值此时为10。执行else语句时，因为打印a--，是先用后减，所以先输出10，然后a的值变为9。答案选择A选项。
112有以下程序：
#include <stdio.h>
main()
{
int a=1,b=0;
if(--a) b++;
else if(a==0) b+=2;
else b+=3;
printf("%d\n",b);
}
程序运行后的输出结果是（ ）。
A．0
B．1
C．2
D．3
【答案】C
【解析】“++”和“--”运算，当以前缀形式出现时，则先进行加一或减一操作，再进行其他运算，当以后缀形式出现时，则先进行其他运算，再进行加一或减一操作。a初始定义为1，b为0，执行--a，a的值变为0，--a的值也为0，即if判断为假，执行b+=2，输出b的值为2。答案选择C选项。
113有以下程序：
#include <stdio.h>
main()
{
int a=7;
while(a--);
printf("%d\n", a);
}
程序运行后的输出结果是（ ）。
A．-1
B．0
C．1
D．7
【答案】A
【解析】“++”和“--”运算，当以前缀形式出现时，则先进行加一或减一操作，再取值，当以后缀形式出现时，则先取值，再进行加一或减一操作。程序中执行a--，直到while判断为0时才跳出循环，执行下条语句，即a为0时再执行a--，此时跳出while循环，最终输出的结果为-1。答案选择A选项。
114有以下程序：
#include <stdio.h>
main()
{
int a=1,b=1;
while(a--)
b--;
printf("%d,%d\n", a,b);
}
程序的运行结果是（ ）。
A．-1,0
B．0,0
C．-1,-1
D．1,1
【答案】A
【解析】while循环的判定条件为“a--”，即a先作为循环条件判定，然后再自减1。第一次循环判定条件为真，执行完毕后a=0，b=0，第二次循环判定条件为假，循环不成立，所以只执行判定表达式"a--"，所以最终a=-1，b=0，答案选择A选项。
115有以下程序
#include <stdio.h>
main()
{
int x,y,z;
x=y=1;
z=x++,y++,++y;
printf("%d,%d,%d\n",x,y,z);
}
程序运行后的输出结果是（ ）。
A．2,3,1
B．2,3,2
C．2,3,3
D．2,2,1
【答案】A
【解析】注意区分，z=x++是先将x的值赋给z，在令x自增；z=++x是先将x自增，再将自增后的值赋给z；而无论是++x还是x++，都会完成x自增的运算。对于表达式“z=x++,y++,++y;”，因为赋值运算符的优先级高于逗号运算符的优先级，所以可以将上式改成“(z=x++),(y++),(++y)”。然后从左向右先计算表达式z=x++，后缀自增运算先进行其他运算，再执行自增运算，所以z的值为1，x的值为2，再计算逗号表达式第二个表达式y++，此时y的值为1，y++的值为2，最后计算第三个表达式++y，y的值为3。答案选择A选项。
116以下程序段中的变量已定义为int类型，则
sum=pAd=5;
pAd=sum++,++pAd,pAd++;
printf("%d\n",pAd);
程序段的输出结果是（ ）。
A．6
B．4
C．5
D．7
【答案】D
【解析】自增和自减运算符的两种用法：前置运算，运算符放在变量之前，规则是先使变量的值增（或减）1，然后以变化后表达式的值参与其他运算；后置运算，运算符放在变量之后，规则是变量先参与其他运算，然后再使变量的值增（或减）1。执行pAd=sum++，sum++是后置自增，执行完后，pAd=5，sum=6；++pAd和pAd++语句中没有其他运算，即效果相同，pAd分别加1，两句执行完后，pAd = 7。答案选择D选项。
117有以下程序
#include<stdio.h>
main()
{
int sum,pad,pAd;
sum=pad=5;
pAd=++sum,pAd++,++pad;
printf("%d\n",pad);
}
程序的输出结果是（ ）。
A．8
B．5
C．7
D．6
【答案】D
【解析】C语言中的标识符区分大小写，pad只实现了一次自增操作，结果输出6。答案选择D选项。
118有以下程序
#include <stdio.h>
main()
{
int i;
for(i=1;i<=40;i++)
{
if(i++%5==0)
if(++i%8==0)printf("%d",i);
}
printf("\n");
}
执行后的输出结果是（ ）。
A．32
B．24
C．5
D．40
【答案】A
【解析】自增运算符“++”分为前缀和后缀两种形式。两种形式的作用效果是一样的，都是使运算分量的值加1，但是它们的表达式的值不一样，前缀形式表达式的值为运算分量加1之后的值，而后缀形式表达式的值为运算分量加1之前的值。题目中使用了一个for循环，循环变量i从1递增到40。在循环体中有两条嵌套的if语句，首先判断i++%5==0，即判断i++的值（i加1之前的值）是否能被5整除（判断后i被加1），然后再判断++i的值（i加1之后的值）是否能被8整除（判断后i被加1），若两个条件都满足了，就输出i的值，只有i=30时，满足i++%5==0，此时i=31，++i%8==0成立，此时i=32。答案选择A选项。
119有如下程序：
#include<stdio.h>
main()
{
int a =0,b=1;
if(++a==b++)
printf("T");
else
printf("F");
printf("a=%d,b=%d\n",a,b);
printf("\n");
}
程序运行后的输出结果是（ ）。
A．Ta=0,b=1
B．Fa=1,b=2
C．Ta=1,b=2
D．Fa=0,b=2
【答案】C
【解析】程序执行过程为：判断++a==b++是否成立，++a前置运算先加1，则运算符==左边表达式值为1，a=1，b++后置运算先取值，则==右边表达式值我1，b=2，即是判断1==1，成立，输出T，输出a=1，b=2。答案选择C选项。
120有如下程序：
#include<stdio.h>
main()
{
int a =0,b=1;
if(a++&&b++)
printf("T");
else
printf("F");
printf("a=%d,b=%d\n",a,b);
}
程序运行后的输出结果是（ ）。
A．Ta=1,b=2
B．Fa=0,b=2
C．Fa=1,b=1
D．Ta=0,b=1
【答案】C
【解析】程序中判断if条件是否成立，a++先取值为0，则(a++&&b++)为0，不且不计算b++，而后a自增得a=1，if条件不成立，执行else下的语句，输出F。最后执行输出语句；按照格式输出a=1，b=1。答案选择C选项。