C语言题库及答案(选择题)

C语言题库（选择题）

1.C语言源程序的基本单位是（）。

A.过程 B.函数 C.子程序 D.标识符

2.

下列字符序列中，可用作C标识符的一组字符序列是（）。

A. S.b，sum，average，_above

B. class，day，lotus_1，2day

C. #md，&12x，month，student_n!

D. D56，r_1_2，name，_st_1

3.

以下标识符中，不能作为合法的C用户定义标识符的是（）。

A.a3_b3 C._123

4.

以下数据中，不正确的数值或字符常量是（）。

A.0 B.5L C.o13 D.9861

5.以下数值中，不正确的八进制数或十六进制数是（）。

A.0x16 B.16 C.-16 D.0xaaaa

6.以下的选择中，正确的赋值语句是（）。

A.a=1,b=2 B.j++ C.a=b=5; D.y=int(x)

7.以下运算符中，优先级最高的运算符是（）。

A.?: B.++ C.&& D.,

8.在C语言中，能代表逻辑值“真”的是（）。

B.大于0的数 C.非0整数 D.非0的数

9.下列变量说明语句中，正确的是（）。

:a b c; a;b;c; x;z; x,z;

10.下列字符序列中，不可用作C语言标识符的是（）。

A.b70 B.#ab D.a_1

11.以下不正确的叙述是（）。

A.在C程序中所用的变量必须先定义后使用。

B.程序中，APH和aph是两个不同的变量。

C.若a和b类型相同，在执行了赋值语句a=b；后b中的值将放入a中，b中的值不变。

D.当输入数值数据时，对于整型变量只能输入整型值；对于实型变量只能输入实型值。

12.以下标识符中，不能作为合法的C用户定义标识符的是（）。

13.以下标识符中，不能作为合法的C用户定义标识符的是（）。

D._if

14.以下标识符中，不能作为合法的C用户定义标识符的是（）。

r B._double C._123

15.以下数据中，不正确的数值或字符常量是（）。

A.8.9e1.2 B.10 C.0xff00 D.82.5

16.以下数据中，不正确的数值或字符常量是（）。

A.c B.66 C.0xaa D.50

17.以下运算符中，优先级最高的运算符是（）。

- 1 -

A.*= B.>= C.(类型) D.+

18.以下运算符中，优先级最高的运算符是（）。

A.|| B.% C.! D.==

19.以下运算符中，优先级最高的运算符是（）。

A.= B.!= C.*(乘号) D.()

20.以下叙述中不正确的是（）。

A.一个好的程序应该有详尽的注释

B.在C程序中，赋值运算符的优先级最低

C.在C程序中，j++;是一条赋值语句

D.C程序中的#include和#define均不是C语句

21.设C语言中，int类型数据占2个字节，则long类型数据占（）。

A.1个字节 B.2个字节 C.4个字节 D.8个字节

22.设C语言中，int类型数据占2个字节，则short类型数据占（）。

A.1个字节 B.2个字节 C.4个字节 D.8个字节

23.C语言中，double类型数据占（）。

A.1个字节 B.2个字节 C.4个字节 D.8个字节

24.C语言中，char类型数据占（）。

A.1个字节 B.2个字节 C.4个字节 D.8个字节

25.设C语言中，int类型数据占2个字节，则unsigned类型数据占（）。

A.1个字节 B.2个字节 C.4个字节 D.8个字节

26.下列程序的输出结果是（）。

main()

{char c1=97,c2=98;

printf("%d %c",c1,c2);

}

A.97 98 B.97 b C.a 98 D.a b

27.执行下列语句后变量x和y的值是（）。

y=10;x=y++;

A.x=10,y=10 B.x=11,y=11 C.x=10,y=11 D.x=11,y=10

28.下列数据中，为字符串常量的是（）。

A. A B."house" do you do. D.$abc

29.先用语句定义字符型变量c，然后要将字符a赋给c，则下列语句中正确的是

A.c='a'; B.c="a"; C.c="97"; D.C='97'

30.下列语句的结果是（）。

main()

{ int j;

j=3;

printf("%d,",++j);

printf("%d",j++);

}

A.3,3 B.3,4 C.4,3 D.4,4

31.设a=12，且a定义为整型变量。执行语句a+=a-=a*=a;后a的值为（）。

A.12 B.144 C.0 D.132

32.已知year为整型变量，不能使表达式（year%4==0&&year%100!=0）- 2 -

||year%400==0的值为“真”的数据是（）。

A.1990 B.1992 C.1996 D.2000

33.下列运算符中，不属于关系运算符的是（）。

A.< B.> C.>= D.!

34.假设所有变量均为整型，表达式:a=2,b=5,a>b?a++:b++,a+b的值是（）。

A.7 B.8 C.9 D.2

35.以下不符合C语言语法的赋值语句是（）。

A.a=1,b=2 B.++j; C.a=b=5; D.y=(a=3,6*5);

36.以下不符合C语言语法的语句是（）。

A.j++; B.j=j=5; C.k=2*4,k*4; D.y=float(j);

37.执行下列程序后，其输出结果是（）。

main()

{int a=9;

a+=a-=a+a;

printf("%dn",a);

}

A.18 B.9 C.-18 D.-9

38.下列语句的输出结果是（）。

printf("%dn",(int)(2.5+3.0)/3);

A.有语法错误不能通过编译 B.2 C.1 D.0

39.下列程序的输出结果是（）。

main()

{int a=7,b=5;

printf("%dn",b=b/a);

}

A.0 B.5 C.1 D.不确定值

40.下列程序的输出结果是（）。

main()

{int a=011;

printf("%dn",++a);

}

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

41.下列程序的输出结果是（）。

main()

{

printf("%dn",null);

}

A.0 B.变量无定义 C.-1 D.1

42.若int类型数据占两个字节，则下列语句的输出为（）。

int k=-1; printf("%d,%un",k,k);

A.-1,-1 B.-132,767 C.-132,768 D.-165,535

43.若k,g均为int型变量，则下列语句的输出为（）。

k=017; g=111; printf("%dt",++k); printf("%xn",g++);

A.15 6f B.16 70 C.15 71 D.16 6f

- 3 -

44.若k为int型变量，则以下程序段的执行结果是（）。

k=-8567; printf("|%06D|n",k);

A.格式描述符不合法,输出无定值

B.输出为|%06D|

C.输出为|0-8567|

D.输出为|-8567|

45.若ch为char型变量，k为int型变量（已知字符a的ASCII十进制代码为97），

则以下程序段的执行结果是（）。

ch='a'; k=12; printf("%x,%o,",ch,ch,k); printf("k=%%dn",k);

A.因变量类型与格式描述符的类型不匹配，输出无定值

B.输出项与格式描述符个数不符，输出为零值或不定值

C.61,141,k=%d

D.61,141,k=%12

46.若有以下定义：char s='092'; 则该语句（）。

A.使s的值包含1个字符

B.定义不合法，s的值不确定

C.使s的值包含4个字符

D.使s的值包含3个字符

47.若a是float型变量，b是unsigned型变量，以下输入语句中合法的是（）。

("%6.2f%d",&a,&b); ("%f%n",&a,&b);

("%f%3o",&a,&b); ("%f%f",&a,&b);

48.已知字母a的ASCII十进制代码为97，则执行下列语句后的输出结果为（）。

char a='a'; a--;

printf("%d,%cn",a+'2'-'0',a+'3'-'0');

A.b,c B.a--运算不合法,故有语法错

C.98,c D.格式描述和输出项不匹配,输出无定值

49.下列程序的输出结果为（）。

main()

{int m=7,n=4;

float a=38.4,b=6.4,x;

x=m/2+n*a/b+1/2;

printf("%fn",x);

}

A.27 B.27.5 C.28 D.28.5

50.若给定条件表达式(M)?(a++):(a--)，则其中表达式M（）。

A.和(M==0)等价 B.和(M==1)等价 C.和(M!=0)等价 D.和(M!=1)等价

51.以下程序的输出结果是（）。

main()

{int i,j,k,a=3,b=2;

i=(--a==b++)?--a:++b;

j=a++;k=b;

printf("i=%d,j=%d,k=%dn",i,j,k);

}

A.i=2,j=1,k=3 B.i=1,j=1,k=2 C.i=4,j=2,k=4 D.i=1,j=1,k=3

- 4 -

52.a,b为整型变量，二者均不为0，以下关系表达式中恒成立的是（）。

A.a*b/a*b==1 B.a/b*b/a==1 C.a/b*b+a%b==a D.a/b*b==a

53.为了提高程序的运行速度，在函数中对于整型或指针可以使用（）型的变量。

er

54.以下程序的输出结果为（）。

main()

{int i=010,j=10;

printf("%d,%dn",++i,j--);

}

A.11,10 B.9,10 C.010,9 D.10,9

55.C 语言中以下几种运算符的优先次序（）的排列是正确的。

A.由高到低为:!,&&,||,算术运算符,赋值运算符

B.由高到低为:!,算术运算符,关系运算符,&&,||,赋值运算符

C.由高到低为:算术运算符,关系运算符,赋值运算符,!,&&,||

D.由高到低为:算术运算符,关系运算符,!,&&,||,赋值运算符

56.设a为整型变量，初值为12，执行完语句a+=a-=a*a后，a的值是（）。

A.552 B.144 C.264 D.-264

57.在TC运行环境中经下列语句定义后，sizeof(x)，sizeof(y)，sizeof(a)，sizeof(b)在微机上的值分别为（）。

char x=65;

float y=7.3;

int a=100;

double b=4.5;

A.2,2,2,4 B.1,2,2,4 C.1,4,2,8 D.2,4,2,8

58.用下列语句定义a，b，c，然后执行b=a、c='b'+b，则b，c的值是（）。

long a=0xffffff;

int b; char c;

A.0ffffff 和0x61 B.-1和98 C.-1和97 D.指向同一地址

59.执行下列语句后，a和b的值分别为（）。

int a,b;

a=1+'a';

b=2+7%-4-'A';

A.-63,-64 B.98,-60 C.1,-60 D.79,78

60.C语言中要求对变量作强制定义的主要理由是（）。

A.便于移植 B.便于写文件

C.便于编辑预处理程序的处理 D.便于确定类型和分配空间

61.以下程序的输出结果是（）。

main()

{float x=3.6;

int i;

i=(int)x;

printf("x=%f,i=%dn",x,i);

}

A.x=3.600000,i=4 B.x=3,i=3 C.x=3.600000,i=3 D.x=3 i=3.600000

- 5 -

62.经过以下语句定义后，表达式z+=x>y?++x:++y的值为（）。

int x=1,y=2,z=3;

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

63.以下程序的运行结果是（）。

main()

{

int i=1,sum=0;

while(i<10) sum=sum+1;i++;

printf("i=%d,sum=%d",i,sum);

}

A.i=10,sum=9 B.i=9,sum=9 C.i=2,sum=1 D.运行出现错误

64.以下程序的运行结果是（）。

main()

{ int n;

for(n=1;n<=10;n++)

{

if(n%3==0) continue;

printf("%d",n);

}

}

A.12457810 B.369 C.12 D.1234567890

65.在C语言中，if语句后的一对原括号中，用以决定分支的流程的表达式（）。

A.只能用逻辑表达式

B.只能用关系表达式

C.只能用逻辑表达式或关系表达式

D.可用任意表达式

66.在以下给出的表达式中，与 do--while(E)语句中的（E）不等价的表达式是（）。

A.(!E==0) B.(E>0||E<0) C.(E==0) D.(E!=0)

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

k1=1;

k2=2;

k3=3;

x=15;

if(!k1) x--;

else if(k2) x=4;

else x=3;

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

68.执行下列语句后的输出为（）。

int j=-1;

if(j<=1) printf("****n");

else printf("%%%%n");

A.**** B.%%%% C.%%%%c D.有错,执行不正确

69.下列程序的输出结果是（）。

main()

- 6 -

{ int x=1,y=0,a=0,b=0;

switch(x)

{

case 1:switch(y)

{

case 0:a++;break;

case 1:b++;break;

}

case 2:a++;b++;break;

case 3:a++;b++;break;

}

printf("a=%d,b=%dn",a,b);

}

A.a=1,b=0 B.a=2,b=1 C.a=1,b=1 D.a=2,b=2

70.在C语言中，为了结束由while语句构成的循环，while后一对圆括号中表达式的值应该为（）。

A.0 B.1 D.非0

71.下列程序的输出为（）。

main()

{ int y=10;

while(y--);

printf("y=%dn",y);

}

A.y=0 构成无限循环 C.y=1 D.y=-1

72.C语言的if语句嵌套时，if与else的配对关系是（）。

A.每个else总是与它上面的最近的if配对

B.每个else总是与最外层的if配对

C.每个else与if的配对是任意的

D.每个else总是与它上面的if配对

73.设j和k都是int类型，则for循环语句

for(j=0,k=-1;k=1;j++,k++) printf("****n");（）。

A.循环结束的条件不合法

B.是无限循环

C.循环体一次也不执行

D.循环体只执行一次

74.下列数组说明中，正确的是（）。

array[][4]; array[][]; array[][][5]; array[3][];

75.下列数组说明中，正确的是（）。

char str[]="China";

char str[]; str="China";

char str1[5],str2[]={"China"}; str1=str2;

char str1[],str2[];str2={"China"}; strcpy(str1,str2);

76.下列定义数组的语句中正确的是（）。

A.#define size 10 char str1[size],str2[size+2];

- 7 -

str[];

num['10'];

n=5; int a[n][n+2];

77.下列定义数组的语句中不正确的是（）。

int a[2][3]={1,2,3,4,5,6};

int a[2][3]={{1},{4,5}};

int a[][3]={{1},{4}};

int a[][]={{1,2,3},{4,5,6}};

78.下列语句中，不正确的是（）。

char a[2]={1,2};

int a[2]={'1','2'};

char a[2]={'1','2','3'};

char a[2]={'1'};

79.若输入ab，程序运行结果为（）。

main()

{ static char a[3];

scanf("%s",a);

printf("%c,%c",a[1],a[2]);

}

A.a,b B.a, C.b, D.程序出错

80.下列说法不正确的是（）。

A.主函数main中定义的变量在整个文件或程序中有效

B.不同函数中,可以使用相同名字的变量

C.形式参数是局部变量

D.在一个函数内部,可以在复合语句中定义变量,这些变量只在复合语句中有效

81.关于return语句，下列正确的说法是（）。

A.不能在主函数中出现且在其他函数中均可出现

B.必须在每个函数中出现

C.可以在同一个函数中出现多次

D.只能在除主函数之外的函数中出现一次

82.在C语言的函数中，下列正确的说法是（）。

A.必须有形参

B.形参必须是变量名

C.可以有也可以没有形参

D.数组名不能作形参

83.在C语言程序中（）。

A.函数的定义可以嵌套,但函数的调用不可以嵌套

B.函数的定义不可以嵌套,但函数的调用可以嵌套

C.函数的定义和函数调用均可以嵌套

D.函数的定义和函数调用不可以嵌套

84.C语言执行程序的开始执行点是（）。

A.程序中第一条可以执行语言

B.程序中第一个函数

C.程序中的main函数

- 8 -

D.包含文件中的第一个函数

85.C语言程序中，若对函数类型未加显式说明，则函数的隐含说明类型为（）。

86.C语言程序中，当调用函数时（）。

A.实参和形参各占一个独立的存储单元

B.实参和形参可以共用存储单元

C.可以由用户指定是否共用存储单元

D.计算机系统自动确定是否共用存储单元

87.数组名作为实参数传递给函数时，数组名被处理为（）。

A.该数组的长度 B.该数组的元素个数

C.该数组的首地址 D.该数组中各元素的值

88.以下描述中，正确的是（）。

A.预处理是指完成宏替换和文件包含中指定的文件的调用

B.预处理指令只能位于C源文件的开始

C.C源程序中凡是行首以#标识的控制行都是预处理指令

D.预处理就是完成C编译程序对C源程序第一遍扫描,为编译词法和语法分析作准备

89.以下对C语言函数的描述中，正确的是（）。

A.C程序必须由一个或一个以上的函数组成

B.C函数既可以嵌套定义又可以递归调用

C.函数必须有返回值,否则不能使用函数

D.C程序中有调用关系的所有函数必须放在同一个程序文件中

90.以下函数调用语句中实参的个数是（）。

exce((v1,v2),(v3,v4,v5),v6);

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

91.以下函数调用语句中实参的个数是（）。

func((e1,e2),(e3,e4,e5));

A.2 B.3 C.5 D.语法错误

92.C语言中函数调用的方式有（）。

A.一种：函数调用作为语句

B.一种：函数调用作为函数表达式

C.两种：函数调用作为语句或函数表达式

D.三种：函数调用作为语句、函数表达式或函数参数

93.执行下面程序后，输出结果是（）。

main()

{ a=45,b=27,c=0;

c=max(a,b);

printf("%dn",c);

}

int max(int x,int y)

{ int z;

if(x>y) z=x;

else z=y;

return(z);

- 9 -

}

A.45 B.27 C.18 D.72

94.以下程序的输出结果为（）。

main()

{int a=1,b=2,c=3,d=4,e=5;

printf("%dn",func((a+b,b+c,c+a),(d+e)));

}

int func(int x,int y)

{

return(x+y);

}

A.15 B.13 C.9 D.函数调用出错

95.下列定义不正确的是（）。

A.#define PI 3.141592

B.#define S 345

max(int x,int y); { }

char c;

96.下列程序运行结果为：

#define P 3

#define S(a) P*a*a

main()

{int ar;

ar=S(3+5);

printf("n%d",ar);

}

A.192 B.29 C.27 D.25

97.已知p，p1为整型指针变量，a为整型数组名，j为整型变量，下列赋值语句中不正确的是（）。

A.p=&j,p=p1; B.p=a; C.p=&a[j]; D.p=10;

98.经过下列的语句 int j,a[10],*p=a;定义后，下列语句中合法的是（）。

A.p=p+2; B.p=a[5]; C.p=a[2]+2; D.p=&(j+2);

99.两个指针变量不可以（）。

A.相加 B.比较 C.相减 D.指向同一地址

100.若已定义x为int类型变量，下列语句中说明指针变量p的正确语句是（）。

p=&x; *p=x; *p=&x; D.*p=*x;

101.关于指针概念说法不正确的是（）。

A.一个指针变量只能指向同一类型变量

B.一个变量的地址称为该变量的指针

C.只有同一类型变量的地址才能放到指向该类型变量的指针变量之中

D.指针变量可以由整数赋值，不能用浮点数赋值

102.设有说明int (*ptr)[M];其中标识符ptr是（）。

A.M个指向整型变量的指针

B.指向M个整型变量的函数指针

C.一个指向具有M个整型元素的一维数组的指针

- 10 -

D.具有M个指针元素的一维指针数组，每个元素都只能指向整型量

103.设char a[5],*p=a;，下面选择中正确的赋值语句是（）。

A.p="abcd"; B.a="abcd"; C.*p="abcd"; D.*a="abcd";

104.具有相同类型的指针变量p与数组a，不能进行的操作是（）。

A.p=a; B.*p=a[0]; C.p=&a[0]; D.p=&a;

105.若有下列定义，则对a数组元素地址的正确引用是（）。

int a[5],*p=a;

A.&a[5] B.p+2 C.a++ D.&a

106.若有下列定义和语句，则对a数组元素的非法引用是（）。

int a[2][3], (*pt)[3]; pt=a;

[0][0] B.*(pt+1)[2] C.*(pt[1]+2) D.*(a[0]+2)

107.以下程序段的输出结果是（）。

char *alp[]={"ABC","DEF","GHI"}; int j; puts(alp[1]);

A.A B.B C.D

108.设有以下语句, 若0

char str[4][2]={"aaa","bbb","ccc","ddd"},*strp[4];

int j;

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

strp[j]=str[j];

[k] [k] D.*strp

109.若有int a[][2]={{1,2},{3,4}}; 则*(a+1),*(*a+1)的含义分别为（）。

A.非法,2 B.&a[1][0],2 C.&a[0][1],3 D.a[0][0],4

110.若有定义：char *p1,*p2,*p3,*p4,ch;则不能正确赋值的程序语句为（）。

A.p1=&ch; scanf("%c",p1);

B.p2=(char *)malloc(1);scanf("%c",p2);

C.*p3=getchar();

D.p4=&ch;*p4=getchar();

111.当定义一个结构体变量时，系统分配给它的内存是（）。

A.各成员所需内存量的总和

B.结构中第一个成员所需内存量

C.结构中最后一个成员所需内存量

D.成员中占内存量最大者所需的容量

112.设有如下定义： struct sk {int a; float b;} data,*p;若要使p指向data中的a域，正确的赋值语句是（）。

A.p=(struct sk*)&data.a; B.p=(struct sk*) data.a;

C.p=&data.a; D.*p=data.a;

113.以下对枚举类型名的定义中正确的是（）。

a={sum,mon,tue};

a {sum=9,mon=-1,tue};

a={"sum","mon","tue"};

a {"sum","mon","tue"};

114.在下列程序段中，枚举变量c1，c2的值依次是（）。

enum color {red,yellow,blue=4,green,white} c1,c2;

c1=yellow;c2=white;

- 11 -

printf("%d,%dn",c1,c2);

A.1,6 B.2,5 C.1,4 D.2,6

115.变量p为指针变量，若p=&a，下列说法不正确的是（）。

A.&*p==&a B.*&a==a C.(*p)++==a++ D.*(p++)==a++

116.以下程序的输出结果是（）。

main()

{ char s[]="123",*p;

p=s;

printf("%c%c%cn",*p++,*p++,*p++);

}

A.123 B.321 C.213 D.312

117.执行下列语句后的结果为（）。

int x=3,y;

int *px=&x;

y=*px++;

A.x=3,y=4 B.x=3,y=3 C.x=4,y=4 D.x=3,y不知

118.下列各m的值中，能使m%3==2&&m%5==3&&m%7==2为真的是（）。

A.8 B.23 C.17 D.6

119.若有以下程序段：int a=3,b=4; a=a^b;b=b^a;a=a^b;则执行以上语句后，a和b的值分别是（）。

A.a=3,b=4 B.a=4,b=3 C.a=4,b=4 D.a=3,b=3

120.在位运算中，操作数每右移一位，其结果相当于（）。

A.操作数乘以2 B.操作数除以2

C.操作数乘以16 D.操作数除以16

(str,n,fp)函数从文件中读入一个字符串，以下正确的叙述是（）。

A.字符串读入后不会自动加入'0'

是file类型的指针

函数将从文件中最多读入n-1个字符

函数将从文件中最多读入n个字符

122.C语言中的文件类型只有（）。

A.索引文件和文本文件两种

文件和二进制文件两种

C.文本文件一种

D.二进制文件一种

123.C语言中，文件由（）。

A.记录组成 B.由数据行组成 C.由数据块组成 D.由字符(字节)序列组成

124.C语言中的文件的存储方式有（）。

A.只能顺序存取 B.只能随机存取(或直接存取)

C.可以顺序存取,也可随机存取 D.只能从文件的开头进行存取

125.下列程序的输出结果是（）。

main()

{ int x=1,y=0,a=0,b=0;

switch(x)

{

- 12 -

case 1:switch(y)

{

case 0:a++;break;

case 1:b++;break;

}

case 2:a++;b++;break;

case 3:a++;b++;break;

}

printf("a=%d,b=%dn",a,b);

}

A.a=1,b=0 B.a=2,b=1 C.a=1,b=1 D.a=2,b=2

126.设j和k都是int类型，则下面的for循环语句（）。

for(j=0,k=0;j<=9&&k!=876;j++) scanf("%d",&k);

A.最多执行10次 B.最多执行9次

C.是无限循环 D.循环体一次也不执行

127.以下程序段 char *alp[]={"ABC","DEF","GHI"}; puts(alp[1]);的输出结果是

A.A B.B C.D

128.下列标识符中，不合法的C语言用户自定义标识符是（）。

C._(下划线)

129.以下字符中不是转义字符的是（）。

A.'a' B.'b' C.'c' D.''

130.下列程序段的输出结果为（）。

float k=0.8567;

printf("%06.1f%%",k*100);

A.0085.6%% B.85.70% C.85.60% D.0.857

131.下列程序段的输出结果为（）。

float x=213.82631;

printf("%3d",(int)x);

A.213.82 B.213.83 C.213 D.3.8

132.C语言的注释定界符是（）。

A.{ } B.[ ] C.* * D./* */

133.下列字符序列中，是C语言关键字的是（）。

e

x;scanf("%lf",&x);不可以赋值给x变量的常量是（）。

A.123 B.100000 C.'A' D."abc"

135.C语言能正确处理的指数是（）。

A.8.50E+42 B.e-32 C.1.23E+11 D.4.5e-5.6

136.下列运算符中是C语言关系运算符的是（）。

A.~ B.! C.& D.!=

137.以下常量中，能够代表逻辑“真”值的常量是（）。

A.'0' B.0 C.'0'

138.下列程序段的输出结果为（）。

int x=3,y=2;

printf("%d",(x-=y,x*=y+8/5));

- 13 -

A.1 B.7 C.3 D.5

139.下列程序段的输出结果为（）。

int a=7,b=9,t;

t=a*=a>b?a:b;

printf("%d",t);

A.7 B.9 C.63 D.49

140.下列表达式中，可作为C合法表达式的是（）。

A.[3,2,1,0] B.(3,2,1,0) C.3=2=1=0 D.3/2/1/0

141.以下语句中，不能实现回车换行的是（）。

("n"); r("n");

f(stdout,"n"); ("n",1,1,stdout);

142.执行以下程序段后，输出结果和a的值是（）。

int a=10;

printf("%d",a++);

A.10 和 10 B.10 和 11 C.11 和 10 D.11 和 11

143.以下语句中，循环次数不为10次的语句是（）。

(i=1;i<10;i++);

B.i=1;do{i++;}while(i<=10);

C.i=10;while(i>0){--i;}

D.i=1;m:if(i<=10){i++;goto m;}

144.以下程序段的输出结果为（）。

for(i=4;i>1;i--)

for(j=1;j

putchar('#');

A.无 B.###### C.# D.###

145.以下程序段中，能够正确地执行循环的是（）。

for(i=1;i>10;i++)

static int a;

while(a)

int s=6;

do s-=2;

while(s);

int s=6;

m:if(s<100)

exit(0);

else s-=2;

goto m:

a=1,b=2,c=3;

if(a>b)a=b;

if(a>c)a=c;

则a的值为（）。

A.1 B.2 C.3 D.不一定

a=3,b=2,c=1;

if(a>b>c)a=b;

- 14 -

else a=c;

则a的值为（）。

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

148.求平方根函数的函数名为（）。

(fabs(t)<1e-5)if(!s/10)break;循环结束的条件是（）。

A.t>=1e-5&&t<=-1e-5&&s>-10&&s<10

(t)<1e-5&&!s/10

(t)<1e-5

D.s/10==0

a[10];合法的数组元素的最小下标值为（）。

A.10 B.9 C.1 D.0

a[10];不能将字符串"abc"存储在数组中的是（）。

(a,"abc");

B.a[0]=0;strcat(a,"abc");

C.a="abc";

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

i,j,a[2][3];按照数组a的元素在内存的排列次序，不能将数1,2,3,4,5,6存入a数组的是（）。

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

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

(i=0;i<6;i++)a[i/3][i%3]=i+1;

(i=1;i<=6;i++)a[i][i]=i;

char str[10]="China";数组元素个数为（）。

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

154.若char a[10];已正确定义，以下语句中不能从键盘上给a数组的所有元素输入值的语句是（）。

(a); ("%s",a);

(i=0;i<10;i++)a[i]=getchar(); D.a=getchar();

a[]="This is a program.";输出前5个字符的语句是（）。

("%.5s",a); (a); ("%s",a); D.a[5*2]=0;puts(a);

a[10];

给数组a的所有元素分别赋值为1、2、3、……的语句是（）。

(i=1;i<11;i++)a[i]=i;

(i=1;i<11;i++)a[i-1]=i;

(i=1;i<11;i++)a[i+1]=i;

(i=1;i<11;i++)a[0]=1;

157.以下程序段的输出结果为（）。

char c[]="abc";

int i=0;

do ;while(c[i++]!='0');printf("%d",i-1);

C.2 D.3

a1[]="abc",a2[80]="1234";将a1串连接到a2串后面的语句是（）。

(a2,a1 (a2,a1); (a1,a2); (a1,a2);

- 15 -

159.若有

char s1[]="abc",s2[20],*t=s2;gets(t);

则下列语句中能够实现当字符串s1大于字符串s2时,输出s2的语句是（）。

(strcmp(s1,s1)>0)puts(s2);

(strcmp(s2,s1)>0)puts(s2);

(strcmp(s2,t)>0)puts(s2);

(strcmp(s1,t)>0)puts(s2);

160.函数的形式参数隐含的存储类型说明是（）。

er

161.与实际参数为实型数组名相对应的形式参数不可以定义为（）。

a[]; *a; a; (*a)[3];

162.C语言中不可以嵌套的是（）。

A.函数调用 B.函数定义 C.循环语句 D.选择语句

163.用户定义的函数不可以调用的函数是（）。

A.非整型返回值的 B.本文件外的 函数 D.本函数下面定义的

164.全局变量的定义不可能在（）。

A.函数内部

B.函数外面

C.文件外面

D.最后一行

165.对于void类型函数，调用时不可作为（）。

A.自定义函数体中的语句

B.循环体里的语句

语句的成分语句

D.表达式

166.在C语言中，调用函数除函数名外，还必须有（）。

A.函数预说明

B.实际参数

C.( )

D.函数返回值

167.C程序中的宏展开是在（）。

A.编译时进行的

B.程序执行时进行的

C.编译前预处理时进行的

D.编辑时进行的

168.C语言中，定义结构体的保留字是（）。

f

169.结构体类型的定义允许嵌套是指（）。

A.成员是已经或正在定义的结构体型

B.成员可以重名

C.结构体型可以派生

D.定义多个结构体型

170对结构体类型的变量的成员的访问，无论数据类型如何都可使用的运算符是

A. . B. -> C. * D. &

- 16 -

171.相同结构体类型的变量之间，可以（）。

A.相加 B.赋值 C.比较大小 D.地址相同

172.使用共用体变量，不可以（）。

A.节省存储空间

B.简化程序设计

C.进行动态管理

D.同时访问所有成员

a {sum=9,mon=-1,tue};定义了（）。

A.枚举变量

B.3个标识符

C.枚举数据类型

D.整数9和-1

174.在定义构造数据类型时，不能（）。

A.说明变量

B.说明存储类型

C.初始化

D.末尾不写分号

175.位字段数据的单位是（）位。

A.十六进制 B.八进制 C.二进制 D.十进制

176.C语言程序中必须有的函数是（）。

A.#include "stdio.h"

177.指针变量p进行自加运算(即 执行p++;)后，地址偏移值为1，则其数据类型为（）。

178.若有int i=3,*p;p=&i;下列语句中输出结果为3的是（）。

("%d",&p);

("%d",*i);

("%d",*p);

("%d",p);

179.若有int *p=(int *)malloc(sizeof(int));则向内存申请到内存空间存入整数123的语句为（）。

("%d",p);

("%d",&p);

("%d",*p);

("%d",**p);

180.若有int a[10]={0,1,2,3,4,5,6,7,8,9},*p=a;则输出结果不为5的语句为（）。

("%d",*(a+5));

("%d",p[5]);

("%d",*(p+5));

("%d",*p[5]);

*s1="hello",*s2;s2=s1;则（）。

A.s2指向不确定的内存单元

B.不能访问"hello"

(s1);与puts(s2);结果相同

- 17 -

D.s1不能再指向其它单元

h,*s=&h;可将字符H通过指针存入变量h中的语句是（）。

A.*s=H; B.*s='H'; C.s=H; D.s='H'

183.若有char a[80],*s=a;不正确的输入语句是（）。

("%s",s);

(s);

(stdin,"%c",s);

(s,80,stdin);

(*p)[6]; 它的含义为（）。

A.具有6个元素的一维数组

B.定义了一个指向具有6个元素的一维数组的指针变量

C.指向整型指针变量

D.指向6个整数中的一个的地址

*match(char c)是（）。

A.函数定义的头部

B.函数预说明

C.函数调用

D.指针变量说明

186.若有double *p,x[10];int i=5;使指针变量p指向元素x[5]的语句为（）。

A.p=&x[i];

B.p=x;

C.p=x[i];

D.p=&(x+i)

187.不仅可将C源程序存在磁盘上，还可将数据按数据类型分别以什么的形式存在磁盘上（）。

A.内存 B.缓冲区 C.文件 D.寄存器

188.应用缓冲文件系统对文件进行读写操作，打开文件的函数名为（）。

189.应用缓冲文件系统对文件进行读写操作，关闭文件的函数名为（）。

() () ()

190.文件中有一个位置指针，指向当前读写的位置，不可使p所指文件的位置返回到文件的开头的是（）。

(p);

(p,0,SEEK_SET);

(p,0,0);

(p,-3L,SEEK_CUR);

191.从键盘上输入某字符串时，不可使用的函数是（）。

r() () () ()

192.选择结构中的条件与循环结构中循环成立的条件，在写法上可以是任一表达式，但其值只能被判断为“真”或“假”。哪个数作为逻辑“假”值（）。

A.-1 B.1 C.非零的数 D.0

struct {int a1;float a2;char a3;}a[10]={1,3.5,'A'};说明数组a是地址常量，它有10个结构体型的下标变量，采用静态存储方式，其中被初始化的下标变量是（）。

- 18 -

A.a[1] B.a[-1] C.a[0] D.a[10]

194.打开文件时，方式“w”决定了对文件进行的操作是（）。

A.只写盘 B.只读盘 C.可读可写盘 D.追加写盘

a[10]={1,2,3,4,5,6,7,8};int *p;p=&a[5];p[-3]的值是（）。

A.2 B.3 C.4 D.不一定

196.一个算法应该具有“确定性”等5个特性，下面对另外4个特性的描述中错误的是（）。

A.有零个或多个输入

B.有零个或多个输出

C.有穷性

D.可行性

197.能将高级语言编写的源程序转换为目标程序的是（）。

A.链接程序 B.解释程序 C.编译程序 D.编辑程序

198.以下叙述中正确的是 （）。

A.C程序中注释部分可以出现在程序中任意合适的地方

B.花括号“{“和”}”只能作为函数体的定界符

C.构成C程序的基本单位是函数,所有函数名都可以由用户命名

D.分号是C语句之间的分隔符,不是语句的一部分

199.下列叙述中正确的是（）。

A.C语言编译时不检查语法

B.C语言的子程序有过程和函数两种

C.C语言的函数可以嵌套定义

D.C语言所有函数都是外部函数

200.以下叙述中正确的是（）。

A.构成C程序的基本单位是函数

B.可以在一个函数中定义另一个函数

()函数必须放在其它函数之前

D.所有被调用的函数一定要在调用之前进行定义

201.在一个C程序中（）。

函数必须出现在所有函数之前

函数可以在任何地方出现

函数必须出现在所有函数之后

函数必须出现在固定位置

202.以下叙述中正确的是（）。

A.C语言的源程序不必通过编译就可以直接运行

B.C语言中的每条可执行语句最终都将被转换成二进制的机器指令

C.C源程序经编译形成的二进制代码可以直接运行

D.C语言中的函数不可以单独进行编译

203.一个C程序的执行是从（）。

A.本程序的main函数开始,到main函数结束

B.本程序文件的第一个函数开始,到本程序文件的最后一个函数结束

C.本程序的main函数开始,到本程序文件的最后一个函数结束

D.本程序文件的第一个函数开始,到本程序main函数结束

204.以下叙述中正确的是 （）。

- 19 -

A.C语言比其他语言高级

B.C语言可以不用编译就能被计算机识别执行

C.C语言以接近英语国家的自然语言和数学语言作为语言的表达形式

D.C语言出现的最晚,具有其他语言的一切优点

205.一个C语言程序是由（）。

A.一个主程序和若干子程序组成

B.函数组成

C.若干过程组成

D.若干子程序组成

206.C语言规定，在一个源程序中，main函数的位置（）。

A.必须在最开始

B.必须在系统调用的库函数的后面

C.可以任意

D.必须在最后

207.以下叙述不正确的是（）。

A.一个C源程序可由一个或多个函数组成

B.一个C源程序必须包含一个main函数

C.C程序的基本组成单位是函数

D.在C程序中，注释说明只能位于一条语句的后面

208.以下叙述正确的是（）。

A.在C程序中，main函数必须位于程序的最前面

B.C程序的每行中只能写一条语句

C.C语言本身没有输入输出语句

D.在对一个C程序进行编译的过程中，可发现注释中的拼写错误

209.表达式18/4*sqrt(4.0)/8值的数据类型为（）。

D.不确定

210.C语言中运算对象必须是整型的运算符是（）。

A.%= B./ C.= D.〈=

211.若变量已正确定义并赋值，下面符合C语言语法的表达式是（）。

A.a:=b+1

B.a=b=c+2

18.5%3

D.a=a+7=c+b

212.若有条件表达式 (exp)?a++:b--，则以下表达式中能完全等价于表达式(exp)的是（）。

A.(exp==0)

B.(exp!=0)

C.(exp==1)

D.(exp!=1)

213.设以下变量均为int类型，则值不等于7的表达式是（）。

A.(x=y=6,x+y,x+1)

B.(x=y=6,x+y,y+1)

C.(x=6,x+1,y=6,x+y)

D.(y=6,y+1,x=y,x+1)

- 20 -

214.在C语言中,int、char和short三种类型数据在内存中所占用的字节数（）。

A.由用用户自己定义

B.均为2个字节

C.是任意的

D.由所用机器的机器字长决定

215.设C语言中，一个int型数据在内存中占2个字节，则unsigned int型数据的取值范围为（）。

A.0--255

B.0--32767

C.0--65535

D.0--2147483647

216.在C语言中，char型数据在内存中的存储形式是（）。

A.补码 B.反码 C.原码 码

217.设变量a是整型，f是实型，i是双精度型，则表达式10+'a'+i*f值的数据类型为（）。

D.不确定

(float)是（）。

A.一个双精度型表达式

B.一个整型表达式

C.一种函数调用

D.一个不合法的表达式

219.若有定义:int a=7;float x=2.5,y=4.7;

则以下输出的结果是printf("%f",x+a%3*(int)(x+y)%2/4);（）。

A.2.5 B.2.75 C.3.5 D.0

220.已知大写字母A的ASCII码值是65，小写字母a的ASCII码是97，则用八进制表示的字符常量'101'是（）。

A.字符A B.字符a C.字符e D.非法的常量

221.以下选项中合法的用户标识符是（）。

B._2Test C.3Dmax

222.以下选项中合法的实型常数是（）。

A.5E2.0 B.E-3 C.2.00E-01 D.1.3E

223.语句printf("abre'hi'yboun");的输出结果是(说明:'b'是退格符)（）。

'hi'ybou

'hi'ybou

'hi'you

'hi'ybou

224.若已定义x和y为double类型，则表达式x=1,y=x+3/2 的值是（）。

A.1 B.2 C.2 D.2.5

225.下列变量定义中合法的是（）。

_a=1-.1e-1;

b=1+5e2.5;

do=0xfdaL;

2_and=1-e-3;

226.若变量a与i已正确定义，且i已正确赋值，合法的语句是（）。

- 21 -

A.a==1 B.++i; C.a=a++=5; D.a=int(i);

227.设有 int x=11; 则表达式 (x++ * 1/3) 的值是（）。

A.3 B.4 C.11 D.12

228.若以下变量均是整型，且num=sum=7;则计算表达式sum=num++,sum++,++num后sum的值为（）。

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

229.设 int x=1, y=1; 表达式(!x||y--)的值是（）。

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

230.C语言中的标识符只能由字母，数字和下划线三种字符组成，且第一个字符

A.必须为字母

B.必须为下划线

C.必须为字母或下划线

D.可以是字母，数字和下划线中任一字符

231.下面四个选项中，均是不合法的用户标识符的选项是（）。

A.A P_0 do

la0 _A

C.b-a goto int

D._123 temp int

232.下列四个选项中，均是C语言关键字的选项是（）。

enum include

typedef continue

union scanf

struct type

233.下列四组选项中，均不是C语言关键字的选项是（）。

IF type

char printf

e scanf case

go pow

234.假设所有变量均为整型，则表达式(a=2,b=5,b++,a+b)的值是（）。

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

235.若有说明语句:char c='72';则变量c（）。

A.包含1个字符

B.包含2个字符

C.包含3个字符

D.说明不合法，c的值不确定

236.下面四个选项中，均是不合法的浮点数的选项是（）。

A.160. 0.12 e3

B.123 2e4.2 .e5

C.-.18 123e4 0.0

D.-e3 .234 1e3

237.以下符合C语言语法的赋值表达式是（）。

A.d=9+e+f=d+9

B.d=9+e,f=d+9

C.d=9+e,e++,d+9

- 22 -

D.d=9+e++=d+7

238.下面不正确的字符串常量是（）。

A.'abc' B."12'12" C."0" D." "

239.以下所列的C语言常量中，错误的是（）。

A.0xFF

B.1.2e0.5

C.2L

D.'72'

240.已定义ch为字符型变量，以下赋值语句中错误的是（）。

='';

=62+3;

=NULL;

='xaa';

241.若a为int类型，且其值为3，则执行完表达式a+=a-=a*a后，a的值是（）。

A.-3 B.9 C.-12 D.6

242.下列选项中，合法的C语言关键字是（）。

r

t

243.设有说明语句:char a='72';则变量a（）。

A.包含1个字符

B.包含2个字符

C.包含3个字符

D.说明不合法

244.以下选项中，与k=n++完全等价的表达式是（）。

A.k=n,n=n+1

B.n=n+1,k=n

C.k=++n

D.k+=n+1

245.以下for循环的执行次数是 for(x=0,y=0;(y=123)&&(x<4);x++);（）。

A.是无限循环

B.循环次数不定

C.4次

D.3次

246.语句while(!E);中的表达式!E等价于（）。

A.E==0

B.E!=1

C.E!=0

D.E==1

247.下面有关 for 循环的正确描述是（）。

循环只能用于循环次数已经确定的情况

循环是先执行循环循环体语句,后判断表达式

C.在 for 循环中,不能用 break 语句跳出循环体

- 23 -

循环的循环体语句中,可以包含多条语句,但必须用花括号括起来

248.若i为整型变量，则以下循环执行次数是（）。

for(i=2;i==0;) printf("%d",i--);

A.无限次

B.0次

C.1次

D.2次

249.C语言中 while 和 do-while 循环的主要区别是（）。

-while 的循环体至少无条件执行一次

的循环控制条件比 do-while的循环控制条件更严格

-while 允许从外部转到循环体内

-while 的循环体不能是复合语句

250.以下不是无限循环的语句为（）。

(y=0,x=1;x>++y;x=i++) i=x;

(;;x++=i);

(1){x++;}

(i=10;;i--) sum+=i;

251.执行语句 for(i=1;i++<4;); 后变量 i 的值是（）。

A.3

B.4

C.5

D.不定

252.C语言中用于结构化程序设计的三种基本结构是（）。

A.顺序结构、选择结构、循环结构

、switch、break

、while、do-while

、for、continue

253.对 for(表达式1; ;表达式3) 可理解为（）。

(表达式1;0;表达式3)

(表达式1;1;表达式3)

(表达式1;表达式1;表达式3)

(表达式1;表达式3;表达式3)

254.下列运算符中优先级最高的是（）。

A.< B.+ C.&& D.!=

函数中用到格式符%5s，其中数字5表示输出的字符串占用5列，如果字符串长度大于5，则输出按方式（）。

A.从左起输出该字符串,右补空格

B.按原字符长从左向右全部输出

C.右对齐输出该字串,左补空格

D.输出错误信息

r函数可以向终端输出一个（）。

A.整型变量表达式值

B.实型变量值

C.字符串

- 24 -

D.字符或字符型变量值

257.以下描述中正确的是（）。

A.由于 do-while 循环中循环体语句只能是一条可执行语句,所以循环体内不能使用复合语句

-while 循环由do开始,用while结束,在 while(表达式)后面不能写分号

-while 循环体中,一定要有能使 while 后面表达式的值变为零("假")的操作

-while 循环中,根据情况可以省略 while

258.以下关于运算符优先顺序的描述中正确的是（）。

A.关系运算符<算术运算符<赋值运算符<逻辑运算符

B.逻辑运算符<关系运算符<算术运算符<赋值运算符

C.赋值运算符<逻辑运算符<关系运算符<算术运算符

D.算术运算符<关系运算符<赋值运算符<逻辑运算符

259.已知x=43，ch='A'，y=0;则表达式(x>=y&&ch<'B'&&!y)的值是（）。

A.0 B.语法错 C.1 D."假"

260.若希望当A的值为奇数时，表达式的值为“真”，A的值为偶数时，表达式的值为“假”，则以下不能满足要求的表达式是（）。

A.A%2==1

B.!(A%2==0)

C.!(A%2)

D.A%2

261.判断char型变量cl是否为小写字母的正确表达式是（）。

A.'a'<=cl<='z'

B.(cl>=a)&&(cl<=z)

C.('a'>=cl)||('z'<=cl)

D.(cl>='a')&&(cl<='z')

262.以下不正确的if语句形式是（）。

(x>y&&x!=y);

(x==y) x+=y;

(x!=y) scanf("%d",&x) else scanf("%d",&y);

(x

263.为了避免在嵌套的条件语句 if-else 中产生二义性，C语言规定:else子句总是与（）配对。

A.缩排位置相同的if

B.其之前最近的if

C.其之后最近的if

D.同一行上的if

264.逻辑运算符两侧运算对象的数据类型（）。

A.只能是0或1

B.只能是0或非0正数

C.只能是整型或字符型数据

D.可以是任何类型的数据

265.结构化程序设计所规定的三种基本控制结构是（）。

A.输入、处理、输出

B.树形、网形、环形

- 25 -

C.顺序、选择、循环

D.主程序、子程序、函数

266.以下叙述正确的是（）。

-while语句构成的循环不能用其它语句构成的循环来代替.

-while语句构成的循环只能用break语句退出.

C.用do-while语句构成的循环,在while后的表达式为非零时结束循环.

D.用do-while语句构成的循环,在while后的表达式为零时结束循环

267.对以下说明语句 int a[10]={6,7,8,9,10}; 的正确理解是（）。

A.将5个初值依次赋给a[1]至a[5]

B.将5个初值依次赋给a[0]至a[4]

C.将5个初值依次赋给a[6]至a[10]

D.因为数组长度与初值的个数不相同,所以此语句不正确

268.以下不正确的定义语句是（）。

x[5]={2.0,4.0,6.0,8.0,10.0};

y[5]={0,1,3,5,7,9};

c1[]={'1','2','3','4','5'};

c2[]={'x10','xa','x8'};

269.若有说明:int a[][3]={1,2,3,4,5,6,7};则a数组第一维的大小是（）。

A.2 B.3 C.4 D.无确定值

270.若二维数组a有m列,则在a[i][j]前的元素个数为（）。

A.j*m+i B.i*m+j C.i*m+j-1 D.i*m+j+1

271.若有说明:int a[3][4];则数组a中各元素（）。

A.可在程序的运行阶段得到初值0

B.可在程序的编译阶段得到初值0

C.不能得到确定的初值

D.可在程序的编译或运行阶段得到初值0

272.设有数组定义: char array [ ]="China"; 则数组 array所占的空间为（）。

A.4个字节 B.5个字节 C.6个字节 D.7个字节

273.以下能正确定义数组并正确赋初值的语句是（）。

N=5,b[N][N];

a[1][2]={{1},{3}};

c[2][]={{1,2},{3,4}};

d[3][2]={{1,2},{34}};

274.以下对二维数组a的正确说明是（）。

a[3][] a(3,4) a[1][4] a(3)(4)

275.若有说明:int a[10];则对a数组元素的正确引用是（）。

A.a[10] B.a[3,5] B.a(5) D.a[10-10]

276.在C语言中，一维数组的定义方式为:类型说明符数组名（）。

A.[常量表达式] B.[整型表达式]

C.[整型常量]或[整型表达式] D.[整型常量]

277.以下能对一维数组a进行正确初始化的语句是（）。

a[10]=(0,0,0,0,0) a[10]={}; a[]={0}; a[10]={10*1};

278.以下对一维整型数组a的正确说明是（）。

a(10); n=10,a[n];

- 26 -

n; scanf("%d",&n); int a[n]; D.#define SIZE 10 (换行) int a[SIZE];

279.若有说明 int a[3][4];则对a数组元素的正确引用是（）。

A.a[2][4] B.a[1,3] C.a[1+1][0] D.a(2)(1)

280.若有说明 int a[3][4];则a数组元素的非法引用是（）。

A.a[0][2*1] B.a[1][3] C.a[4-2][0] D.a[0][4]

281.以下能对二维数组a进行正确初始化的语句是（）。

a[2][]={{1,0,1},{5,2,3}};

a[][3]={{1,2,3},{4,5,6}};

a[2][4]={{1,2,3},{4,5},{6}};

a[][3]={{1,0,1}{},{1,1}};

282.以下不能对二维数组a进行正确初始化的语句是（）。

a[2][3]={0};

a[][3]={{1,2},{0}};

a[2][3]={{1,2},{3,4},{5,6}};

a[][3]={1,2,3,4,5,6};

283.若有说明: int a[3][4]={0};则下面正确的叙述是（）。

A.只有元素a[0][0]可得到初值0

B.此说明语句不正确

C.数组a中各元素都可得到初值,但其值不一定为0

D.数组a中每个元素均可得到初值0

284.若有说明: int a[][4]={0,0};则下面不正确的叙述是（）。

A.数组a的每个元素都可得到初值0

B.二维数组a的第一维大小为1

C.因为二维数组a中第二维大小的值除经初值个数的商为1,故数组a的行数为1

D.有元素a[0][0]和a[0][1]可得到初值0,其余元素均得不到初值0

285.以下定义语句中，错误的是（）。

a[]={1,2};

*a[3];

s[10]="test";

n=5,a[n];

286.在C语言中，引用数组元素时，其数组下标的数据类型允许是（）。

A.整型常量

B.整型表达式

C.整型常量或整型表达式

D.任何类型的表达式

287.以下程序段中，不能正确赋字符串（编译时系统会提示错误）的是（）。

s[10]="abcdefg";

t[]="abcdefg",*s=t;

s[10];s="abcdefg";

s[10];strcpy(s,"abcdefg");

288.以下不能正确定义二维数组的选项是（）。

a[2][2]={{1},{2}};

a[][2]={1,2,3,4};

a[2][2]={{1},2,3};

- 27 -

a[2][]={{1,2},{3,4}};

289.假定int类型变量占用两个字节，其有定义:int x[10]={0,2,4};则数组x在内存中所占字节数是（）。

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

290.以下数组定义中不正确的是（）。

a[2][3];

b[][3]={0,1,2,3};

c[100][100]={0};

d[3][]={{1,2},{1,2,3},{1,2,3,4}};

291.以下不能正确进行字符串赋初值的语句是（）。

str[5]="good!";

str[]="good!";

*str="good!";

str[5]={'g','o','o','d',0};

292.若使用一维数组名作函数实参，则以下正确的说法是（）。

A.必须在主调函数中说明此数组的大小

B.实参数组类型与形参数组类型可以不匹配

C.在被调用函数中,不需要考虑形参数组的大小

D.实参数组名与形参数组名必须一致

293.凡是函数中未指定存储类别的局部变量，其隐含的存储类别为（）。

A.自动(auto) B.静态(static) C.外部(extern) D.寄存器(register)

294.在C语言中，函数的隐含存储类别是（）。

D.无存储类别

295.以下正确的描述是：在C语言程序中（）。

A.函数的定义可以嵌套,但函数的调用不可以嵌套

B.函数的定义不可以嵌套,但函数的调用可以嵌套

C.函数的定义和函数的调用均不可以嵌套

D.函数的定义和函数的调用均可以嵌套

296.C语言中，函数值类型的定义可以缺省，此时函数值的隐含类型是（）。

297.以下不正确的说法是：C语言规定（）。

A.实参可以是常量,变量或表达式

B.形参可以是常量,变量或表达式

C.实参可以为任何类型

D.形参应与其对应的实参类型一致

298.以下正确的函数定义形式是（）。

fun(int x,int y)

fun(int x;int y)

fun(int x,int y);

fun(int x,y);

299.以下正确的说法是：在C语言中（）。

A.实参和与其对应的形参各占用独立的存储单元

B.实参和与其对应的形参共占用一个存储单元

C.只有当实参和与其对应的形参同名时才共占用存储单元

- 28 -

D.形参是虚拟的,不占用存储单元

300若调用一个函数，且此函数中没有return语句，则正确的说法是：该函数（）。

A.没有返回值

B.返回若干个系统默认值

C.能返回一个用户所希望的值

D.返回一个不确定的值

301.以下叙述中正确的是（）。

A.全局变量的作用域一定比局部变量的作用域范围大

B.静态(static)类别变量的生存期贯穿于整个程序的运行期间

C.函数的形参都属于全局变量

D.未在定义语句中赋初值的auto变量和static变量的初值都是随机值

302.以下正确的说法是（）。

A.用户若需调用标准库函数，调用前必须重新定义

B.用户可以重新定义标准库函数，若如此，该函数将失去原有含义

C.系统根本不允许用户重新定义标准库函数

D.用户若需调用标准库函数，调用前不必使用预编译命令将该函数所在文件包括到用户源文件中，系统自动去调

303.若用数组名作为函数的实参，传递给形参的是（）。

A.数组的首地址

B.数组第一个元素的值

C.数组中全部元素的值

D.数组元素的个数

304.以下正确的说法是（）。

A.定义函数时,形参的类型说明可以放在函数体内

后边的值不能为表达式

C.如果函数值的类型与返回值类型不一致，以函数值类型为准

D.如果形参与实参类型不一致，以实参类型为准

305.C语言允许函数类型缺省定义，此时函数值隐含的类型是（）。

306.C语言规定，函数返回值的类型是由（）。

语句中的表达式类型所决定

B.调用该函数时的主调函数类型所决定

C.调用该函数时系统临时决定

D.在定义该函数时所指定的函数类型所决定

307.以下错误的描述是：函数调用可以（）。

A.出现在执行语句中

B.出现在一个表达式中

C.做为一个函数的实参

D.做为一个函数的形参

308.关于建立函数的目的，以下正确的说法是（）。

A.提高程序的执行效率

B.提高程序的可读性

C.减少程序的篇幅

D.减少程序文件所占内存

- 29 -

309.以下只有在使用时才为该类型变量分配内存的存储类说明是（）。

和 static

和 register

er和 static

和 register

310.若已定义的函数有返回值，则以下关于该函数调用的叙述中错误的是（）。

A.函数调用可以作为独立的语句存在

B.函数调用可以作为一个函数的实参

C.函数调用可以出现在表达式中

D.函数调用可以作为一个函数的形参

311.当调用函数时，实参是一个数组名，则向函数传送的是（）。

A.数组的长度

B.数组的首地址

C.数组每一个元素的地址

D.数组每个元素中的值

312.在C语言中，形参的缺省存储类别是（）。

er

313.在调用函数时，如果实参是简单变量，它与对应形参之间的数据传递方式是

A.地址传递

B.单向值传递

C.由实参传给形参，再由形参传回实参

D.传递方式由用户指定

314.以下运算符中优先级最低的是（）。

A.&& B.& C.|| D.|

315.在C语言中，要求运算数必须是整型或字符型的运算符是（）。

A.&& B.& C.! D.||

316.在C语言中，要求运算数必须是整型的运算符是（）。

A.^ B.% C.! D.>

317.在位运算中，操作数每左移一位，其结果相当于（）。

A.操作数乘以2

B.操作数除以2

C.操作数除以4

D.操作数乘以4

318.表达式，0x13&0x17的值是（）。

A.0x17 B.0x13 C.0xf8 D.0xec

319.若a=1,b=2则 a|b的值是（）。

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

320.以下叙述中不正确的是（）。

A.预处理命令行都必须以#号开始

B.在程序中凡是以#号开始的语句行都是预处理命令行

C.C程序在执行过程中对预处理命令行进行处理

D.以下是正确的宏定义 #define IBM_PC

321.设char型变量x中的值为10100111，则表达式(2+x)^(~3)的值是（）。

A.10101001 B.10101000 C.11111101 D.01010101

- 30 -

322.若要说明一个类型名STP，使得定义语句STP s等价于char *s，以下选项中正确的是（）。

f STP char *s; f *char STP;

f stp *char; f char* STP;

323.以下叙述中正确的是（）。

A.在程序的一行上可以出现多个有效的预处理命令行

B.使用带参的宏时,参数的类型应与宏定义时的一致

C.宏替换不占用运行时间,只占编译时间

D.在以下定义中 C R 是称为"宏名"的标识符 #define C R 045

324.以下各选项企图说明一种新的类型名，其中正确的是（）。

f v1 int; f v2=int; f int v3; f v4: int;

325.以下叙述正确的是（）。

A.可以把define和if定义为用户标识符

B.可以把define定义为用户标识符,但不能把if定义为用户标识符

C.可以把if定义为用户标识符,但不能把define定义为用户标识符

和if都不能定义为用户标识符

326.以下叙述中不正确的是（）。

A.表达式a&=b等价于a=a&b

B.表达式a|=b等价于a=a|b

C.表达式a!=b等价于a=a!b

D.表达式a^=b等价于a=a^b

327.设 int b=2;表达式(b>>2)/(b>>1)的值是（）。

A.0 B.2 C.4 D.8

328.若x=2,y=3则x&y的结果是（）。

A.0 B.2 C.3 D.5

329.整型变量x和y的值相等、且为非0值,则以下选项中，结果为零的表达式是

A.x || y B.x | y C.x & y D.x ^ y

330.下面说明不正确的是（）。

a[10]="china";

a[10],*p=a;p="china"

*a;a="china";

a[10],*p;p=a="china"

331.设p1和p2是指向同一个字符串的指针变量，c为字符变量，则以下不能正确执行的赋值语句是（）。

A.c=*p1+*p2;

B.p2=c;

C.p1=p2;

D.c=*p1*(*p2);

332.设 char *s="ta017bc";则指针变量s指向的字符串所占的字节数是（）。

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

333.对于基本类型相同的两个指针变量之间，不能进行的运算是（）。

A.< B.= C.+ D.-

334.若有以下的定义:int t[3][2];能正确表示t数组元素地址的表达式是（）。

A.&t[3][2] B.t[3] C.&t[1] D.t[2]

- 31 -

335.变量的指针，其含义是指该变量的（）。

A.值 B.地址 C.名 D.一个标志

336.若有语句int *point,a=4;和 point=&a;下面均代表地址的一组选项是（）。

A.a,point,*&a B.&*a,&a,*point C.*&point,*point,&a D.&a,&*point,point

337.若有说明:int *p,m=5,n;以下正确的程序段是（）。

A.p=&n;scanf("%d",&p);

B.p=&n;scanf("%d",*p)

("%d",&n);*p=n;

D.p=&n;*p=m;

338.若有说明:int *p1,*p2,m=5,n;以下均是正确赋值语句的选项是（）。

A.p1=&m;p2=&p1

B.p1=&m;p2=&n;*p1=*p2;

C.p1=&m;p2=p1;

D.p1=&m;*p2=*p1;

339.下面判断正确的是（）。

*a="china";等价于 char *a;*a="china";

str[10]={"china"};等价于char str[10];str[]={"china"};

*s="china";等价于 char *s;s="china";

c[4]="abc",d[4]="abc";等价于 char c[4]=d[4]="abc";

340.若定义:int a=511,*b=&a;, 则printf("%dn",*b);的输出结果为（）。

A.无确定值 B.a的地址 C.512 D.511

341.若有定义:int *p[3];，则以下叙述中正确的是（）。

A.定义了一个基类型为int的指针变量p，该变量具有三个指针

B.定义了一个指针数组p，该数组含有三个元素,各元素都是基类型为int的指针

C.定义了一个名为*p的整型数组，该数组含有三个int类型元素

D.定义了一个可指向一维数组的指针变量p，所指一维数组应具有三个int类型

元素

342.下列选项中正确的语句组是（）。

s[8]; s={"Beijing"};

*s; s={"Beijing"};

s[8]; s="Beijing";

*s; s="Beijing";

343.若有说明:int n=2,*p=&n,*q=p;，则以下非法的赋值语句是（）。

A.p=q; B.*p=*q; C.n=*q; D.p=n;

344.在说明语句:int *f();中，标识符f代表的是（）。

A.一个用于指向整型数据的指针变量

B.一个用于指向一维数组的行指针

C.一个用于指向函数的指针变量

D.一个返回值为指针型的函数名

345.若有定义:int aa[ 8];则以下表达式中不能代表数组元aa[1]的地址的是（）。

A.&aa[0]+1 B.&aa[1] C.&aa[0]++ +1

346.若有说明:int i, j=2,*p=&i;,则能完成i=j赋值功能的语句是（）。

A.i=*p; B.*p=*&j; C.i=&j; D.i=**p;

347.设有定义:int n=0,*p=&n,**q=&p;则以下选项中，正确的赋值语句是（）。

- 32 -

A.p=1; B.*q=2; C.q=p; D.*p=5;

函数的正确调用形式是（）。

(fp,格式字符串,输出表列);

(格式字符串,输出表列,fp);

(格式字符串,文件指针,输出表列);

(文件指针,格式字符串,输入表列);

349.系统的标准输入文件是指（）。

A.键盘 B.显示器 C.软盘 D.硬盘

350.函数 ftell(fp) 的作用是（）。

A.得到流式文件中的当前位置

B.移到流式文件的位置指针

C.初始化流式文件的位置指针

D.以上答案均正确

351.函数 rewind 的作用是（）。

A.使位置指针重新返回文件的开头

B.将位置指针指向文件中所要求的特定位置

C.使位置指针指向文件的末尾

D.使位置指针自动移至下一个字符位置

函数的正确调用形式是（）。

(文件类型指针,起始点,位移量)

(fp,位移量,起始点)

(位移量,起始点,fp)

(起始点,位移量,文件类型指针)

353.利用 fseek 函数可以实现的操作是（）。

A.改变文件的位置指针

B.文件的顺序读写

C.文件的随机读写

D.以上答案均正确

354.函数调用语句：fseek(fp,-20L,2);的含义是（）。

A.将文件位置指针移到距离文件头20个字节处

B.将文件位置指针从当前位置向后移动20个字节

C.将文件位置指针从文件末尾处退后20个字节

D.将文件位置指针移到离当前位置20个字节处

355.若调用fputc函数输出字符成功，则其返回值是（）。

B.1 C.0 D.输出的字符

356.在执行 fopen 函数时，ferror 函数的初值是（）。

B.-1 C.1 D.0

函数的一般调用形式是（）。

(buffer,count,size,fp);

(fp,size,count,buffer);

(fp,count,size,buffer);

(buffer,size,count,fp);

358.以下fread函数的调用形式中，参数类型正确的是（）。

(int fd,char *buf,int count)

- 33 -

(int *buf,int fd,int count)

(int fd,int count,char *buf)

(int count,char *buf,int fd)

359.已知函数的调用形式：fread(buffer,size,count,fp);其中buffer代表的是（）。

A.一个整数,代表要读入的数据项总数

B.一个文件指针,指向要读的文件

C.一个指针,指向要读入数据的存放地址

D.一个存储区,存放要读的数据项

360.当顺利执行了文件关闭操作时，fclose函数的返回值是（）。

A.-1 C.0 D.1

361.若以"a+"方式打开一个已存在的文件，则以下叙述正确的是（）。

A.文件打开时,原文件内容不被删除,位置指针移到文件末尾,可作添加和读操作

B.文件打开时,原文件内容不被删除,位置指针移到文件开头,可作重写和读操作

C.文件打开时,原有文件内容被删除,只可作写操作

D.以上各种说法皆不正确

362.若要用fopen函数打开一个新的二进制文件，该文件要既能读也能写，则文件方式字符串应是（）。

A."ab++" B."wb+" C."rb+" D."ab"

363.若执行fopen函数时发生错误，则函数的返回值是（）。

A.地址值 B.0 C.1

364.以下叙述中不正确的是（）。

A.C语言中的文本文件以ASCⅡ码形式存储数据

B.C语言中对二进制文件的访问速度比文本文件快

C.C语言中，随机读写方式不适用于文本文件

D.C语言中，顺序读写方式不适用于二进制文件

365.以下可作为函数fopen中第一个参数的正确格式是（）。

A.c:

B.c:

C."c:"

D."c:"

函数的作用是从指定文件读入一个字符，该文件的打开方式必须是（）。

A.只写 B.追加 C.读或读写 D.答案B和C都正确

367.以下叙述中错误的是（）。

A.二进制文件打开后可以先读文件的末尾,而顺序文件不可以

B.在程序结束时,应当用fclose函数关闭已打开的文件

C.在利用fread函数从二进制文件中读数据时,可以用数组名给数组中所有元素读入数据

D.不可以用FILE定义指向二进制文件的文件指针

368.下列关于C语言数据文件的叙述中正确的是（）。

A.文件由ASCII码字符序列组成,C语言只能读写文本文件

B.文件由二进制数据序列组成,C语言只能读写二进制文件

C.文件由记录序列组成,可按数据的存放形式分为二进制文件和文本文件

D.文件由数据流形式组成,可按数据的存放形式分为二进制文件和文本文件

369.若fp已正确定义并指向某个文件，当未遇到该文件结束标志时函数feof(fp)- 34 -

的值为（）。

A.0 B.1 C.-1 D.一个非0值

370.若要打开A盘上user子目录下名为的文本文件进行读、写操作，下面符合此要求的函数调用是（）。

("A:","r")

("A:","r+")

("A:","rb")

("A:","w")

371.在C程序中，可把整型数以二进制形式存放到文件中的函数是（）。

f函数 函数 函数 函数

372.若fp是指向某文件的指针，且已读到此文件末尾,则库函数feof(fp)的返回值是（）。

B.0 C.非零值

373.C语言结构体类型变量在程序执行期间（）。

A.所有成员一直驻留在内存中

B.只有一个成员驻留在内存中

C.部分成员驻留在内存中

D.没有成员驻留在内存中

374.当说明一个结构体变量时系统分配给它的内存是（）。

A.各成员所需内存量的总和

B.结构中第一个成员所需内存量

C.成员中占内存量最大者所需的容量

D.结构中最后一个成员所需内存量

375.下列变量中合法的是

A. B.3a6b C._6a7b D.$ABC

376.整型变量x=1,y=3,经下列计算后,x的值不等于6的是

A.x=(x=1+2,x*2)

B.x=y>2?6:5

C.x=9-(--y)-(y--)

D.x=y*4/2

377.能正确表示逻辑关系:" a≥10或a≤0 "的C语言表达式是

A.a>=10 or a<=0

B.a>=0 | a<=10

C.a>=10 && a<=0

D.a>=10 || a<=0

378.C程序的基本结构单位是

A.文件 B.语句 C.函数 D.表达式

379.设有说明:char w; int x; float y; double z; 则表达式w*x+z-y值的数据类型为

380.已定义两个字符数组a,b,则以下正确的输入格式是

("%s%s", a, b);

(a, b);

("%s%s", &a, &b);

("a"),gets("b");

- 35 -

381.C语言中,逻辑"真"等价于

A.大于零的数

B.非零的数

C.大于零的整数

D.非零的整数

382.函数调用:strcat(strcpy(str1,str2),str3)的功能是

A.将串str1复制到串str2中后再连接到串str3之后

B.将串str1连接到串str2之后再复制到串str3之后

C.将串str2连接到串str1之后再将串str1复制到串str3中

D.将串str2复制到串str1中后再将串str3连接到串str1之后

383.任何一个C语言的可执行程序都是从____开始执行的.

A.程序中的第一个函数

( )函数的入口处

C.程序中的第一条语句

D.编译预处理语句

384.下面叙述中错误的是

A.函数的形式参数,在函数未被调用时就不被分配存储空间

B.若函数的定义出现在主调函数之前,则可以不必再加说明

C.若一个函数没有return语句,则什么值也不会返回

D.一般来说,函数的形参和实参的类型要一致

385.在一个C源程序文件中,若要定义一个只允许本源文件中所有函数使用的全局变量,则该变量需要使用的存储类型是

er

386.若有以下定义和语句:

int a[10]={1,2,3,4,5,6,7,8,9,10}, *p=a;

不能表示a数组元素的表达式是

A.*p B.a[9] C.*p++ D.a[*p-a]

387.C语言函数的隐含存储类别是

er

388.下面说法中错误的是

A.共用体变量的地址和它各成员的地址都是同一地址

B.共用体内的成员可以是结构变量,反之亦然

C.在任一时刻,共用体变量的各成员只有一个有效

D.函数可以返回一个共用体变量

389.设变量定义为"int x, *p=&x;",则&(*p)相当于

A.p B.*p C.x D.*(&x)

390.以下程序的执行结果是main()

{ int x = 0, s = 0;

while( !x != 0 ) s += ++x;

printf( "%d ",s ); }

A.0 B.1 C.语法错误 D.无限循环

391.执行下列程序段后,m的值是________.

int w=2,x=3,y=4,z=5,m;

m=(w

- 36 -

m=(m

m=(m

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

392.C语言的switch语句中case后

A.只能为常量

B.只能为常量或常量表达式

C.可为常量或表达式或有确定值的变量及表达式

D.可为任何量或表达式

393.C语言的if语句中,用作判断的表达式为

A.任意表达式

B.逻辑表达式

C.关系表达式

D.算术表达式

394.C 语言程序的三种基本结构是顺序结构、选择结构和______结构.

A.循环 B.递归 C.转移 D.嵌套

395.若变量已正确定义且 k 的值是 4,计算表达式 ( j =4, k--) 后,j和k的值为

A.j=3, k=3 B.j=3, k=4 C.j=4, k=4 D.j=4, k=3

396.下列语句定义pf为指向float类型变量f的指针,_____是正确的.

f, *pf = f; f, *pf = &f;

*pf = &f, f; f, pf

397.设变量定义为"int a, b;",执行下列语句时,输入_____,则a和b的值都是10.

scanf("a=%d, b=%d",&a, &b);

A.10 10

B.10, 10

C.a=10 b=10

D.a=10, b=10

398.C语言源程序名的后缀是

A..exe B..c C..obj D..cp

399.以下关于long、int和short类型数据占用内存大小的叙述中正确的是

A.均占4个字节

B.根据数据的大小来决定所占内存的字节数

C.由用户自己定义

D.由C语言编译系统决定

400.若变量均已正确定义并赋值,以下合法的C语言赋值语句是

A.x=n/2.5; B.x==5; C.x+n=I; D.5=x=4+1;

401.已知字符'A'的ASCⅡ代码值是65,字符变量c1的值是'A',c2的值是'D'.执行语句printf("%d,%d",c1,c2-2);后,输出结果是

A.A,B B.A,68 C.65,66 D.65,68

402.以下叙述中错误的是

A.用户所定义的标识符允许使用关键字

B.用户所定义的标识符应尽量做到"见名知意"

C.用户所定义的标识符必须以字母或下划线开头

D.用户定义的标识符中,大、小写字母代表不同标识

403.以下叙述中错误的是

- 37 -

A.可以通过typedef增加新的类型

B.可以用typedef将已存在的类型用一个新的名字来代表

C.用typedef定义新的类型名后,原有类型名仍有效

D.用typedef可以为各种类型起别名,但不能为变量起别名

404.下列( )表达式的值为真,其中a=5;b=8;c=10;d=0

A.a*2>8+2 B.a&&d C.(a*2-c)||d D.a-b

405.下列字符数组长度为5的是

a[]={'h', 'a', 'b', 'c', 'd'};

b[]= {'h', 'a', 'b', 'c', 'd', '0'};

c[10]= {'h', 'a', 'b', 'c', 'd'};

d[6]= {'h', 'a', 'b', 'c', '0' };

406.从循环体内某一层跳出,继续执行循环外的语句是

语句 语句 ue语句 D.空语句

407.下列数据中属于"字符串常量"的是

B."ABC" C.'ABC' D.'A'

408.C语言源程序文件经过C编译程序编译连接之后生成一个后缀为( )的可执行文件

A..c B..obj C..exe D..bas

409.若有定义int a[10],*p=a;,则p+5表示

A.元素a[5]的地址

B.元素a[5]的值

C.元素a[6]的地址

D.元素a[6]的值

410.定义结构体的关键字是

f

411.为了避免在嵌套的条件语句if—else中产生二义性,C语言规定:else总与( )配对

A.缩排位置相同的if

B.其之前最近的未配对的if

C.其之后最近的if

D.同一行上的if

412.下列正确的标识符是

A._do B.6a C.%y D.a+b

413.设有说明:char c; int x; double z;则表达式c*x+z值的数据类型为

414.下列说法中错误的是

A.一个数组只允许存储同种类型的变量

B.如果在对数组进行初始化时,给定的数据元素个数比数组元素个数少时,多余的数组元素会被自动初始化为最后一个给定元素的值

C.数组的名称其实是数组在内存中的首地址

D.当数组名作为参数被传递给某个函数时,原数组中的元素的值可能被修改

415.判断两个字符串是否相等,正确的表达方式是

A.s1==s2 B.s1=s2 (s1,s2)==0 (s1,s2)=0

416.下面叙述中错误的是

- 38 -

A.主函数中定义的变量在整个程序中都是有效的

B.在其它函数中定义的变量在主函数中也不能使用

C.形式参数也是局部变量

D.复合语句中定义的变量只在该复合语句中有效

417.C语言函数内定义的局部变量的隐含存储类别是

er

418.有定义:char*p1,*p2;则下列表达式中正确合理的是

A.p1/=5 B.p1*=p2 C.p1=&p2 D.p1+=5

419.若int a=2,则执行完表达式a-=a+=a*a后,a的值是

A.-8 B.-4 C.-2 D.0

420.算术运算符、赋值运算符和关系运算符的运算优先级按从高到低顺序依次为

A.算术运算、赋值运算、关系运算

B.关系运算、赋值运算、算术运算

C.算术运算、关系运算、赋值运算

D.关系运算、算术运算、赋值运算

421.以下程序的执行结果是_______.

main()

{ int num = 0;

while( num <= 2 ) { num++; printf( "%d,",num ); } }

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

422.以下程序的执行结果是________.

main()

{ int w = 1, x = 2, y = 3, z = 4;

w =( w < x ) ? x : w;

w =( w < y ) ? y : w;

w =( w < z ) ? z : w;

printf( "%d " , w );}

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

423.以下程序的输出结果是________.

void fun(int a, int b, int c)

{ a=456; b=567; c=678; }

main()

{ int x=10, y=20, z=30;

fun(x, y, z);

printf("%d,%d,%dn", z, y, x);}

A.30,20,10 B.10,20,30 C.456567678 D.678567456

424.若x=2,y=3则x||y的结果是

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

425.C语言中,switch后的括号内表达式的值可以是

A.只能为整型

B.只能为整型,字符型,枚举型

C.只能为整型和字符型

D.任何类型

426.下面叙述中正确的是

- 39 -

A.对于用户自己定义的函数,在使用前必须加以声明

B.声明函数时必须明确其参数类型和返回类型

C.函数可以返回一个值,也可以什么值也不返回

D.空函数在不完成任何操作,所以在程序设计中没有用处

427.对于定义,char *aa[2]={"abcd","ABCD"},选项中说法正确的是

数组元素的值分别是"abcd"和"ABCD"

是指针变量,它指向含有两个数组元素的字符型一维数组

数组的两个元素分别存放的是含有4个字符的一维字符数组的首地址

数组的两个元素中各自存放了字符'a'和'A'的地址

428.以下正确的字符串常量是

A."" B.'abc' cGames D.'A'

429.如果int a=2,b=3,c=0,下列描述正确的是

A.a>b!=c和a>(b!=c)的执行顺序是一样的

B.!a!=(b!=c)表达式的值为1

C.a||(b=c)执行后b的值为0

D.a&&b>c的结果为假

430.若有如下定义和语句,且0<=i<5,下面( )是对数值为3数组元素的引用

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

p=a;

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

431.字符串指针变量中存入的是

A.字符串 B.字符串的首地址 C.第一个字符 D.字符串变量

432.为表示关系x≥y≥z,应使用C语言表达式

A.(x>=y)&&(y>=z)

B.(x>=y) AND (y>=z)

C.(x>=y>=z)

D.(x>=z)&(y>=z)

433.C语言源程序文件经过C编译程序编译后生成的目标文件的后缀为

A..c B..obj C..exe D..bas

434.若变量已正确定义,执行语句scanf("%d,%d,%d ",&k1,&k2,&k3);时,___是正确的输入

A.2030,40 B.20 30 40 C.20, 30 40 D.20,30,40

435.C语言中while和do—while循环的主要区别是

的循环控制条件比do—while的循环控制条件严格

—while的循环体至少无条件执行一次

—while允许从外部转到循环体内

—while循环体不能是复合语句

()

{int x=1,a=0,b=0;

switch (x)

{ case 0: b++;

case 1: a++;

case 2: a++;b++;}

printf("a=%d,b=%d",a,b);}

- 40 -

该程序的输出结果是( )

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

437.定义共用体的关键字是

f

438.下列关于指针定义的描述,___________是错误的

A.指针是一种变量,该变量用来存放某个变量的地址值的

B.指针是一种变量,该变量用来存放某个变量的值

C.指针变量的类型与它所指向的变量类型一致

D.指针变量的命名规则与标识符相同

439.设a和b均为double型常量,且a=5.5、b=2.5,则表达式(int)a+b/b的值是______。

A.6.500000 B.6 C.5.500000 D.6.000000

440.已知i、j、k为int型变量,若从键盘输入:1,2,3<回车>,使i的值为1、j的值为2、k的值为3,以下选项中正确的输入语句是______。

("%2d%2d%2d",&i,&j,&k);

("%d %d %d",&i,&j,&k);

("%d,%d,%d",&i,&j,&k);

("i=%d,j=%d,k=%d",&i,&j,&k);

441.若有以下程序：

main()

{

int k=2,i=2,m;

m=(k+=i*=k);

printf("%d,%dn",m,i);

}

执行后的输出结果是______。

A.8，6 B.8，3 C.6，4 D.7，4

442.设a、b、c、d、m、n均为int型变量，且a=5、b=6、c=7、d=8、m=2、n=2，则逻辑表达式(m=a>b)&&(n=c>d)运算后，n的值为______。

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

443.t为int类型，进人下面的循环之前，t的值为0

while( t=1 )

{ ……}

则以下叙述中正确的是______。

A.循环控制表达式的值为0

B.循环控制表达式的值为1

C.循环控制表达式不合法

D.以上说法都不对

444.以下程序中，while循环的循环次数是______

main()

{

int i=0;

while(i<10)

{

if(i<1) continue;

- 41 -

if(i==5) break;

i++;

}

}

A.1 B.4 C.6 D.死循环，不能确定次数

445.以下函数的类型是______。

fff(float x)

{

return 5;

}

A.与参数x的类型相同 类型 类型 D.无法确定

446.结构化程序由三种基本结构组成，三种基本结构组成的算法______。

A.可以完成任何复杂的任务

B.只能完成部分复杂的任务

C.只能完成符合结构化的任务

D.只能完成一些简单的任务

447.下列关于单目运算符++、--的叙述中正确的是______。

A.它们的运算对象可以是任何变量和常量

B.它们的运算对象可以是char型变量和int型变量，但不能是float型变量

C.它们的运算对象可以是int型变量，但不能是double型变量和float型变量

D.它们的运算对象可以是char型变量、int型变量和float型变量

448.有以下程序段

int n=0,p;

do

{

scanf("%d",&p);

n++;

}while(p!=12345&&n<3);

此处do-while循环的结束条件是______。

A.p的值不等于12345并且n的值小于3

B.p的值等于12345并且n的值大于等于3

C.p的值不等于12345或者n的值小于3

D.p的值等于12345或者n的值大于等于3

C语言题库答案（选择题）

- 42 -

1~ 6~ 11~ 16~

21~ 26~ 31~ 36~

41~ 46~ 51~ 56~

61~ 66~ 71~ 76~

81~ 86~ 91~ 96~

101~ 106~ 111~ 116~

121~ 126~ 131~ 136~

141~ 146~ 151~ 156~

161~ 166~ 171~ 176~180. BDCAD

181~ 186~ 191~

201~ 206~ 211~

221~ 226~ 231~

241~ 246~ 251~

261~ 266~ 271~

281~ 286~ 291~

301~ 306~ 311~

321~ 326~ 331~

341~ 346~ 351~

361~ 366~ 371~

381~ 386~ 391~

401~ 406~ 411~

421~ 426~ 431~

441~ 446~

- 43 -

196~200. BCADA

216~

236~

256~

276~

296~

316~

336~

356~

376~

396~

416~

436~