福建省C语言二级考试选择+填空+程序填空+输出结

福建省计算机等级考试二级C语言选择题（2010年1月）

一、选择题

50100在Ｃ语言中，合法的字符常量是（ D ）。 A. '字' B. \ C.\ D.'\\x41'

50101下面叙述正确的是（ B ）。

A. 程序中必须包含有输入语句 B. 变量按所定义的类型存放数据 C.main函数必须位于文件的开头 D.每行只能写一条语句

50102错误的叙述是（ D ）。

A. 一个C语言源程序可由一个或多个函数组成 B. 若一条语句较长，也可分写在下一行上

C.C程序必须包含一个main()函数 D.构成C语言源程序的基本单元是算术表达式 50103（C）是关于C语言数据类型的正确叙述。 A. 变量必须先定义后使用 B. 不允许使用空类型 C.枚举类型不是基本类型 D.数组并不是构造类型 50104 main( )函数的位置（ B ）。

A. 必须在自定义函数前面 B. 可以在自定义函数后面 C.必须位于程序的最前面 D.必须在自定义函数后面 50105 C语言函数体由（ C ）括起来。 A. < > B. ( ) C.{ } D.[ ]

50106（ A ）是不正确的叙述。

A. 注释说明只能位于一条语句的后面 B. C源程序的基本组成单元是函数 C.C源程序可由一个或多个函数组成 D.每条语句最后必须有一个分号 50107一个C语言源程序是由（ B ）。

A. 一个主程序和若干子程序组成 B. 函数组成 C.若干过程组成 D.若干子程序组成

50108结构化程序设计的三种基本结构是（ C ）。

A. 函数结构、判断结构、选择结构 B. 平行结构、嵌套结构、函数结构 C.顺序结构、选择结构、循环结构 D.判断结构、嵌套结构、循环结构 50109C源程序的调试是指对源程序进行（ C ）。

A. 录入与编辑 B. 查错与编译 C.查错与排错 D.连接与运行 50110C语言中，可将一系列语句置于（ C ）从而构成复合语句。 A. 一对尖括号\之间 B. 一对圆括号\之间 C.一对花括号\之间 D.一对方框号\之间 50111构成C源程序的基本单位是（ D ）。 A. 语句 B. 变量 C.运算符 D.函数

50112以下叙述中正确的是（ A ）。

A. C源程序中注释部分可以出现在程序中任意合适的地方 B. 一对花括号\只能作为函数体的定界符

C.C源程序编译时注释部分的错误将被发现 D.构成C源程序的基本单位是函数，所有函数名都可以由用户命名

50113下面叙述正确的是（ D ）。

A.每行最多只能写两条语句 B. 程序中必需含有自定义函数 C.main()函数必须位于源程序文件的开头 D.所有语句都必须以分号\结束

50114下面叙述错误的是（ B ）。

A.若一条语句较长，可分写在下一行或多行上 B.构成C语言源程序的基本单位是语句 C.C源程序中大、小写字母是有区别的 D.一个C源程序可由一个或多个函数组成 50115（ A ）是关于C语言数据类型的正确叙述。

A. 枚举类型不是基本类型 B. 数组不是构造类型 C.变量使用前应定义相应的数据类型 D.不允许使用空类型 50116 C源程序中main()函数的位置（ C ）。

A. 必须位于程序的最前面 B. 必须在系统库函数后面 C.可以在自定义函数后面 D.必须在自定义函数前面

50118下面叙述错误的是（ D ）。

A. C源程序可由一个或多个函数组成 B. C源程序必须包含一个main()函数 C.一个C源程序的执行是从main()函数开始，直到main()函数结束 D.注释说明部分只能位于C源程序的最前面

50200C语言的下列运算符中，优先级最高的运算符是（ A ）。 A. ++ B. += C.|| D.!= 50201（ D ）为正确的用户标识符。 A. struct B. 5f C._f 0.6 D._for

50202C语言基本数据类型包括（ B ）。

A. 整型、实型、逻辑型 B. 整型、实型、字符型 C.整型、字符型、逻辑型 D.整型、实型、字符串型 50203（ A ）为合法的常量。

A. 52686L B. E-7 C.1.2E-2.1 D.'E12' 50204（ C ）为正确的变量名。 A. -k15 B. int C.k_5 D.k.jeep 50205（ D ）为正确的字符常量。 A. ''\\\\'' B. \ C.\ D.'M' 50206（ C ）为非法的字符串常量。 A. \ B. \ C.'efg' D.\

50207 C语言整型数据在内存中的代码是用（ C ）表示的。 A. 原码 B. 反码 C.补码 D.BCD码

50208以下选项中，合法的实型常数是（ B ）。 A. E-3 B. .2E1 C.1E.5 D.1.5E

50209下列C语言合法的数据类型关键字是（ B ）。 A. Double B. unsigned C.integer D.Char

50210 Turbo C中，int型数据占用的字节数（ B ）。

A. 由用户自己定义 B. 为2个字节 C.是任意的 D.等于所用计算机的字长 50211 Turbo C中，基本数据类型存储空间长度的排列顺序是（ A ）。 A. char

A. 字符常量用一对单撇号' '作为单个字符的定界符 B. 字符常量和字符串常量一样，都是用双引号括起来

C.字符常量存储时，自动在字符后加一个字符结束符号'\\0' D.字符常量和字符串常量所分配的内存空间大小是一样的 50213（ B）为正确的用户标识符。

A. 3_row B. max_at C.union D.min-5 50214C语言的基本数据类型包括（ A ）。

A. 整型、实型、字符型 B. 整型、实型、空类型 C.整型、字符型、指针型 D.整型、实型、逻辑型 50215（ D ）为合法的常量。

A. 5,326 B. 3.21E-6.5 C.'b_k' D.1.23E+8 50216（ D ）为正确的变量名。

A. 5_pro B. case C.else D.pro_5 50217（ C ）为正确的字符常量。 A. 'bcd' B. '\\084' C.'@' D.'165' 50218（ A ）为非法的字符串常量。 A. '123' B. \ C.\ D.\ \

50300已知'A'的ASCII码的十进制值为65，'0'的ASCII码的十进制值为48，则以下程序运行结果是（ A ）。 main()

{ char ch1,ch2; ch1='A'+'5'-'3'; ch2='A'+'6'-'3';

printf(\ } A. 67,D B. C,D C.C,68 D.67,68

50301若有定义 int m=6; 则正确的赋值表达式是（ C ）。 A. m*7 B. m*5=8 C.m-=m*6 D.double(-m)

50302语句 k=(m=5,n=++m); 运行之后，变量k、m、n的值依次为（ D ）。 A. 5,5,6 B. 5,6,5 C.6,6,5 D.6,6,6

50303语句 x=5%4+(4/5); 运行之后，整型变量x的值为（ A ）。 A. 1 B. 2 C.3 D.0

50304（B ）语句符合C语言语法。

A. float z=28,int x,y=18; B. int x=25,y=25,z=25; C.int x=25:y=25:z=25; D.int x+y=z;

50305若有定义 int a,x; 则语句 a=(x=8,x+8); 运行后，变量a、x的值依次为（ A ）。 A. 16, 8 B. 8, 8 C.16, 16 D.8, 16

50306若变量 m, n, t已定义且赋予初值，则正确的表达式是（ B ）。 A. m=m+1=t-n B. m=6+n+t,m++ C.m=m\\2 D.m=int(5.6%4)

50307若有定义：int a,b; float x，则以下不符合C语言语法的表达式是（ A ）。 A. x%7 B. x/=a-b C.a=b=2 D.x=(float)a/b

50308若有定义：int m=4,n=5;float k;，则以下符合C语言语法的表达式是（ B ）。 A. (m+n)*=k B. m=(n==5) C.k=float(n)/m D.n%2.5

50309若有定义：int a=6; 则语句 a*=a-=a/=3; 运行后，a的值是（ B ）。 A. 10 B. 0 C.34 D.24

50310下面关于C语言变量的叙述中，错误的是（ A ）。

A. 可以用define关键字定义变量 B. 变量名用大小写字母是有区别的 C.C语言允许不同基本类型的变量之间进行混合运算

D.C语言中要求对变量作强制定义的主要理由是：便于确定类型和分配空间 50311若有定义：int a=5,b=2; 则表达式b= (a!=5)的值为（ B ）。 A. 5 B. 0 C.3 D.2

50312逗号表达式 (a=15,a*4),a+15 的值为（ B ）。 A. 15 B. 30 C.75 D.60

50313若有定义：int b=-15; 则（ A ）为正确的赋值表达式。 A. b+=b*3 B. b=*5 C.*b=6 D.b+10=-5

50314若有定义：int x,a,b; 语句x=(a=2,b=3,a+b); 运行后，x、a、b的值依次为（C ）。 A. 2 3 5 B. 3 2 5 C.5 2 3 D.5 3 2

50315若有定义：int a,b=5; 语句a=(b/2)+b%2; 运行后，a的值为（ B ）。 A. 0 B. 3 C.4 D.2

50316（C ）语句符合C语言语法。

A. int a=2,b+=a; B. int a=b=2,c=5; C.float x=2.3,b,c; D.float x=3.2,int i,j=6; 50317若有定义：int a=3; 语句a+=a-=a*a; 运行后，a的值为（ C ）。 A. 0 B. -3 C.-12 D.-6

50318若有定义 int x=1,y=2,n=3; 则（ A ）为正确的表达式。 A. x=y*3,y=(x+n)/y B. x=ny C.float(y/n) D.(x+y)(y+n)

50400下列语句中，符合C语言语法的赋值语句是（ C ）。

A. a=7+b+c=a+7; B. a=7+b++=a+7; C.a=7+b,b++,a+7; D.a=7=b,c=a+7;

50401（ A ）是正确的叙述。

A. (int)5.0/6 与 5/6 等价 B. 'G' 与\等价 C.5/6 与 5.0/6.0 等价 D.++3与4 等价 50402下面叙述中，错误的是（ D ）。

A. C语言中的表达式求值，是按其运算符的优先级先高后低的次序进行 B. 自增与自减运算符的结合方向为“自右至左”

C.关系运算符的优先级低于算术运算符 D.C语言算术运算符不包含模运算符“%” 50403（ C ）是正确的叙述。

A. 表达式 \是合法的 B. 若变量x, y为整型，则 (a+b)++是合法的 C.强制类型转换运算的优先级高于算术运算 D.表达式 'm' * 'n' 是不合法的 50404若有定义 int i=1,j=9; 则表达式 (++j)*(i--) 的值为（ B ）。 A. 0 B. 10 C.9 D.8

50405设整型变量x为7，使整型变量y不为2的表达式是（ A ）。 A. y=x%3 B. y = x/3 C.y =(++x)/3 D.y=8-(--x)

50406若已定义 int a=3,b=2,c=1; 则语句 ++a||++b&&++c; 运行后b的值为（ D ）。 A. 0 B. 3 C.1 D.2

50407若有定义：int i=5,j=4;则语句 i/=++j; 运行后i的值为（ B ）。 A. 10 B. 1 C.1.25 D.0

50408若已定义：int a=2,b=2; 则表达式 (a+(b++), b) 的值是（ B ）。 A. 2 B. 3 C.4 D.6

50409若有定义：int r,x=245; 则语句 r=x/100%9; 运行后r的值为（ A ）。 A. 2 B. 5 C.0 D.27

50410若已定义：int i=6,t; 则语句 t=3+(--i); 运行后t的值为（ C ）。 A. 9 B. 7 C.8 D.5

50411C语言的 % 运算符按运算对象的个数属（ C ）。

A. 单目运算符 B. 四目运算符 C.双目运算符 D.三目运算符

50412若已定义：int a=5,b=9,c=6; 则语句 b++; ++c; a=b-c; 运行后a的值为（ B ）。 A. 5 B. 3 C.2 D.4

50413下面叙述正确的是（ B ）。

A. 2/3 与 2%3 等价 B. 5/(int)4.0 与 5/4 等价 C.++2 与 3 等价 D.++2与--3 等价 50414下面叙述错误的是（ A ）。

A. 算术运算符中只有\、\优先级高于关系运算符 B. 模运算符\是C语言基本的算术运算符

C.自加和自减运算符只能用于变量，而不能用于常量或表达式

D.算术运算符中不包含\运算符

50415下面叙述正确的是（ A ）。

A. C语言中整型与字符型变量的混合运算表达式的结果是整型 B. (3+9)++ 是正确表达式

C.模运算符\两边运算数的数据类型是任意的 D.\是正确表达式 50416若有定义：int i=3,j=6; 则表达式(--i)*(j++)的值为（ C ）。 A. 18 B. 15 C.12 D.10

50417若有定义：int a,b=6; 语句a=--b; 运行后，a、b的值分别是（ C ）。 A. 5 6 B. 6 5 C.5 5 D.6 6

50418若有定义：int x,y,z; 语句 x=(y=z=3,++y,z+=y); 运行后，x的值为（ C ）。 A. 6 B. 8 C.7 D.3

50500以下程序运行时，若从键盘输入5，则输出结果是（ D ）。 main() { int a; scanf(\ if(a++>5) printf(\ else printf(\ } A. 7 B. 4 C.5 D.6

50501若已定义 float x; 要从键盘输入数据36.582给变量x，则应选用（ B ）语句。 A. scanf(\ B. scanf(\C.scanf(\ D.scanf(\50502若已定义 double y; 拟从键盘输入一个值赋给变量y，则正确的函数调用是（ C ）。 A. scanf(\ B. scanf(\ C.scanf(\ D.scanf(\50503已有定义 char s; 使用scanf( )函数输入一个字符给变量s，不正确的函数调用是（ D ）。

A. scanf(\ B. scanf(\ C.scanf(\ D.scanf(\50504函数putchar( ) 的功能是向终端输出（ A ）。

A. 一个字符 B. 多个字符 C.一个关系表达式 D.一个实型变量值

50505若已定义 int a=11; 执行以下语句后的输出结果是（ B ）。 printf(\

A. a=11, a=11, a=b B. a=11, a=13, a=b C.a=11, a=13, a=c D.a=11, a=12, a=13 50506若有定义 int m=4321,n=123,k=21; 语句printf(\执行后的输出结果是（ C ）。

A. 4321432143211231231232121 B. 43211232 C.4321+123+21 D.432+123+02

50507已有如下定义和输入语句， char c1,c2;int x; scanf(\ 若要求x、c1、c2的值分别为9、'K'和'H'，正确的数据输入是（ A ）。 A. K9H B. K 9 H C.K9 H D.9KH

50508以下程序段的运行结果是（ B ）。 int a=1; printf(\a++);

A. 3,3,1 B. 2, 2, 1 C.1, 2, 3 D.3, 2, 1

50509以下程序的运行结果是（ D ）。 void main() { int a=65; char c='A';

printf(\ } A. A+A=AA B. 65+A=65a C.65+65=130 D.65+A=130

50510若已定义：int x=7;float y=7.0; 以下语句中能输出正确值的是（ B ）。 A. printf(\ B. printf(\C.printf(\ D.printf(\

50511putchar函数可以向终端输出一个（ A ）。

A. 字符或字符型变量值 B. 整型变量表达式值 C.实型变量值 D.字符串 50512若已定义：int a=6;float b=1.5; 要求输出形式为： 6 * 1.50=9.00 ，应选用的正确输出语句是（ B ）。

A. printf(\ B. printf(\C.printf(\ D.printf(\

50513若有定义 float x; 要从键盘输入数据6.02赋给x，则应选用（ D ）语句。 A. scanf(\ B. scanf(\ C.scanf(\ D.scanf(\50514 只能向终端输出一个字符的是（ D ）。

A. printf()函数 B. scanf()函数 C.getchar()函数 D.putchar()函数

50515 若有语句 int a; char c; scanf(\为将整数135赋给a，字符'6'赋给c，正确的数据输入方式是（ B ）。（说明：代表换行，__代表空格） A. 135__6 B. 1356 C.1356 D.135__6__ 50516 getchar()函数的功能是获取终端输入的（ B ）。

A. 多个字符 B. 一个字符 C.一个实型变量值 D.一个整型变量表达式

50517 若有定义 int a=8,b=5; 要实现输出形式为: 8*5=40 ，正确的printf()函数调用语句是（ D ）。

A. printf(\ B. printf(\

C.printf(\ D.printf(\

50518若有定义:char c1='A',c2='B'; 语句printf(\运行后的结果为（ D ）。（说明：'A'的ASCII码的十进制值为65）

A. A+B=131 B. 65+66=AB C.A+B=AB D.65+66=131 50600有以下程序： main() { int c;

while((c=getchar())!= '\\n') { switch(c-'2') { case 0 :

case 1 : putchar(c+4);

case 2 : putchar(c+4); break;

case 3 : putchar(c+3);

default: putchar(c+2); break; } }

printf(\ } 当输入：247<回车>，程序的输出结果是（ B ）。 A. 689 B. 6689 C.66778 D.66887

50601若已定义 int x=5,y=9,z; 语句 z=x>=y; 运行后z的值为（ C ）。 A. 1 B. .t. C.0 D..f.

50602判定逻辑值为“真”的最准确叙述是（ D ）。 A. 1 B. 大于0的数 C.非0的整数 D.非0的数

50603若已定义 int x=-16,y=-12,z; 语句z=x<=y; 运行后z的值为（ B ）。 A. .t. B. 1 C..f. D.0

50604能正确表示数学关系式 100≤s＜300的表达式为（ C ）。 A. (s>=100) & (s<300) B. 100<= s<300

C.(s>=100) && (s<300) D.(s>=100) and (s<300)

50605若定义 int a=2,b=3; 则表达式 !a||b 的值为（ B ）。 A. 0 B. 1 C.2 D.3

50606若定义 int a=-5,b=-8,c=-12; 则表达式 a>=b||b

50607下列表达式（ C ）不能用来判断整型变量x中的值是否为奇数。 A. x%2==1 B. !(x%2==0) C.!(x%2) D.x%2

50608若有定义：int a=3,b=2,c=3; 则值为0的表达式是（ D ）。

A. (a-b)==(c/b) B. a>=c C.c-b||a+b&&(b*c-a-c) D.(b*c-a-c)&&(b*c-a-b) 50609若已定义：int x=4,y=2,z=0; 则表达式 (x-y<=y)|| (y=z)的值是（ A ）。 A. 1 B. 0 C.2 D.4

50610若有定义：int a=3,b=2,c=1,k; 则表达式k=a>b>c的值是（ A ）。 A. 0 B. 1 C.2 D.3

50611以下运算符中优先级最高的是（ D ）。 A. <= B. && C.|| D.!

50612执行以下语句后，b的值是（ A ）。 int a=5,b=6,c=1,x=2,y=3,z=4; (a=c>x) || (b=y>z); A. 0 B. 1 C.-1 D.6

50613 x的值在-20至-5之间为“真”，否则为“假”的正确逻辑表达式为（ B ）。 A. -20-20 && x<-5 C.!(x>-20) && !(x<-5) D.-5

50614若有定义：int a; 则表达式（ B ）不能用来判断a值为奇数是“真”，偶数是“假”。 A. a%2==1 B. !(a%2) C.a%2 D.!(a%2==0)

50615若有定义：int a=1,b=2,c=3,d=4,t=2,k=2; 语句(t=a

A. 2 B. 1 C.0 D.-

50616若有定义：int x=1,y=2,z=3; 则表达式（ A ）的值为0。 A. !((xy || x

50617若有定义: int a=3,b=5,c=8; 则表达式 !(a-b) || (c-b) 的值为（ A ）。 A. 1 B. 0 C.2 D.3

50618若有定义: int a; 且表达式 !a的值为0，则表达式（ A ）的值为1。 A. a!=0 B. a==0 C.a=0 D.!(a<0 || a>0) 50700以下程序运行后，a的值是（ C ）。 main() { int a,b;

for(a=1,b=1;a<=100;a++) { if(b>=20) break;

if(b%3==1) { b+=3; continue; }

b-=5; } }

A. 101 B. 100 C.8 D.7

50701已定义 double k=3.6; 则正确的赋值表达式是（ D ）。

A. k=double(-3.6) B. k%3 C.k=k*(-1.0)=-3.6 D.k+=k-=(k=1.2)*(k=3) 50702已定义 char c = 'A' ; 则正确的赋值表达式是（ B ）。 A. c=\\028 B. c=(c++)%4 C.c+1=66 D.c+=127-- 50703已定义 int m ='A'; 则正确的表达式是（ C ）。 A. 2*m=m++ B. m=int(-3.2) C.m%3 D.m=m-m=m-5

50704设已定义 float a=2.0,b=3.0; 使a值为5.0的表达式是（ A ）。 A. a+= b B. a*=b+2.0 C.a/=b+2.0 D.a-=b+2.0

50705若已定义 int m=7;float k=5.5; 则表达式 k+ m%2/4 的值为（ D ）。 A. 6.375 B. 6.75 C.5.75 D.5.5

50706若已定义 int a=3,b=3,x=1,y=2; 表达式 (a=y>x)&&(x=b>a) 的值是（ B ）。 A. 6 B. 1 C.9 D.0

50707若有定义：int a=2,b=3; float x=5; 则表达式x*b/a的值是（ A ）。 A. 7.5 B. 7 C.6 D.5

50708若有定义：int x=8; float y=130;char z='A'; 则表达式x+z%(int)y的值是（ C ）。 [已知'A'的ASCII码的十进制值为65]

A. 运行时产生错误信息 B. 8 C.73 D.8.5

50709若已定义：int m=7,n=4; float x=3.0,y=8.0,k; 则执行语句k=m/2+n*x/y;后，变量k的值是（ C ）。

A. 3 B. 4 C.4.5 D.5

50710若有定义：float x=2,y=4,h=3; 下列表达式中与(x+y)*h/2.0计算结果不相符的是（ C ）。

A. (x+y)*h/2 B. (x+y)*h*1/2 C.(1/2)*(x+y)*h D.h/2*(x+y)

50711表达式2+sqrt(16.0)/4结果的数据类型是（ A ）。 A. double B. int C.char D.void

50712若有定义：int a=4,b=5,c=6; 则表达式 (1.0*a+b)/c的值是（ A ）。 A. 1.5 B. 1 C.4 D.4.5

50713下列运算符中优先级最低的是（ A ）。 A. = B. ! C.> D.*

50714若有定义：float x=3.5,y=3.6; 则表达式（ A ）的值为6。 A. (int)x+(int)y B. x+y C.(int)(x+y) D.int(x+y)

50715若有定义：int x; char c='A'; 则正确的赋值表达式是（ A ）。（说明：'A'的ASCII码的十进制值为65，'a'的ASCII码的十进制值为97）

A. x=c+32 B. x=c+'ABC' C.x=c+'CBA' D.x='ABC'

50716若有定义：float x=2,y; int a=3; 语句y=1*(x+a)/3; 运行后，y的值为（ D ）。 A. 2.0 B. 0 C.1.0 D.1.666667

50717若有定义：float x=3.5,y=5.5; 则表达式（ B ）的值为2。 A. (x+y)%7 B. (int)(x+y)%7 C.int(x+y)%7 D.(int)x+y%7

50718若有定义：int a=6,b=7,k=0,t=1; 语句 (k=a

A. 0 0 B. 1 C.0 1 D.1 0

50800以下程序段的运行结果是（ D ）。 int x=3; do{ printf(\\x-=2 ); }while(!(--x));

A. 1 B. 30 C.死循环 D.1, -2

50801以下程序运行时，若从键盘输入6，则输出结果是（A ）。 void main() {int x;

scanf(\

if (x-->6) printf(\ else printf(\ } A. 4 B. 5 C.6 D.3

50802以下程序的运行结果是（ C ）。 void main() {int m,n=1,t=1;

if(t== 0) t=-t; else m=n>=0?7:3; printf(\ }

A. 3 B. - C.7 D.0

50803对于整型变量a，赋值语句 a=(a%3==0?1:0); 与（D ）语句不等价。 A. if (a%3= =0) a=1; else a=0; B. if (a%3!=0) a=0; else a=1; C.if (a%3) a=0; else a=1; D.if (a%3) a=1; else a=0;

50804以下程序运行的结果是（B ）。 void main() {int x,y,z,a; x=y=z=1;a=15; if(!x) a--; else if(y) ; if(z) a=3; else a+=4;

printf(\ }

A. 15 B. 3 C.19 D.14

50805若已定义 int a=1,b=2,t=3; 则执行以下程序段后变量a，b，t的值分别为（A ）。 if(a

A. a=2,b=1,t=2 B. a=2,b=1,t=1 C.a=2,b=1,t=3 D.a=3,b=1,t=2 50806以下程序段运行后变量k的值为（ C ）。 int a=3,b=2; int k;

k=(--a==b++)?a:b+1; A. 0 B. 1 C.2 D.3

50807以下程序的运行结果是（ C ）。 void main() { int n=9; switch(n--)

{ default: printf(\ \ case 8:

case 7: printf(\ \ break;

case 6: printf(\ \ case 5: printf(\ \ } } A. 8 B. 7 C.8 9 D.8 7 50808以下程序的运行结果是（ C ）。 void main() { int n=8; switch(n--)

{ default: printf(\ \ case 8:

case 6: printf(\ \ break;

case 4: printf(\ \ case 2: printf(\ \ } }

A. 8 B. 8 6 C.7 D.8 7 50809以下程序的运行结果是（ D ）。 void main( )

{ int a; if(a=6)

printf(\

else if(a>6) printf(\ else printf(\ }

A. 运行时产生错误信息 B. 9 C.8 D.6

50810若有定义：int x=10,y=8,a; 则执行语句a=((--x==y)? x: y);后，变量a的值是（ A ）。 A. 8 B. 9 C.10 D.0

50811若有定义: int a=2,b=3,c=1; 则以下程序段的运行结果是（ D ）。 if(a>b)

if(a>c) printf(\ \

else printf(\ \

printf(\ \

A. 3 1 B. 2 C.3 D.1

50812以下条件语句中(其中s1和s2分别表示C语言的语句)，（D）与其他三条语句不等价。

A. if(a) s1; else s2; B. if(a == 0) s2; else s1; C.if(a != 0) s1; else s2; D.if(a == 0) s1; else s2;

50813以下程序段运行时，若从键盘输入5，则运行结果是（D ）。 int a,y=10;

scanf(\ if (a>10) y=a+6; printf(\

A. 10 B. 1 C.16 D.15

50814以下程序的运行结果是（B ）。 void main() {int a,b=2,c=6; a=3;

if(a>6) a=a+b;

else if(a==6) b=a+c;

else a=b+c;

printf(\ } A. 5 B. 8 C.6 D.9

50815若有定义：int x,a; 赋值语句a=(x%3==0)?0:1; 与（ B ）语句不等价。 A. if (x%3!=0) a=1; else a=0; B. if (x%3) a=0; else a=1; C.if (x%3==0) a=0; else a=1; D.if (!(x%3==0)) a=1; else a=0;

50816以下程序段的运行结果是（ C ）。 int s=15; switch(s/4)

{case 1: printf(\ case 2: printf(\

case 3: printf(\ default: printf(\ }

A. Three B. Two Over C.Three Over D.One Over 50817以下程序段的运行结果是（ C ）。 int s=15; switch(s/4)

{default: printf(\ case 1: printf(\ break;

case 2: printf(\ }

A. Two B. Over Two C.Over One D.One

50818以下程序段运行后x的值为（ D ）。 int a=3,b=6,x; x=(a==b)?a++:--b; A. 4 B. 3 C.6 D.5

50900下列程序段中，非死循环的是（ A ）。

A. int i=100; while(1) { i=i0+1; if(i>=100) break; } B. int k=0; do{ ++k; }while(k>=0); C.int s=10; while(++s%2+s%2) s++; D.for(;;)

50901若已定义 int a; 不会产生死循环的语句是（C ）。 A. for( ; ;a+= 2); B. for(a=10; ;a--);

C.for( ;(a=getchar())!= '\\n'; ); D.while(-1) {a++;}

50902在循环语句的循环体中，break语句的作用是（ B ）。 A. 继续执行break语句之后的循环体各语句 B. 提前结束循环，接着执行该循环后续的语句 C.结束本次循环 D.暂停程序的运行

50903以下程序段运行后，循环体中的 n+=3; 语句运行的次数为（ A ）。 int i,j,n=0;

for(i=1;i<=3;i++) {for(j=1;j<=i;j++)

{n+=3; printf(\ } } A. 6次 B. 9次 C.12次 D.1次

50904 do?while循环与while循环的主要区别是（ D ）。

A. while循环体至少无条件执行一次，而do?while循环体可能都不执行

B. do?while循环体中可使用continue语句，while循环体中不允许出现continue语句 C.do?while循环体中可使用break语句，while循环体中不允许出现break语句 D.do?while循环体至少无条件执行一次，而while循环体可能都不执行 50905以下程序段运行后，循环体运行的次数为（ A ）。 int i=8,a＝0; for ( ;i<8;i++) a+= i;

A. 0次 B. 1次 C.8次 D.无限

50906以下程序段运行后变量a的值为（ C ）。 int i=1,a=0; for( ;i<3;i++)

{ continue; a+=i; } A. 6 B. 3 C.0 D.5

50907有以下程序: void main() { int i;

for(i=1; i<=3; i++) switch(i) { case 1: printf(\ break;

case 2: printf(\

default : printf(\ } 执行后输出结果是（A ）。

A. 1223 B. 132 C.111223 D.123 50908以下程序的运行结果是（ C ）。 void main()

{int s = 0, i = 0; while(i< 8) {i++;

if(i%2==0) continue; s+=i; } printf(\ }

A. 36 B. 7 C.16 D.12

50909以下程序的运行结果是（ B ）。 void main()

{int s = 0, i = 0; while(i< 10) {i++;

if(i % 2==0) s += i; } printf(\ }

A. 20 B. 30 C.25 D.45

50910以下程序的运行结果是（C ）。 void main() {int x = 5; do

{ printf(\ } while(!x); }

}

A. 5 4 3 2 1 B. 4 3 2 1 0 C.5 D.4 50911以下程序的运行结果是（D ）。 void main() {int i,j, k=0;

for(i= 3;i>=1;i--) {for(j=i;j<=3;j ++) k += i * j ; } printf(\ } A. 19 B. 29 C.6 D.25

50912以下程序运行时，循环体的执行次数是（ C ）。 void main() {int i,j;

for(i=0,j=1;i<=j+1;i=i+2,j--) printf(\ } A. 3 B. 2 C.1 D.0

50913若有定义: int i,x; （A ）不是死循环。

A. for(x=5;x>0;x--) ; B. while(x=1) ; C.for(i=10; ;i--) ; D.for( ; ;i+=2) ; 50914下面叙述正确的是（D ）。

A. for循环只能用于循环次数已经确定的情况 B. for循环是先执行循环体语句，后判断表达式 C.在for循环中，不能用break语句跳出循环体

D.for循环的循环体可包含多条语句，但必须用花括号{ }括起来 50915以下程序段运行后x的值为（D ）。 int i,j,x=0;

for(i=3;i>=1;i--) for(j=1;j<=i;j++) x=x+2;

A. 14 B. 12 C.8 D.10

50916以下程序段运行后x的值为（ B ）。 int i=0,x=2;

while(i++<=5) {x+=2; }

A. 10 B. 14 C.12 D.8

50917若有定义: int i,x=0; 语句for(i=1;i<=3;i++) x+=2;与下列（ B ）程序段不等价。 A. i=1; for( ;i<=3;i++) x+=2; B. i=1; for( ; ;i++) x+=2;

C.for(i=1;i<=3; ) {x+=2; i++;} D.i=1; for( ;i<=3; ) {x+=2; i++; } 50918以下程序段运行后x的值为（ D ）。 int i=0,x=0;

for(;i<=5;i++,i++) {x+=3;}

A. 15 B. 6 C.12 D.9

51000设已定义char s[ ]=\，则字符串所占的字节数是（ B ）。 A. 19 B. 16 C.18 D.14

51001数组元素下标的数据类型为（ A ）。

A. 整型常量、字符型常量或整型表达式 B. 字符串常量 C.实型常量或实型表达式 D.任何类型的表达式 51002（ B ）是正确的数组定义。 A. int n=10,x[n]; B. int x[10];

C.int N=10;int x[N]; D.int n; scanf(\ int x[n];

51003若已定义 int arr[10]; 则不能正确引用arr数组元素的是（ D ）。 A. arr[0] B. arr[1] C.arr[10-1] D.arr[7+3]

51004若已定义 int x[4]={2,1,3}; 则元素x[1]的值为（ C ）。 A. 0 B. 2 C.1 D.3

51005以下程序段运行后，x[1]的值为（ B ）。 int x[5]={5,4,3,2,1};

x[1]=x[3]+x[2+2]-x[3-1]; A. 6 B. 0 C.1 D.5

51006（ A ）是合法的数组定义。

A. char str[ ]={48,49,50,51,52,53}; B. int a[5]={0,1,2,3,4,5}; C.int a[ ]=\ D.char str[ ]=?string?;

51007若有以下程序: void main( )

{char s[10]= \ r=s;

printf(\ } 则（ D ）。

A. 执行时输出：ajskdl B. 执行时输出：a C.执行时输出：aj D.编译不通过 51008下面程序段的运行结果是（ C ）。 int m[]={5,8,7,6,9,2},i=1; do{ m[i]+=2; } while(m[++i]>5); for(i=0;i<6;i++) printf(\ \

A. 7 10 9 8 11 4 B. 7 10 9 8 11 2 C.5 10 9 8 11 2 D.5 10 9 8 11 4 51009下面程序段的运行结果是（ A ）。 int m[]={5,8,7,6,9,2},i=1; for(i=0;i<6;i++) {if(i % 2 !=0) m[i]+=10; } for(i=0;i<6;i++)

printf(\ \

A. 5 18 7 16 9 12 B. 15 18 17 16 19 12 C.15 8 17 6 19 2 D.5 8 7 6 9 2

51010下面关于数组的叙述中，正确的是（ A ）。

A. 定义数组后，数组的大小是固定的，且数组元素的数据类型都相同 B. 定义数组时，可不加类型说明符

C.定义数组后，可通过赋值运算符\对该数组名直接赋值 D.在数据类型中，数组属基本类型

51011以下程序段的运行结果是（ C ）。 int a[]={1,2,3,4},i,j; j=1;

for(i=3;i>=0;i--) {a[i]=a[i]*j; j=j*3; } for(i=0;i<4;i++) printf(\ \

A. 3 6 9 12 B. 18 12 9 4 C.27 18 9 4 D.54 18 9 4

51012下面关于字符数组的叙述中，错误的是（ B ）。 A. 可以通过赋值运算符“=”对字符数组整体赋值 B. 不可以用关系运算符对字符数组中的字符串进行比较

C.字符数组中的字符串可以整体输入、输出 D.字符数组可以存放字符串 51013若有定义：int a[10],i=2; 能正确引用a数组元素的是（ B ）。 A. a[9+i] B. a[10-i] C.a[10] D.a(7)

51014（ A ）是正确的数组定义。

A. int arr[10]; B. int n=5; int arr[n]; C.int N=5, arr[N]; D.int n; n=5; int arr[n]; 51015若有定义：int arr[15],n=5; 无法正确引用arr数组元素的是（ C ）。 A. arr[0] B. arr[n] C.arr[10+n] D.arr[15-n] 51016以下程序段运行后x的值为（ B ）。 int a[8]={1,2,3,4,5,6,7,8},i,x=0; for(i=0;i<8;i++,i++) x=x+a[i];

A. 36 B. 16 C.20 D.18

51017以下程序段运行后x的值为（ A ）。 int a[8]={1,2,3,4,5,6,7,8},i,x=0; for(i=1;i<8;i++,i++) x=x+a[i];

A. 20 B. 16 C.18 D.36

51018下面叙述错误的是（ C ）。

A. 数组中每一个元素都属于同一个数据类型 B. C语言数组名称是数组在内存中的首地址

C.C语言数组长度在定义数组时可不作确定

D.C语言规定可逐个引用数组元素但不能一次引用整个数组 51100以下程序段的运行结果是（ D ）。 main() { int i=4,j; j=i;

pic(i+2*j-2,'*'); putchar('\\n'); for(j-=2;j>=0;j--) { pic(3-j, ' '); pic(i+2*j, '*'); putchar('\\n'); } } pic(int len,char c) { int k;

for(k=1;k<=len;k++) putchar(c); }

A. * B. ********** C.**** D.********** *** ********* ****** ******** ***** ********** ******** ****** ******* ********** ********** **** 51101以下程序段执行后输出的结果是（ D ）。 int a[][4]={1,2,3,4,5,6,7,8,9,10,11,12}; printf(\

A. 2 B. 3 C.6 D.7

51102以下程序段执行后p的值是（ A ）。 int a[3][3]={3,2,1,3,2,1,3,2,1}; int j,k,p=1;

for(j=0;j<2;j++)

for(k=j;k<4;k++) p*=a[j][k];

A. 108 B. 18 C.12 D.2

51103不能对二维数组a进行正确初始化的语句是（A ）。

A. int a[3][2]={{1,2,3},{4,5,6}}; B. int a[3][2]={{1},{2,3},{4,5}}; C.int a[][2]={{1,2},{3,4},{5,6}}; D.int a[3][2]={1,2,3,4,5};

51104若有定义:int s[3][4]={{1,2},{0},{3,4,5}};则s[2][1]的值为（ B ）。 A. 3 B. 4 C.0 D.

51105若有定义:int a[3][4];则表达式&a[2][1]-a的值为（ C ）。 A. 7 B. 8 C.9 D.10

51106以下程序段运行后sum的值为（ D ）。 int k=0,sum=0;

int a[3][4]={1,2,3,4,5,6,7,8,9,10,11,12}; for(;k<3;k++) sum+=a[k][k+1];

A. 9 B. 18 C.19 D.21

51107若有定义int a[2][3];则合法引用数组元素的是（ A ）。 A. a[0][1/2] B. a[2][1] C.a[2][3] D.a[1][3] 51108在以下数组定义中，错误的是（ A ）。 A. int a[2][]={1,2,3,4,5}; B. int a[][2]={{0},{1}}; C.int a[2][2]={{1,2},{3}}; D.int a[][2]={1,2,3,4};

51109若定义int a[][4]={1,2,3,4,5,6,7,8};则表达式sizeof(a[0][1])的值为（D ）。 A. 1 B. 2 C.3 D.4

51110以下程序段运行后s的值是（ C ）。 int a[3][3]={1,2,3,4,5,1,2,3,4}; int i,j,s=1;

for(i=0;i<3;i++) for(j=i+1;j<3;j++) s+=a[i][j];

A. 6 B. 120 C.7 D.240

51111设已定义: int a[][4]={0,0,0}; 则下列描述正确的是（ C ）。 A. 数组a包含3个元素 B. 数组a的第一维大小为3 C.数组a的行数为1 D.元素a[0][3]的初值不为0

51112在C语言中，若定义二维数组a[2][3]，设a[0][0]在数组中位置为1，则a[1][1]在数组中位置是（ C ）。 A. 3 B. 4 C.5 D.6

51113以下程序段的运行结果是（ A ）。 int t[][3]={1,2,3,4,5,6,7,8,9,10,11,12}; printf(\ A. 5 B. 3 C.4 D.6

51114以下程序段运行后s的值是（ B ）。 int a[3][3]={1,2,3,1,2,3,1,2,3}; int i,j,s=0;

for(i=0;i<3;i++) for(j=i;j<3;j++) s+=a[i][j];

A. 13 B. 14 C.15 D.12

51115以下（C ）对二维数组arr的初始化是错误的。

A. int arr[2][3]={{1,2},{3,4}}; B. int arr[][3]={1,2,3,4,5}; C.int arr[2][3]={{1,2},{3,4},{5,6}}; D.int arr[2][3]={{1},{3,4,5}};

51116若有定义：int a[3][4]={{1,2},{3,4},{5,6,7}}; ，则a[1][1]的值为（A ）。 A. 4 B. 2 C.1 D.3

51117若有定义：int a[3][2]; ，则表达式&a[2][1]-a的值为（ A ）。 A. 5 B. 4 C.3 D.2

51118以下程序段运行后x的值为（ C ）。 int i=0,x=0;

int a[3][3]={1,2,3,4,5,6,7,8,9}; for (;i<3;i++) x+=a[i][i];

A. 0 B. 12 C.15 D.18

51200设有下列语句，则（ D ）是对a数组元素的不正确引用，其中0≤i<10。 int a[10]={0,1,2,3,4,5,6,7,8,9}, *p=a;

A. a[p-a] B. *(&a[i]) C.p[i] D.*(*(a+i))

51201设已定义: char s1[8],s2[8]=\能将字符串\赋给数组s1的语句是（ C ）。

A. s1=s2; B. strcpy(s2,s1); C.strcpy(s1,s2); D.s1=\51202以下程序段的运行结果是（ A ）。 char str[3][2]={ 'a', 'b', 'c', 'd', 'e', 'f'}; str[2][0]= '\\0'; printf(\

A. abcd B. ab C.abcd0 D.abcd0f

51203有如下定义：char str[10]={ \ 则分配给数组str的存储空间是（ B ）个字节。

A. 11 B. 10 C.9 D.8

51204以下程序段运行后输出结果是（ C ）。 char a[]=\ char b[]=\ strcpy(a,b);

printf(\

A. n B. u C.e D.m

51205以下程序段运行后输出结果是（ A ）。 char s[]=\ printf(\ A. 4 B. 5 C.8 D.9

51206以下程序段运行后a的值为（ D ）。 int a=2;

char *s1=\ a=strcmp(s1,s2);

A. -1 B. 2 C.1 D.0

51207以下对C语言字符数组描述中,错误的是（ B ）。

A. 可以用strlen函数计算字符数组中字符串的长度 B. 可以在赋值语句中通过赋值运算符\对字符数组整体赋值

C.存放在字符数组中的字符串，以'\\0'作为该字符串结束标志 D.字符数组可以存放字符串或字符

51208以下程序段运行后,屏幕的输出结果是（ B ）。 char str[80];

strcpy(str,\printf(\ A. 7 B. 8 C.9 D.80

51209若有定义：char str1[6]=\ABCDE\（ C ）是错误的。 A. strcpy(str2,str1); B. 表达式strcmp(str1,str2)的值小于0 C.str1=str2; D.表达式strlen(str1)的值为5

51210已有定义 char str1[15]={\ 则语句用法正确的是（ C ）。 A. str2=str1; B. str2=\ C.scanf(\ D.printf(\

51211设已定义: char str1[20]=\\d!\ 若要形成字符串\world!\正确语句是（ B ）。

A. strcpy(str1,str2); B. strcat(str1,str2); C.strcpy(str2,str1); D.strcat(str2,str1); 51212若有字符数组a[80]和b[80]，则以下输入语句正确的是（ C ）

A. gets(a,b) B. scanf(\ C.scanf(\ D.gets(\51213若有定义：char str1[10],str2[10]=\，能将字符串\赋给数组str1的正确语句是（ B ）。

A. str1=\ B. strcpy(str1,str2); C.strcpy(str2,str1); D.strcopy(str1,str2); 51214以下程序段的运行结果是（ D ）。 char str[3][2]={ 'a','b','c','\\0','e','f'}; printf(\

A. a B. abcef C.abc\\0ef D.abc 51215以下程序段的运行结果是（ C ）。 char str[]={ \ printf(\ A. 9 B. 7 C.6 D.8

51216以下程序段的运行结果是（ B ）。 char a[]=\ char b[]=\ strcpy(a,b);

printf(\

A. c B. z C.b D.y

51217以下程序段的运行结果是（ B ）。 char a[]=\ char b[]=\ char c[10]; strcpy(c,a); strcat(c,b); printf(\

A. abc B. abc xyz C.xyz D.xyzabc

51218以下程序段运行后a的值为（ B ）。 int a=2;

a=strcmp(\ A. 1 B. 0 C.-1 D.true

51300设有下列语句：

char str1[]=\

则（ A ）是对库函数strcpy的不正确调用。此函数用来复制字符串。 A. strcpy(str3,\ B. strcpy(str2,\C.strcpy(str1,\ D.strcpy(str4,\

51301用数组名作为函数的实参时,错误的说法是（ A ）。

A.定义形参数组时，元素的个数必须与实参相同 B. 可以使用数组名作为形参 C.实参传递给形参的值是数组的首地址 D.可以使用指针变量作为形参 51302以下程序的运行结果是（ D ）。 int fun(int a[4][4]) { int i;

for(i=0;i<4;i++) printf(\ printf(\ } main()

{ int a[4][4]={1,1,2,2,1,9,0,0,2,4,0,0,0,5,9,8}; fun(a); }

A. 1 9 0 5 B. 2 0 0 0 C.2 0 0 8 D.2 0 0 9

51303自定义函数中若缺省函数值类型,则隐含的类型是（ A ）。 A. int B. long C.float D.double 51304以下程序运行后输出结果是（ C ）。 #include int fun(int a, int b) { return(a-b); } main() { int x=5,y=3,k; k=fun(x,y);

printf(\ } A. 0 B. x-y=2 C.5-3=2 D.2 51305以下程序运行后输出结果是（ D ）。 #include int a=2,b=3,c=5; int fun(int a, int b) { int c; c=a>b?a:b; return(c); } main() {

int a=6;

printf(\ } A. 5 B. 3,5 C.6,5 D.6

51306以下程序运行后输出结果是（ c ）。 void fun(int i) { int m=2; m=i++;

printf(\ \ } main()

{ int m=7,n=5; fun(n);

printf(\ }

A. 5 5 B. 6 6 C.5 7 D.6 7 51307若有函数定义： int func()

{static int m=0; return m++; }

以下程序段运行后屏幕输出为（ C ）。 int i;

for(i=1;i<=4;i++) func();

printf(\ A. 0 B. 1 C.4 D.5

51308下面程序的输出结果是（ B ）。 #include int num=10; func()

{int num=4;

return ++num; } void main()

{ printf(\ } A. 4 B. 5 C.10 D.1

51309下列关于C语言函数的描述中，错误的是（ A ）。 A. 函数的定义可以嵌套，但函数的调用不可以嵌套 B. 凡不加类型说明的函数，其返回值默认为整型

C.函数的返回值可以通过函数中的return语句获得 D.可以定义有参函数，也可以定义无参函数 51310以下程序的运行结果是（ B ）。 func(int a,int b) {int c;

c=(a>b)?(a-b):(a+b); return(c); }

main()

{int x=7,y=3;

printf(\ } A. 3 B. 4 C.7 D.10

51311以下程序运行结果是（ B ）。 void main( )

{int max(float a,float b); float x,y; int z;

x=-4.6; y=-3.7; z=max(x,y);

printf(\ } int max(float a,float b) {float c;

if(a>b) c=a;

else c=b; return (c); }

A. -3.7 B. -3 C.-4.6 D.-4

51312下面函数调用语句含有实参的个数为（ A ）。 temp((a,b,c),(x,y)) A. 2 B. 3 C.4 D.5

51313C语言中，数组名作为函数调用的实参时，下面叙述正确的是（ D ）。 A. 传递给形参的是数组元素的个数 B. 传递给形参的是数组第一个元素的值 C. 传递给形参的是数组中全部元素的值

D. 形参数组中各元素值的改变会使实参数组相应元素的值同时发生变化 51314以下程序的运行结果是（ A ）。 int fun(int array[3][3]) { int j;

for(j=0;j<3;j++) array[1][j]++; printf(\ } main()

{ int j,a[3][3]={0,1,2,1,0,4,2,4,5}; fun(a);

for(j=0;j<3;j++) printf(\ printf(\ } A. 2 1 5 B. 1 0 4 C.0 1 2 D.1 2 3

51315C语言中，若缺省定义函数返回值类型，则该函数默认返回值类型是（ C ）。 A. void B. long C.int D.double 51316以下程序的运行结果是（ B ）。 int f(int c) { c+=2;

return c ; } main()

{ int a=2,c=5; a=f(a);

printf(\ %d \\n\ }

A. 4 4 B. 4 5 C.2 4 D.2 5 51317以下程序的运行结果是（ C ）。 int a=2,b=3;

int min(int a,int b) { int c; c=a

{ int a=4;

printf(\ } A. 2,3 B. 2 C.3 D.4

51318以下程序的运行结果是（ B ）。 fun()

{ static int a=0; a++;

printf(\ \ } main() { int i;

for(i=1;i<=2;i++) fun(); }

A. 1 1 B. 1 2 C.0 0 D.0 51400以下程序的运行结果是（ C ）。 fun3(int x)

{ static int a=3; a+=x; return a; } main()

{ int k=2,m=1,n; n=fun3(k); n=fun3(m);

printf(\ }

A. 3 B. 4 C.6 D.9

51401以下程序运行后输出结果是（ D ）。 #define F(m,n) m*n main( )

{ int x=5,y=3,a1,a2;

a1=F(x+y,x-y); a2=F(x-y,x+y);

printf(\ }

A. 16,16 B. 16,-16 C.-7,17 D.17,-7

51402以下叙述正确的是（ C ）。

A. 编译预处理命令行必须以分号结束

B. 程序中使用带参数的宏时，参数类型要与宏定义时一致

C.宏展开不占用运行时间，只占用编译时间 D.宏名只能包含大写字母和数字字符 51403以下叙述正确的是（ B ）。

A. 一个源程序只能有一个编译预处理命令行 B. 编译预处理命令行都必须以\开头 C.\定义了与30等价的符号常量PRICE D.使用带参数的宏定义时，应该说明每个参数的数据类型

51404以下叙述错误的是（ D ）。

A. 编译预处理命令行都必须以#号开始 B. 宏名可以用小写字母表示

C. 使用预处理命令\<文件名>\时，编译系统只在指定的系统目录下查找该文件 D. 宏定义只能放在main()函数之前

51405若有定义:#define N 3+2,则表达式N*2的值为（ B ）。 A. 5 B. 7 C.10 D.0

51406以下程序运行后输出结果是（ C ）。 #define MIN(m,n) m

{ int a=3,b=5,c; c=2*MIN(a,b); printf(\ }

A. 3 B. 5 C.6 D.10

51407下列#include命令中,正确的是（ A ）。

A. #include \ B. #include [math.h] C.#include (math.h) D.#include {math.h} 51408下面程序的输出结果是（ C ）。 #include #define MON 1

#define TUE 2*MON #define WED 3*TUE void main()

{printf(\ } A. 2 B. 3 C.4 D.5

51409下面错误的叙述是（ A ）。

A. 预处理命令行必须位于C源程序的起始位置 B. 在C语言中，预处理命令行都以\开头

C.C程序在开头可以不包含预处理命令行：#include

D.C语言的预处理可以实现宏定义和条件编译的功能 51410以下程序的运行结果是（ B ）。 #define MUL(r) r*r main()

{int a=2,b=3,c; c=MUL(a+b)*2; printf(\ }

A. 10 B. 14 C.36 D.50

51411下面程序的运行结果是（ C ）。 #define N 10

#define K(x) x*x #define T(x) (x*x) main( )

{int a,b; a=9%K(N); b=9%T(N); printf(\ } A. 9,9 B. 9,90 C.90,9 D.90,90

51412以下在任何情况下计算平方数时都不会引起二义性的宏定义是（ D ）。 A. #define XPF(x) x*x B. #define XPF(x) (x)*(x) C.#define XPF(x) (x*x) D.#define XPF(x) ((x)*(x)) 51413以下程序的运行结果是（ C ）。 #define X a+b main( )

{ int a=3,b=4,s1; s1=2*X;

printf(\ }

A. 14 B. 6 C.10 D.8

51414下面叙述错误的是（ C ）。

A. “#define PRICE 30”命令的作用是定义一个与30等价的符号常量PRICE B. 预处理命令行都必须以“#”开头 C.预处理命令行必须以分号结束

D.C源程序中加入一些预处理命令是为了改进程序设计环境，提高编程效率 51415下面叙述正确的是（ A ）。

A. 宏展开不占用运行时间，只占用编译时间 B. 预处理命令也是C语句，必须以分号结束

C.一个源程序只能有一个预编译处理命令行 D.宏名必须用大写字母表示

51416下面叙述错误的是（ D ）。

A. “#inclue ”命令的作用是在预处理时将stdio.h文件中的实际内容代替该命令 B. “#define PRICE 30”命令的作用是定义一个与30等价的符号常量PRICE C.C源程序中加入一些预处理命令是为了改进程序设计环境，提高编程效率 D.宏定义也是C语句，必须在行末加分号

51417若有定义：#define PI 3，则表达式PI*2*2的值为（ A ）。 A. 12 B. 4 C.322 D.不确定

51418若有定义：#define F 2+3，则表达式F*F的值为（ C ）。 A. 25 B. 13 C.11 D.17

51500下程序的运行结果是（ A ）。 void ast (int x,int y,int *cp,int *dp) { *cp=x+y; *dp=x-y; } main()

{ int a=4,b=3,c,d; ast(a,b,&c,&d);

printf(\ }

A. 7,1 B. 1,7 C.7,-1 D.c、d未赋值，编译出错

51501有以下语句： int a[5]={0,1,2,3,4},i; int *p=a; 设0≤i＜5，对a数组元素不正确的引用是（ C ）。

A. *(&a[i]) B. a[p-a] C.*(*(a+i)) D.p[i]

51502若有定义int *p1,*p2; 则错误的表达式是（ A ）。 A. p1+p2 B. p1-p2 C.p1

51503以下叙述错误的是（ D ）。

A. 存放地址的变量称为指针变量 B. NULL可以赋值给任何类型的指针变量

C.一个指针变量只能指向类型相同的变量 D.两个相同类型的指针变量可以作加减运算 51504以下程序段运行后，表达式*(p+4)的值为（ B ）。 char a[]=\ char *p; p=a;

A. 'n' B. 'a' C.存放'n'的地址 D.存放'a'的地址 51505以下程序段运行后，表达式*(p++)的值为（ A ）。 char a[5]=\ char *p=a;

A. 'w' B. 存放'w'的地址 C.'o' D.存放'o'的地址

51506若有定义: int *p,k=4; p=&k; 以下均代表地址的是（ C ）。 A. k, p B. &k, &p C.&k, p D.k, *p

51507若有定义：double *q,p;则能给输入项读入数据的正确程序段是（ B ）。 A. q=&p;scanf(\ B. q=&p;scanf(\C.*q=&p;scanf(\ D.*q=&p;scanf(\

51508若已定义: int q=5; 对① int *p=&q;和② p=&q; 这两条语句理解错误的是（ C ）。 A. ①是对p定义时初始化,使p指向q;而②是将q的地址赋给p B. ①和②中的&q含义相同,都表示给指针变量赋值

C. ①是对p定义时初始化,使p指向q;而②是将q的值赋给p所指向的变量 D. ①和②的执行结果都是把q的地址赋给p

51509下面语句错误的是（ A ）。

A. int *p; *p=20; B. char *s=\C.char *str=\ D.char *str;str=\

51510若有定义int a[2][3],*p=a;，则能表示数组元素a[1][2]地址的是（ D ）。 A. *(a[1]+2) B. a[1][2] C.p[5] D.p+5

51511若已定义: int a=5,*p; 且 p=&a; 则以下表示中不正确的是（ B ）。 A. &a==&(*p) B. *(&p)==a C.&(*p)==p D.*(&a)==a

51512若有以下程序段，则叙述正确的是（ D ）。 char s[]=\ char *p; p=s; A. s和p完全相同 B. 数组s的长度和p所指向的字符串长度相等 C.*p与s[0]相等 D.数组s中的内容和指针变量p中的内容相等 51513C语言中，二维数组元素在内存中的存放顺序是（A）。

A. 按行存放 B. 按列存放 C.由用户自己定义 D.随机存放

51514若有定义：int *p1,*p2; ，则不能用于指针变量p1、p2之间的运算符是（ C ）。 A. = B. = = C.+ D.-

51515下面叙述错误的是（ C ）。

A. 一个指针变量只能指向同一类型的变量 B. 一个变量的地址称为该变量的指针 C.可以将一个整数值赋给指针变量 D.任何指针变量都可以与空指针NULL进行比较 51516以下程序段运行后*(p+1)的值为（ A ）。 char a[]=\ char *p; p=a; A. 'o' B. 'g' C.a[1]的地址 D.不确定

51517以下程序段运行后*(p++)的值为（ A ）。 char a[5]=\ char *p; p=a; A. 'w' B. a[0]的地址 C.'o' D.a[1]的地址

51518若有定义：int a=4,*p=&a; ，则以下（ B ）均表示地址。 A. a,p B. &a,p C.&a,*p D.a,*p

51600以下程序段的运行结果是（ B ）。 enum weekday{ aa,bb=2,cc,dd,ee }week=ee; printf(\

A. ee B. 5 C.2 D.4

51601若有以下程序段，则不能正确访问数组元素a[1][2]的是（ A ）。 int (*p)[3]; int a[][3]={1,2,3,4,5,6,7,8,9}; p = a;

A. p[1]+2 B. p[1][2] C.(*(p+1))[2] D.*(*(a+1)+2)

51602以下程序段的运行结果是（ A ）。 int a[]={1,2,3,4,5,6,7},*p=a; int n,sum=0; for(n=1;n<6;n++) sum+=p[n++]; printf(\ A. 12 B. 15 C.16 D.27

51603下面程序的运行结果是（ A ）。 main( ) { int a,b; int *p1=&a,*p2=&b,*t; a=10; b=20; t=p1; p1=p2; p2=t; printf(\ } A. 10,20 B. 20,10 C.10,10 D.20,20 51604以下程序段运行后变量s的值为（ C ）。 int a[]={1,2,3,4,5,6,7};

int i, s=1,*p; p=&a[3];

for(i=0;i<3;i++) s*=*(p+i);

A. 6 B. 60 C.120 D.210

51605以下程序段运行后变量ans的值为（ B ）。 int a[]={1,2,3},b[]={3,2,1}; int *p=a,*q=b; int k,ans=0;

for(k=0;k<3;k++) if(*(p+k)==*(q+k)) ans=ans+*(p+k)*2;

A. 2 B. 4 C.6 D.12

51606以下程序运行结果是（ A ）。 main( )

{ char a[]=\ for(p=a;p

A. abcbcc B. abc C.cbabaa D.cba

51607以下程序的输出结果是（ B ）。 #include void main() {int i;

char *s=\ for(i=0;i<3;i++)

printf(\ }

A. CD BCD ABCD B. ABCD BCD CD C.AB ABC ABCD D.ABCD ABC AB 51608以下程序的输出结果是（ B ）。 #include void main()

{char *p=\ printf(\ } A. A B. B C.C D.D

51609下面程序执行时，若输入5 4 3 2 1<回车>，则输出为：（ B ） #include #define N 5 void main() {int a[N]; int *p=a;

while(p

while(p>a)

printf(\ }

A. 5 4 3 2 1 B. 1 2 3 4 5 C.3 4 5 1 2 D.3 2 1 5 4 51610下面程序段的运行结果是（ C ）。 int a[]={1,2,3,4,5,6},*p=a; int i,sum=0;

for(i=1;i<6;i++) sum+=*(p++); printf(\

A. 10 B. 12 C.15 D.20

51611下面程序运行结果是（ D ）。 main( )

{ int a[]={1,2,3,4,5},*p,*q,i; p=a; q=p+4; for(i=1;i<5;i++)

printf(\ }

A. 24334251 B. 51423324 C.15243342 51612下面程序运行结果是（ B ）。 main( )

{ static char a[]=\ char *p=a,*q=b; int i;

for(i=0;i<=6;i++)

if(*(p+i)==*(q+i)) printf(\ }

A. geca B. aceg C.bdf D.fdb 51613以下程序段的运行结果是（ B ）。 int x[3]={1,2,3}; int *p; p=x;

for(p++;p<&x[2];p++) printf(\ \

A. 3 B. 2 C.1 2 D.2 3

51614以下程序段的运行结果是（ B ）。 int x[]={2,3,4,5,6,7},*p=x; int i,s=0;

for(i=1;i<5;i++) s+=p[i++]; printf(\

A. 14 B. 8 C.6 D.20

51615以下程序的运行结果是（ C ）。 main( ) { int x,y;

D.42332415

int *p,*q,*t; x=23; y=45; p=&x;

q=&y; t=p; p=q; q=t;

printf(\ }

A. 23,23 B. 45,45 C.23,45 D.45,23 51616以下程序段运行后x的值为（ C ）。 int a[]={1,2,3,4,5,6,7,8}; int i,x,*p; x=1; p=&a[1];

for(i=0;i<3;i++) x*=*(p+i);

A. 1 B. 6 C.24 D.120

51617以下程序段运行后x的值为（ C ）。 int a[]={1,2,3},b[]={4,3,3}; int *p,*q; int i,x; p=a; q=b;

for(i=0;i<3;i++) if(*(p+i)==*(q+i)) x=*(p+i)*2;

A. 2 B. 4 C.6 D.不确定

51700若定义如下结构，则能打印出字母M的语句是（ B ）。 struct person{ char name[9]; int age; };

struct person class[10]={\ A. printf(\ B. printf(\C.printf(\ D.printf(\51701以下程序段的运行结果是（ D ）。 union { int n;

char str[2]; }t; t.n=80;

t.str[0]='a';

t.str[1]=0; printf(\

A. 80 B. a C.0 D.97

51702一个结构体变量占用的内存大小是（ B ）。

A. 占内存容量最大的成员所需容量 B. 各成员所需内存容量之和 C. 第一个成员所需内存容量 D. 最后一个成员所需内存容量 51703以下程序段的运行结果是（ C ）。 union { int x; float y;

char c; }m,n; m.x=5; m.y=7.5; m.c='A'; n.x=8;

printf(\

A. 5 B. 7.5 C.65 D.8

51704若有定义: struct student {int num; char name[8]; char sex; float score; }stu1; 则变量stu1所占用的内存字节数是（ A ）。 A. 15 B. 16 C.8 D.19

51706若有定义: struct stuent {int num; char sex; int age; }stu1; 下列叙述不正确的是（ B ）。

A. student是结构体类型名 B. struct student是结构体类型名

C.stu1是用户定义的结构体类型变量名 D.num,sex,age都是结构体变量stu1的成员 51707下面程序的运行结果是（ A ）。 #include union data { int i; char c;

double d; }a[2]; void main()

{printf(\ } A. 16 B. 8 C.4 D.2

51708下面程序的运行结果是（ B ）。 #include union data {int i;

char c; }; struct

{char a[2]; int i;

union data d; }p; void main()

{printf(\ } A. 5 B. 6 C.7 D.8

51709以下C语言共用体类型数据的描述中，正确的是（ C ）。 A. 共用体变量占的内存大小等于所有成员所占的内存大小之和 B. 共用体类型不可以出现在结构体类型定义中

C. 在定义共用体变量的同时允许对第一个成员的值进行初始化 D. 同一共用体中各成员的首地址不相同

51710设有如下语句： struct stu {int num;

int age; };

struct stu s[3]={{101,18},{102,21},{103,19}}; struct stu *p=s;

则下面表达式的值为102的是（ B ）。

A. (p++)->num B. (*++p).num C.(*p++).num D.*(++p)->num 51711若有下面定义,能打印出字母'L'的语句是（ A ）。 struct class

{char name[8]; int age; };

struct class s[12]={\ A. printf(\ B. printf(\C.printf(\ D.printf(\

51712若有下面定义,对结构体变量成员不正确引用的语句是（ B ）。 struct pup

{char name[20]; int age;

int sex; }p[3],*q; q=p;

A. scanf(\ B. scanf(\ C.scanf(\ D.scanf(\51713以下程序段的运行结果是（ B ）。 union

{ int num1; int num2; }s; s.num1=20; s.num2=30;

printf(\

A. 20 B. 30 C.50 D.2030 51714若有定义： struct data { char a;

float b[3];

long c; }d1; 则变量d1的长度是（ D ）。 A. 15 B. 12 C.4 D.17

51715若有定义：union u_type {int x; float y[3]; char z; }a; 则变量a的长度是（ C ）。 A. 1 B. 4 C.12 D.15

51716若有定义: struct teacher {int num; char name[10]; char sex; int age; }t1={2001,\ 则下列（ A ）对结构变量引用是正确的。 A. t1.name B. t1->name C.t1.name[0] D.t1->name[0]

51717下列（ C ）对结构类型变量定义是错误的。

A. struct teacher {int num; int age; }teach1; B. struct {int num; int age; }teach1,teach2;

C.struct {int num; int age; }teacher; struct teacher teach1; D.struct teacher {int num; int age; }; struct teacher teach1;

51718若有定义： struct teacher {int num; char sex; int age; }teacher1; 则下面叙述错误的是（ D ）。

A. struct是结构类型的关键字 B. struct teacher是用户定义的结构类型 C.num、sex、age都是结构变量teacher1的成员 D.teacher1是结构类型名

51801若有以下定义： struct node { int data; struct node *next; }; struct node *p; 已建立如下图所示的链表：p → data│next┼→ data│next┼→...─→ data│NULL│ 指针p指向第一个结点,能输出链表所有结点的数据成员data的循环语句是（ D ）。 A. while(p!=NULL) { printf(\ p++; } B. while(p) { printf(\ p=p->next; } C.for( ; p!=NULL; p++) printf(\ D.for( ; p; p=p->next) printf(\

51802若有以下定义： struct node { int data; struct node *next; } struct node m,n,k, *head, *p; 已建立如下图所示的链表：

m n k head →│data│next┼→│data│NULL│ p →│data│next│ 指针head指向变量m, m.next指向变量n，p指向变量k，不能把结点k插到m和n之间形成新链表的程序段是（ A ）。

A. m.next = p; p->next = head->next; B. (*head).next = p; (*p).next = &n; C.head->next = &k; p->next = head->next; D.m.next = &k; k.next = &n;

51803若有以下定义： struct node { int data; struct node *next; } struct node *head,*p; 已建立如下图所示的链表: p↓ head →│data│next┼→│data│next┼→...─→│data│NULL│ 能删除指针p所指向结点的程序段是（ C ）。

A. p = p->next; head->next=p->next; free(p); B. free(p); p = p->next; head->next=p->next; C.head->next = p->next; free(p); D. free(p); head->next = p->next;

51804若有以下定义： struct node { int data; struct node *next; } *p,*q; 已建立如下图所示的链表： ... p →│data│next┼→│data│NULL│ q →│data│next│ 不能将指针q所指结点连到上图所示链表末尾的语句是（ D ）。

A. q->next=NULL; p=p->next; p->next=q; B. p=p->next; p->next=q; q->next=NULL; C.p=p->next; q->next=p->next; p->next=q; D.q->next=p->next; p=p->next; p->next=q; 51805若有定义： struct node { int data; struct node *next; }; 已建立如下图所示的链表： head →│1 │ ┼→│3 │ ┼→ ? →│25│ ┼→NULL 指针head指向链表首结点，以下函数的功能是（ B ）。 void fun(struct node * head) { struct node * p = head; while(p) { printf(\ \); p = (*p).next; break; } }

A. 显示并删除单向链表 B. 显示单向链表中的第一个结点的数据

C. 显示单向链表中的所有数据 D.显示单向链表中除第一个结点外的所有数据

51806若有定义： struct node { int data; struct node *next; }; 已建立如下图所示的链表： head →│2 │ ┼→│4 │ ┼→ ? →│28│ ┼→NULL 指针head指向链表首结点，以下函数的功能是（ D ）。 void fun(struct node * head) { struct node * p = head; while(1) { p = p->next; printf(\ \ if(p) break; } }

A. 显示单向链表中第一个结点的数据 B. 显示单向链表中最后一个结点的数据 C.显示单向链表中的所有数据 D.显示单向链表中除第一个结点外的所有数据

51807若按如下定义，则函数link的功能是（ C ）。其中head指向链表首结点，整个链表结构如下图： head →│data│ ┼→│data│ ┼ → ?→│data│NULL│ struct node {int data; struct node *next; }; int link(struct node* head) {int k=1; struct node *p=head; while(p!=NULL) {p=p->next; k++; } return k-1; } A. 删除链表head中的一个结点 B. 插入一个新元素到链表head中 C. 统计链表head中结点的个数 D.创建新链表head

51808若按如下定义，函数link的功能是（ B ）。其中head指向链表首结点，整个链表结构如下图： head →│data│ ┼→│data│ ┼→? →│data│NULL│ struct node {int data; struct node *next; }; void link(struct node* head) {struct node

*p=head; while(p!=NULL) {if(p->data%2==1) printf(\\p->data); p=p->next; } }

A. 计算链表head中结点的个数 B. 遍历链表head,输出表中值为奇数的元素 C. 删除链表head中的所有结点 D. 插入一个新元素到链表head中

51809以下程序的输出结果是（ B ）。 #include #include typedef struct node {int data; struct node *next; }Node; Node

list[4]={{4,&list[1]},{3,&list[2]},{2,&list[3]},{1,0}}; void output(Node *head) {Node *p=head; while(p!=NULL) {printf(\\p->data); p=p->next; } } void main() {output(list); }

A. 1 2 3 4 B. 4 3 2 1 C. 3 2 1 4 D. 2 1 3 4

51810若按以下定义： struct node {int data; struct node *next; } *head, *p; 并已建立如下图所示的链表结构,指针p和q分别指向图中所示结点: p↓ q↓

... →│data│next┼→│data│NULL│ │data│ │ 则可以将指针q所指的结点连接到链表末尾的程序段是（ A ）。

A. q->next=NULL; p=p->next; p->next=q; B. q->next=p->next; p=p->next; p->next=q; C.p=p->next; q->next=p; p->next=q; D.(*q).next=(*p).next; p=(*p).next; (*p).next=q;

51811若有定义： struct node {int data; struct node *next; }; float link(struct

node *head) {int m=0,n=0; struct node *p=head; while(p!=NULL) {m+=p->data; n++; p=p->next; } if(n>0) return 1.0*m/n; else return 0 } 调用link函数时head是指向链表首结点的指针，整个链表结构如下图： head →│data│next┼→│data│next┼→...─→│data│NULL│ 则函数link()的功能是（ B ）。

A. 统计链表head中结点的个数 B. 遍历链表head, 计算表中各结点成员data的平均值 C.遍历链表head，计算表中各结点成员data的总和 D.创建一个新链表head

51812若有以下定义： struct node {int data; struct node *next; } *p,*q,*t; 指针p、t和q分别指向图中所示结点:

p↓ t↓ q↓

│data│next┼→│data│next┼→│data│next┼→... 现要将t和q所指结点的先后位置交换，同时要保持链表的连续，以下错误的程序段是（ C ） A. t->next=q->next;p->next=q;q->next=t; B. p->next=q;t->next=q->next;q->next=t; C.q->next=t;t->next=q->next;p->next=q; D.t->next=q->next;q->next=t;p->next=q; 51813下列程序段运行后，表达式（ B ）的值为3。 struct point { int x; int y; } *p; struct point a[3]={1,2,3,4,5,6}; p=a; A. *(p+2) B. p[1].x C.p[2].x D.p[3].x

51814若有定义：int a[10]={0,1,2,3,4,5,6,7,8,9}, *p=a; ， 则（ D ）表达式是错误的。 A. a[2] B. p++ C.p[2] D.a++

51815下列程序段运行后，（ C ）对数组a元素的引用是错误的。（其中0≤i＜4，0≤j＜3） int i,j,(*p)[3]; int a[][3]={1,2,3,4,5,6,7,8,9,10,11,12}; p = a; A. *(*(a+i)+j) B. p[i][j] C.*(*(p+i)[j]) D.*(p[i]+j)

51816若有定义：int a[3][4]={1,2,3,4,5,6,7,8,9,10,11,12},(*p)[4];p=a; ，（ A ）对数组a元素的引用是正确的。

A. *(p[2]+3) B. **(p+4) C.*(p[4]) D.(**p)[2] 51817（ B ）能正确定义一个指向函数的指针。

A. int *p() B. int (*p)() C.(int *)p() D.int (*p()) 51818以下程序的运行结果是（ A ）。 main()

{ int a[3]={1,2,3}; int *num[3]; int **p,i;

for(i=0;i<3;i++) num[i]=&a[i]; p=num;

printf(\ }

A. 1 B. 3 C.&a[0] D.num

51900以下程序中的循环执行了（ C ）次。 #define N 2 #define M N+1

#define NUM (M+1)*M/2 main()

{ int i,n=0;

for(i=0;i

A. 5 B. 6 C. 8 D. 9

51901错误的枚举类型定义语句是（ B ）。 A. enum car {A, B, C}; B. enum car {1, 2, 3};

C.enum car {X=0, Y=5, Z=9}; D.enum car {D=3, E, F};

51902假定已有如下定义： int k ;

enum colors {red, green, blue, pink} ;

int a[3]; （ B ）是对以下语句是否符合语法规则的正确判断。 a[red]=pink; /* 语句1 */ red=1; /* 语句2 */ k=green+blue; /* 语句3 */

A. 语句1和语句2正确，语句3错误 B. 语句1和语句3正确，语句2错误 C. 语句2和语句3正确，语句1错误 D. 语句1正确，语句2和语句3错误 51904在对无符号数的位运算中，操作数左移三位相当于（ D ）。

A. 操作数除以6 B. 操作数乘以6 C.操作数除以8 D.操作数乘以8 51905以下程序段运行后变量k的值为（ D ）。 int m=7,n=2,k; k=(m^n)<<1; A. 0 B. 98 C.20 D.10

51906若有定义：int m=7,n=10,k; 则执行语句k=m&n;后k的值为（ A ）。 A. 2 B. 1 C.17 D.15

51907以下程序的输出结果为（ B ）。

#include void main() {enum Weekday{sun=7,mon=1,tue,wed,thu,fri,sat}; enum Weekday day=wed; printf(\ } A. 2 B. 3 C.4 D.5

51908若按如下类型说明，则（ B ）是错误的叙述。

typedef struct {int no; char *name; int cj; }S,*p; A. S是一个结构体类型名 B. p是一个结构体类型名

C.p是指向结构体类型S的指针类型名 D.no是结构体类型S的成员

51909下面程序段的运行结果是（ A ）。 int p=7,q=4; printf(\ A. 4 B. 5 C.6 D.7

51910若有以下类型说明,则叙述错误的是（ C ）。

typedef union {char name[10]; int age; }ustu,*umy;

A. umy是指向共用体类型ustu的指针类型名 B. ustu是一个共用体类型名 C.umy是一个共用体类型名 D.age是共用体类型ustu的成员 51911定义枚举类型的关键字是（ C ）。 A. typedef B. include C.enum D.fnum 51912下面程序段的运行结果是（ B ）。 main()

{int a=5,b=3;

printf(\ } A. 0 B. 1 C.2 D.3

51913（ A ）对枚举类型的定义是错误的。

A. enum b{1, 2, 3}; B. enum a{A, B, C}; C.enum c{D=3, E, F}; D.enum d{X=0, Y=5, Z=9}; 51914若有定义：enum day{sun,mon, tue, wed, thu, fri, sat} ; ，则枚举常量sun、mon的值分别为（A ）。

A. 0 1 B. 7 1 C. 1 2 D. 7 0

51915若有定义： typedef int * INTEGER; INTEGER p; 则下面叙述正确的是（ C ）。 A. p是与INTERGE相同的类型 B. p是一个整形变量

C.程序中可用INTEGER定义int类型指针变量 D.程序中可用INTEGER定义int类型变量 51918若有定义：enum num{a1,a2=3,a3,a4=10} ; ，则枚举常量a2、a3的值分别为（ D ）。 A. 1 2 B. 2 3 C. 3 3 D. 3 4

52000以下程序的功能是（ C ）。 #include main()

{ FILE *fp; long int n;

fp=fopen(\ fseek(fp,0,SEEK_END); n=ftell(fp); fclose(fp);

printf(\ }

A. 计算文件wj.txt的起始地址 B. 计算文件wj.txt的终止地址 C.计算文件wj.txt的长度 D.将文件指针定位到文件末尾

52002文本文件quiz.txt的内容为\不包含引号)，以下程序段的运行结果是（ B ）。 FILE *fp; char *str;

if((fp=fopen(\ str=fgets(str,7,fp); printf(\

A. Progr B. Progra C.Program D.Programming 52004下面程序的运行结果是（ B ）。 #include main()

{ FILE *fp;

int a=2,b=4,c=6,k,n;

fp=fopen(\ fprintf(fp,\

fprintf(fp,\ %d\\n\ fclose(fp);

fp=fopen(\

fscanf(fp,\ printf(\ %d\\n\ fclose(fp); }

A. 2 4 B. 2 6 C. 4 2 D. 6 2

52005对于以下程序，说法正确的是（ B ）。 #include main()

{ FILE *fp;

fp=fopen(\ if(fp!=NULL)

{ fprintf(fp,\ fclose(fp);

printf(\ } }

A. 程序运行后，当前工作目录下存在quiz.txt文件,其中的内容是\ B. 程序运行后，当前工作目录下存在quiz.txt文件,其中的内容是\C.程序运行之前，当前工作目录下一定不存在quiz.txt文件 D.程序运行之前，当前工作目录下一定存在quiz.txt文件 52006以下程序运行后，文件test.txt的内容是（ B ）。 #include main()

{ FILE *fp;

char str[][10]={\ fp = fopen(\ if(fp!=NULL)

fprintf(fp,\ fclose(fp);

fp = fopen(\ if(fp！=NULL)

fprintf(fp,\ fclose(fp); }

A. first B. second C.first second D.second first

本文来源：https://www.bwwdw.com/article/k0lg.html