c语言程序设计试题库

《C语言程序设计》试题库

一、选择题(共250个，每题2分)

1、一个c语言程序的执行是从（ ） A、本程序的main函数开始，到main函数结束

B、本程序文件的第一个函数开始，到本程序文件的最后一个函数结束 C、本程序的main函数开始，到本程序文件的最后一个函数结束 D、本程序文件的第一个函数开始，到本程序main函数结束 2、一个c语言程序是由（ ）

A、一个主程序和若干子程序组成 B、函数组成 C、若干过程组成 D、若干子函数组成 3、以下选项中是正确的整型常量是( )

A、12． B、 -20 C、 1,000 D、 4 5 6 4、以下选项中正确的实型常量是( )

A、0 B、 3. 1415 C、 0.329*10^2 D、.871 5、以下选项中不合法的实型常量是( )

A、 2.607E-1 B、0.8103*12 C、-77.77 D、456e-2 6、以下选项中不合法的字符串是( )

A、’abc’ B、”12’12” C、 “0” D、” ” 7、下面正确的字符常量是（ ）

A、”c” B、 ‘\\\\’’ C、 ‘w’ D、 ‘’ 8、以下选项中不合法的用户标识符是( )

A、 abc.c B、file C、Main D、PRINTF

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

A、必须为字母 B、 必须为下划线 C、必须为字母或下划线 D、可以是字母、数字和下划线中任意一种字符 10、以下选项中不合法的用户标识符是 ( )

A、_123 B、 printf C、 A$ D、 Dim 11、c语言中运算对象必须是整型的运算符是( )

A、% B、 / C、 ! D、 **

12、可在C程序中用作用户标识符的一组标识符是( )

A、nt B、 as-b3 C、 Fir D、 2c define -123 _bc DO WORD if name SIG

13、若变量已正确定义并赋值，符合C语言语法的表达式是( )

A、 a=a+7; B、a=7+b+c,a++ C、 int(12.3%4) D、 a=a+7=c+b 14、若a,b,c,d都是int类型变量且初值为0，以下选项中不正确的赋值语句是( )

A、a=b=c=100; B、d++; C、c+b; D、d=(c=22)-(b++); 15、若x、i、j和k都是int变量，则计算下面表达式后，x的值是（ ）

x=(i=4,j=16,k=32)

A、4 B、16 C、32 D、 52

16、假设所有变量均为整型，则表达式（a=2,b=5,b++,a+b）的值是（ ）

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

17、若有代数表达式a.b，则正确的c语言表达式是（ ）

A、a^*b^ B、pow(a,2).pow(b,2) C、a*a.b*b D、(a*a)*(b*b) 18、若有代数表达式

22

3ae，则不正确的c语言表达式是（ ） bcA、a/b/c*e*3 B、3*a*e /b/c C、3*a*e /b*c D、a*e/c /b *3 19、 若有定义：int a=8,b=5,c;执行语句c=a/b+0.4;后，c的值为（ ）。

A、1.4 B、1 C、2.0 D、2 20、char型数据在内存中的存储形式是（ ）

A、补码 B、反码 C、原码 D、ASCII码

21、设变量a是整型，f是实型，i是双精度，则表达式10+‘a’+i*f值的数据类型为（ ） A、int B、float C、double D、不确定

22、 若有定义：int a=7;flaot x=2.5,y=4.7;;则表达式x+a%3*(int)(x+y)%2/4的值是（ ）。

A、2.500000 B、2.750000 C、3.500000 D、0.000000

23、 若变量a是int类型，并执行了语句：a=’A’+1.6;则正确的叙述是（ ）。

A、a的值是字符C B、a的值是浮点型

C、不允许字符型和浮点型相加 D、a的值是字符’A’的ASCII值加上1 24.、以下选项中合法的字符常量是（ ）。

A、“B” B、’\\ 010’ C、68 D、D 25、以下选项中不是C语句的是( )

A、{int i;i++;printf(“%d\\n”,i);} B、; C、 a=5,c=10 D、 {;} 26、以下合法的C语言赋值语句是( )

A、a=b=58 B、 k=int(a+b) C、 a=58, b=58 D、 --i; 27、以下程序的输出结果是( )

A、0 B、1 C、3 D、不确定的值 main () {int x=10,y=3;

printf(“%d\\n”,y=x/y); }

28、设c语言中，一个int型数据在内存中占2个字节，则unsigned int 型数据的取值范围为（ ） A、0～255 B、0～32767 C、0～65535 D、0～2147483647

29、若变量已正确定义为int类型，要给a、b、c输入数据，以下正确的输入语句是( )

A、read(a,b,c);

B、scanf(“%d%d%d”a,b,c); C、 scanf(“%D%D%D”,&a,&b,&c); D、scanf(“%d%d%d”,&a,&b,&c);

30、若变量已正确定义为float类型，要通过赋值语句scanf（“%f%f%f”,&a,&b,&c）给A赋值10，B赋

予22，C，赋予33，以下不正确的输入形式是( )

A、 10 B、10.0,22.0,33.0 C、10.0 D、10 22

22 22.0 33.0 33

33

31、设有说明：char w;int x;float y;double z;则表达式w*x+z-y值的数据类型为（ ） A、float B、 char C、int D、 double

32、若变量已正确定义，要将a和b中的数进行交换，下面选项中不正确的是（ ）

A、a=a+b,b=a-b,a=a-b; B、t=a,a=b,b=t; C、a=t;t=b;b=a; D、t=b;b=a;a=t; 33、若变量已正确定义，以下程序段的输出结果是( )

A、输出格式说明与输出项不匹配，输出无定值 B、5.170000 C、5.168000 D、5.169000 x=5.16894;

printf(“%f\\n”,(int)(x*1000+0.5)/(float)1000); 34、若有以下程序段，c3的值是（ ）

A、0 B、1/2 C、0.5 D、1 int c1=1,c2=2,c3; c3=c1/c2;

35、若有以下程序段，其输出结果是（ ）

A、 0,0,-10 B、0,0,5 C、-10,3,-10 D、3,3,-10 int a=0,b=0,c=0; c=(a-=a-5),(a=b,b+3); printf(“%d,%d,%d\\n”,a,b,c);

36、若已知变量的类型说明如下：int k,a,b; unsinged long w=5; double x=1.42;则以下不符合c语言

的表达式是（ ）

A、x%(-3) B、w+=-2 C、k=(a=2,b=3,a+b) D、a+=a-=(b=4)*(a=3) 37、以下程序的输出结果是（ ）

A、a=%2, b=%f B、a=2,b=5 C、a=%%d,b=%%d D、a=%d,b=%d main()

{ int a=2,b=3;

printf(“a=%%d,b=%%d\\n”,a,b); }

38、 若int 类型占两个字节，则以下程序段的输出是（ ）

A、 –1,-1 B、 –1,32767 C、 –1,32768 D、 –1,65535 int a=-1;

printf(“%d,%u\\n”,a,a);

39、下列运算符中优先级最高的运算符是（ ）

A、！ B、% C、-= D、&&

40、下列运算符中优先级最低运算符是（ ）

A、|| B、!= C、〈= D、+

41、为表示关系 x≥y≥z, 应使用的C语言表达式是（ ）

A、 (x>=y)&&(y>=z) B、(x>=y)AND(y>=z) C、 (x>=y>=z) D、(x>=y)&(y>=z)

42、若有以下定义，则能使值为3的表达式是（ ） int k=7,x=12;

A、x%=k-k%5) B、x%=(k%=5) C、 x%=(k-k%5) D、(x%=k)-(k%=5)

43、 设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 44、 假定w、x、y、z、m均为int型变量，有如下程序段： w=1; x=2; y=3; z=4; m=(w

m=(m

m=(m

则该程序运行后，m的值是（ ）。

A、4 B、3 C、1 D、2 45、以下程序的输出是（ ）

A、0 B、1 C、2 D、3 main()

{ int a=2,b=-1,c=2; if(b

printf(“%d\\n”,c); }

46、设a,b 和c 都是int 型变量，且 a=3,b=4,c=5;则以下的表达式中，值为0的表达式是（A、 a&&b B、 a<=b C、 a||b+c&&b-c D、 !((a

A、0 B、1 C、2 D、3 main()

{ int a=2,b=-1,c=2; if(a

48、以下程序的输出是（ ）

A、1 B、2 C、3 D、4 main()

{ int w=4,x=3,y=2,z=1;

printf(“%d\\n”,(w

49、已知int x=10,y=20,z=30;以下语句执行后x,y,z的值是（ ） if(x>y) z=x;x=y;y=z;

A、x=10,y=20,z=30 B、x=20,y=30,z=30 C、x=20,y=30,z=10 D、x=20,y=30,z=20 50、以下程序的运行结果是（ ）

main( ){int m=5;

if(m++>5)printf(“%d\\n”,m); else printf(“%d\\n”,m--); }

A、4 B、5 C、6 D、7

51、若执行以下程序时从键盘上输入3和4，则输出结果是（ ）

A、14 B、16 C、18 D、20 main() { int a,b,s;

scanf(“%d%d”,&a,&b); s=a;

if(a

）

printf(“%d\\n”,s); }

52、运行以下程序，输出（ ）

A、**** B、&&&&

C、####&&&& D、有语法错误不能通过编译 main() { int k=-3;

if(k<=0)printf(“****\\n”); else printf(“&&&&\\n”); }

53、以下程序的输出结果是 （ ）

main() { int x=2,y=-1,z=2; if(x

printf(“%d\\n”,z); }

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

54、为了避免在嵌套的条件语句if-else中产生二义性，c语言规定：else子句总是与（A、上下位置在同一列的if B、else前面最近的if C、else之后最近的if D、同一行上的if 55、以下不正确的语句为（ ）

A、if(x>y); B、if(x==y)&&(x!=0) x+=y ; C、if(x

if(a

A、1 B、2 C、3 D、6

57、以下程序段，int k=10;while(k=0)k=k+1;则下面描述中正确的是（ ）。

A、while循环执行10次 B、循环是无限循环 C、循环体语句一次也不执行 D、循环体语句执行一次 58. 以下程序中，while循环的循环次数是（ ）。 A、1 B、10 C、6 D、死循环，不能确定次数 59、以下程序中，while循环的循环次数是（ ）。 ）配对。

main() { int i=0; while(i<10) { if(i<1) break; i++;} }

main() { int i=0; while(i<10)

{ if(i<1) contimue;

if(i==5) break; i++;} }

A、1 B、10 C、6 D、死循环，不能确定次数 60、若执行以下程序时从键盘上输入9，则输出结果是 ( )

A、 11 B、 10 C、 9 D、 8 main() { int n; scanf(\

if(n++<10) printf(\ else printf(\ }

61、有以下程序段( ) int k=0

while(k= =1)k++; while 循环执行的次数是

A、 无限次 B、 有语法错，不能执行 C、 一次也不执行 D、 执行1次 62、对于下面①，②两个循环语句，（ ）是正确的描述。 ①while(1) ; ②for( ; ; ) ;

A、①②都是无限循环 B、①是无限循环，②错误 C、①循环一次，②错误 D、①②皆错误 63、语句while(!E);中的表达式!E等价于（ ） A、E==0 B、E!=1 C、E!=0 D、E==1 64、下面程序段运行结果是（ ） x=y=0;while(x<15) y++,x=x+(++y); pirntf(“%d,%d”,y,x);

A、20，7 B、6，12 C、20，8 D、8，20 65、设有以下程序段 int x=0,s=0;

while(! x!=0) s+=++x;

printf(“%d”,s); 则（ ）

A、运行程序段后输出0 B、运行程序段后输出1 C、程序段中的控制表达式是非法的 D、程序段执行无限次 66、下面程序段的运行结果是（ ）

int n=0; while(n++<=2); printf(“%d”,n);

A、2 B、3 C、4 D、有语法错误 67、下面程序的运行结果是（ ） #include

main( ){ int num=0; while(num<=2)

{num++;printf(“%d ”,num);} }

A、1 B、1 2 C、1 2 3 D、1 2 3 4 68、c语言中while和do-while循环的主要区别是（ ） A、do-while的循环体至少无条件执行一次

B、while的循环控制条件比do-while的循环控制条件严格 C、do-while允许从外部转到循环体内

D、do-while的循环体不能是复合语句 69、下面有关for循环的正确描述是（ ） A、for循环只是能用于循环次数已经确定的情况

B、for循环是先执行循环体语句，后判断表达式 C、在for循环中，不能用break语句跳出循环体

D、for循环的循环体语句中，可以包含多条语句，但必须用花括号括起来 70、对for(表达式1； ；表达式3)可以理解为（ ）

A、for(表达式1；0；表达式3) B、for(表达式1；表达式1；表达式3

C、for(表达式1；1；表达式3) D、for(表达式1;表达式3；表达式3) 71、若i为整型变量，则以下循环执行次数是（ ） for(i=2;i==0;) printf(“%d”,i--);

A、无限次 B、0次 C、1次 D、2次 72、下面程序的运行结果是（ ）

#include main( ){ int y=10;

do { y--;} while(--y); printf(“%d\\n”,y--); }

A、-1 B、1 C、8 D、0 73、下面程序的运行结果是（ ）

#include main( ){ int a=1,b=10;

do { b-=a;a++;} while(b--<0); printf(“a=%d,b=%d\\n”,a,b); }

A、a=3,b=11 B、a=2,b=8 C、a=1,b=-1 D、a=4,b=9 74、下面程序段的运行结果是（ ）

for(y=1;y<10;) y=((x=3*y,x+1),x-1); printf(“x=%d,y=%d”,x,y);

A、x=27,y=27 B、x=12,y=13 C、x=15,y=14 D、x=y=27 75、下列程序段不是死循环的是（ ）

A、 int i=100; while(1){i=i0+1;if(i>100)break;} B、for(;;) C、int k=0; do{++k;} while(k==0); D、int s=36;while(s);--s; 76、以下程序段输出结果是（ ）

A、 9 B、1 C、11 D、10 int k, j, s; for (k=2;k<6;k++,k++) { s=1;

for(j=k; j<6;j++) s+=j; }

printf(“%d\\n”,s);

77、以下程序段输出结果是( )

A、12 B、15 C、20 D、25 int i, j,m=0; for (i=1;i<=15;i+=4)

for(j=3;j<=19;j+=4) m++;

printf(“%d\\n”,m);

78、以下程序段输出结果是( )

A、10 B、9 C、 10 D、9

9 8 9 8 8 7 8 7

7 6

int n=10; while(n>7) { n--;

printf(“%d\\n”,n); }

79、以下程序段输出结果是( )

A、 1 B、3 0 C、1 –2 D、死循环 int x=3; do

{ printf(“=” , x-=2);} while(!(--x));

80、以下程序段输出结果是( )

A、15 B、14 C、不确定 D、0 main()

{ int i, sum;

for(i=1;i<6;i++) sum+=sum; printf(“%d\\n”,sum); }

81、以下程序的输出结果是 ( )

A、741 B、852 C、963 D、875421 main()

{ int y=10;

for(; y>0;y--) if(y%3==0)

{ printf (“%d”,--y) ;continue; } }

82、若x是int型变量，以下程序段的输出结果是( )

A、 **3 B、##3 C、##3 D、**3##4

##4 **4 **4##5 **5 **5 ##5 for(x=3; x<6;x++)

printf ((x%2)?(“**%d”):(“##%d\\n”),x); 83、以下程序的输出结果是( )

A、*#*#*#$ B、#*#*#*$ C、*#*#$ D、#*#*$ main() { int i;

for(i=1; i<=5; i++) { if (i%2) printf(“*”);

else continue; printf(“#”); }

printf(“$\\n”); }

84、 以下叙述不正确的是( )

A、do-while语句构成的循环不能用其他语句构成的循环来代替。 B、do-while语句构成的循环只能用break语句退出。

C、用do-while语句构成循环时，只有在while后的表达式为非零时结束循环。 D、用do-while语句构成循环时，只有在while后的表达式为零时结束循环 85、C语言中的简单数据类型有（ ）

A、 整型、实型、逻辑型 B、 整型、实型、字符型 C、 整型、字符型、逻辑型 D、 整型、实型、逻辑型、字符型 86、C语言中，字符（char）型数据在微机内存中的存储形式是（ ） A、 反码 B、 补码 C、 EBCDIC码 D、 ASCII码 87、设有定义语句char a=‘\\72’；，则变量a( ) A、 包含1个字符 B、 包含2个字符 C、 包含3个字符 D、 包含4个字符 88、C语言中不合法的字符常量是（ ） 89、C语言中不合法的字符串常量是（ ）

A、“121” B、‘y=’ C、 “\\n\\n” D、“ABCD\\x6d”

90、判断char型变量c是否为大写字母的最简单且正确的表达式是：（ ） A、‘A’<=c<=‘Z’ B、 ( c>=‘A’)&（c<=‘Z’） C、(‘A’<=c )AND(‘Z’>=c) D、 ( c>=‘A’)&&（c<=‘Z’） 91、以下程序的输出结果是（ ）

A、因输出格式不合法，无正确输出 B、65,90 C、A,Y D、65,89 main()

{char c1=’A’,c2=’Y’; printf(“%d,%d\\n”,c1,c2); }

92、以下程序段的输出结果是（ ）

A、A B、a C、Z D、z main()

{ char x=’A’;

x=(x>=’A’&&x<=’Z’)?(x+32):x; printf(“%c\\n”,x); }

93、以下程序的输出结果是（ ）

A、67,C B、B,C C、C,D D、不确定的值 main()

{char ch1,ch2; ch1=’A’+’5’-‘3’; ch2=’A’+’5’-‘3’;

A、‘\\xff’ B、‘\\65’ C、‘&’ D、‘\\028’

printf(“%d,%c\\n,”ch1,ch2”); } 94、以下程序的输出结果使（ ） A、11 B、20 C、21 D、31 func(int a,int b) {int c; c=a+b; return c; } main()

{ int x=6,y=7,z=8,r; r=func((x--,y++,x+y),z--); printf(“%d\\n”,r); }

95、以下程序的输出结果是（ ） A、-1 B、0 C、1 D、2 main() { int i=2,p; p=f(i,i+1);

printf(“%d\\n”,p); } int f(int a,int b) { int c; c=a;

if(a>b) c=1; else if(a==b) c=0; else c=-1; return(c); }

96、以下程序的输出结果使（ ）

A、0 B、1 C、6 D、无定值 fun( int a, int b, int c) { c=a*b; } main() { int c; fun(2,3,c);

printf(“%d\\n”,c); }

97、以下程序的输出结果是（ ）

A、5.500000 B、3.000000 C、4.000000 D、8.25 double f(n)

{ int i; double s;s=1.0; for(i=1; i<=n; i++) s+=1.0/i; return s; } main()

{ int i,m=3; float a=0.0; for(i=0;i

A、因变量无定义输出不定值 B、0 C、-1 D、1

#include “stdio.h” main()

{ printf(“%d\\n”,NULL) ;} 99、以下程序的输出结果是

A、5,2,3 B、-5,-12,-7 C、-5,-12,-17 D、5,-2,-7 void sub(int x, int y, int *z) { *z=y-x;} main()

{ int a,b,c;

sub(10,5,&a); sub(7,a,&b); sub(a,b,&c); printf(“%d,%d,%d\\n”,a,b,c); } 100、以下程序的输出结果是( )

A、4 B、6 C、8 D、10 main()

{ int k=2, m=4, n=6; int *pk=&k,*pm=&m,*p; *(p=&n)=*pk*(*pm) printf(“%d\\n”,n); } 101、以下程序的输出结果是( )

A、 4,3 B、2,3 C、 3,4 D、 3,2 void fun (float *a, float *b) { float w ; *a= *a+*a;

w=*a; *a=*b; *b=w; } main()

{ float x=2.0, y=3.0; float *px=&x, *py=&y; fun(px,py);

printf(“%2.0f,%2.0f\\n”,x,y);} 102、以下程序的输出结果是( )

A、 9.000000 B、 1.500000 C、 8.000000 D、 10.500000 void sub (float x, float *y, float *z) { *y= *y-1.0; *z= *z+x;} main()

{ float a=2.5,b=9.0 , *pa, *pb; pa=&a; pb=&b; sub (b-a, pa , pa); printf (“%f\\n”, a);}

103、在c语言中，引用数组元素时，其数组下标的数据类型允许是（ ） A、整型常量 B、整型表达式 C、整型常量或整型表达式 D、任何类型的表达式

104、以下对一维整型数组a的正确说明是（ ）

A、int a(10); B、int n;scanf(“%d”,&n);int a[n];

C、int n=10,a[n]; D、#define SIZE 10 int [SIZE]; 105、以下能对一维数组a进行正确初始化的语句是( )。

A、int a[10]=(0,0,0,0,0); B、int a [10]={}; C、int a[]={10，12，56}; D、int a[]={‘10*1’}; 106、以下对二维数组a的正确说明是( )。

A、int a[3][]; B、float a (3,4); C、double a[1][4]; D、float a(3)(4); 107、若有说明：int a[3][4];则对a数组元素的正确引用是 ( ) 。

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

108、若有说明：int a[3][4];则对a数组元素的非法引用是( )。

A、a[0][2*1] B、a[1][3] C、a[4-2][0] D、a[0][4] 109、以下能对二维数组a进行正确初始化的语句是( )。

A、int a[2][]={{1,0,1},{5,2,3}}; B、int a[][3]={{1,2,3},{4,5,6}}; C、int a[2][4]={1,2,3},{4,5}{6}}; D、int a[][3]={{1,0,1}{},{1,1}}; 110、以下不能对二维数组a进行正确初始化的语句是( )。

A、int a[2][3]={0}; B、int a[][3]={{1,2},{0}}; C、int a[2][3]={{1,2},{3,4},{5,6}}; D、int a[][3]={1,2,3,4,5,6}; 111、 若有说明：int a[3][4]={0};则下面正确的叙述是( )。

A、只有元素a[0][0]可得到初值0 B、数组a中每个元素均可得到初值0 C、数组a中各元素都可得到初值，但不一定为0 D、此说明语句不正确 112、 若有说明：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

113、若二维数组a有m列，则计算任一元素a[i][j]在数组中位置的公式为( )。(假设a[0][0]位于

数组的第一个位置上。)

A、i*m+j B、j*m+I C、i*m+j-1 D、i*m+j+1 114、对以下说明语句的正确理解是( )。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、因为数组长度与初值的个数不相同，所以此语句不正确 115、若有说明：int a[][3]={1,2,3,4,5,6,7};则a数组第一维的大小是( )。

A、2 B、3 C、4 D、无确定值 116、定义如下变量和数组：

int k;

int a[3][3]={1,2,3,4,5,6,7,8,9}; 则下面语句的输出结果是( )。

for (k=0;k<3;k++)printf(“%d”,a[k][2-k]);

A、3 5 7 B、3 6 9 C、1 5 9 D、1 4 7 117、下面是对s的初始化，其中不正确的是( )。

A、char s[5]={“abc”}; B、char s[5]={‘a’,’b’,’c’}; C、char s[5]=””; D、char s[5]=”abcdef”; 118、下面程序段的运行结果是( )。

char c[5]={‘a’,’b’,’\\0’,’c’,’\\0’}; printf(“%s”,c);}

A、’a’’b’ B、ab C、ab＿c D、ab (其中＿表示空格)

119、对两个数组a和b进行如下初始化

char a[]=”ABCDEF”;

char b[]={‘A’,’B’,’C’,’D’,’E’,’F’}; 则以下叙述正确的是( )。

A、a与b数组完全相同 B、a与b长度相同 C、a和b中都存放字符串 D、a数组比b数组长度大 120、有两个字符数组a、b，则以下正确的输入语句是( )。

A、gets(a,b); B、scanf(“%s%s”,a,b); C、scanf(“%s%s”,&a,&b); D、gets(“a”),gets(“b”); 121、有字符数组a[80]和b[80]，则正确的输出语句是( )。

A、puts(a,b); B、printf(“%s,%s”,a[],b[]); C、putchar(a,b); D、puts(a),puts(b); 122、有下面的程序段

char a[3],b[]=”China”;

a=b; printf(“%s”,a); 则( )。

A、运行后将输出China B、运行后将输出Ch C、运行后将输出Chi D、编译出错 123、判断字符串a和b是否相等，应当使用( )。

A、if(a= =b) B、if(a=b) C、if(strcpy(a,b)) D、if(strcmp(a,b)) 124、判断字符串s1是否大于字符串s2，应当使用( )。

A、if(s1>s2) B、if(strcmp(s1,s2)) C、if(srtcmp(s2,s1)>0) D、if(strcmp(s1,s2)>0) 125、下述对C语言字符数组的描述中错误的是( )。

A、字符数组可以存放字符串

B、字符数组的字符串可以整体输入、输出

C、可以在赋值语句中通过赋值运算符“=”对字符数组整体赋值 D、不可以用关系运算符对字符数组中的字符串进行比较 126、以下正确的说法是( )。建立函数的目的之一是

A、提高程序的执行效率 B、提高程序的可读性 C、减少程序的篇幅 D、减少程序文件所占内存 127、以下正确的说法是( )。

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

B、用户可以重新定义标准库函数，若如此，该函数将失去原有含义 C、系统根本不允许用户重新定义标准库函数

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

128、以下正确的函数定义形式是( )。

A、double fun(int x,int y) B、double fun(int x;int y) C、double fun(int x,int y); D、double fun(int x,y); 129、以下正确的函数形式是( )。

A、double fun(int x,int y) {z=x+y;return z;} B、fun(int x,y) {int z; return z;}

C、fun(x,y) {int x,y;double z; z=x+y;return z;} D、double fun(int x,int y) {double z; z=x+y;return z;}

130、以下正确的说法是( )。在C语言中

A、实参和与其对应的形参各占用独立的存储单元 B、实参和与其对应的形参共占用一个存储单元

C、只有当实参和与其对应的形参同名时才共占用存储单元 D、形参是虚拟的，不占用存储单元

131、以下不正确的说法是( )。C语言规定

A、实参可以是常量、变量或表达式 B、形参可以是常量、变量或表达式 C、实参可以为任意类型 D、形参应与其对应的实参类型一致 132、以下正确的说法是( )。

A、定义函数时，形参的类型说明可以放在函数体内 B、return后边的值不能为表达式

C、如果函数值的类型与返回值类型不一致，以函数值类型为准 D、如果形参与实参的类型不一致，以实参类型为准

133、 C语言允许函数值类型缺省定义，此时该函数值隐含的类型是( )。

A、float型 B、int型 C、long型 D、double型 134、 C语言规定，函数返回值的类型是由( )。

A、return语句中的表达式类型所决定 B、调用该函数时的主调函数类型所决定 C、调用该函数时系统临时决定

D、在定义该函数时所指定的函数类型所决定 135、下面函数调用语句含有实参的个数为( )。

Func((exp1,exp2),(exp3,exp4,exp5));

A、1 B、2 C、4 D、5 136、以下错误的描述是( )。函数调用可以

A、出现在执行语句中 B、出现在一个表达式中 C、做为一个函数的实参 D、做为一个函数的形参 137、以下正确的描述是( )。在C语言程序中

A、函数的定义可以嵌套，但函数的调用不可以嵌套 B、函数的定义不可以嵌套，但函数的调用可以嵌套 C、函数的定义和函数的调用均不可以嵌套 D、函数的定义和函数的调用均可以嵌套

138、若用数组名作为函数调用的实参，传递给形参的是( )。

A、数组的首地址 B、数组第一个元素的值 C、数组中全部元素的值 D、数组元素的个数

139、 已有以下数组定义和f函数调用语句，则在f函数的说明中，对形参的说明中，对形参数组array

的错误定义方式为 （ ） int a[3][4]; f(a);

A、f(int array[ ][6]) B、f(int array[3][ ]) C、f(int array[ ][4]) D、f(int array[2][5]) 140、 若使用一维数组名作参数，则以下正确的说发是 （ ） A、必须在主调函数中说明此数组的大小 B、实参数组类型与形参数组类型可以不匹配

C、在被调函数中，不需要考虑形参数组的大小 D、实参数组名与形参名必须一致

141、 以下正确的说法是（ ）

如果在一个函数中的复合语句中定义了一个变量，则该变量 A、只在复合语句中有效 B、在该函数中有效 C、在本程序范围内均有效 D、为非法变量 142、以下不正确的说法是（ ）

A、在不同的函数中可以使用相同名字的变量 B、形式参数是局部变量

C、在函数内定义的变量只能在本函数范围内使用 D、在函数内的复合语句中定义的变量在本函数范围内有效

143、 凡是函数中未指定存储类别的局部变量，其隐含的存储类别为（ ） A、自动（auto）B、静态（static）C、外部（extern）D、寄存器（register） 144、 以下程序的运行结果是（ ） sub(int x,int y,int *z)

{*z=y-x;} main() { int a,b,c;

sub(10,5,&a);sub(7,a,&b);sub(a,b,&c);} printf(“M,M,M\\n”,a,b,c); }

A、5， 2， 3 B、-5，-12，-7 C、-5，-12，-17 D、5，-2，-7 145、 以下程序能对两个整型变量的值进行交换。以下正确的说法是（ ） main(){ int a=10,b=20;

printf(“(1)a=%d,b=%d\\n”,a,b); swap(&a,&b);

printf(“(2)a=%d,b=%d\\n”,a,b); } swap( int p,int q) {int t; t=p;p=q;q=t;}

A、该程序完全正确 B、该程序有错，只要将语句swap(&a,&b);中的参数改为a,b即可 C、该程序有错，只要将swap()函数中的形参p和q以及t均定义为指针变量即可。 D、以上说法都不正确

146、 以下程序中调用scanf函数给变量a输入数值的方法是错误的，其错误原因是（ ） main(){ int *p,*q,a,b;

p=&a;printf(“input a:”); scanf(“%d”,*p); ??}

A、*p表示的是指针变量p的地址

B、*p表示的是变量a的值，而不是变量a的地址 C、*p表示的是指针变量p的值 D、*p只能用来说明p是一个指针变量

147、 已有定义 int k=2;int *prt1,*prt2;且prt1和prt2均已指向变量k,下面不能正确执行的赋值语句是（ ）

A、k=*prt1+*prt2 B、prt2=k; C、prt1=prt2; D、k=*prt1*(*prt2); 148、 若有说明：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;

149、 设p1和p2是指向同一个字符串的指针变量，c为字符变量，则以下不能正确执行的赋值语句是（ ）

A、c=*p1+*p2; B、p2=c; C、p1=p2; D、c=*p1*(*p2) 150、 下面判断正确的是（ ）

A、char *a=”china”;等价于char *a;*a=”china”;

B、char str[10]={“china”};等价于char str[10];str[]={”china”}; C、char *a=”china”;等价于char *s;s=”china”;

D、char c[4]=”abc”,d[4]=”abc”;等价于char c[4]=d[4]=”abc”; 151、 下面能正确进行的字符串赋值操作的是（ ）

A、char s[5]={“ABCDE”};B、char s[5]={‘A’,’B’,’C’,’D’,’E’}; C、char *s;s=”ABCDE”; D、char *s;scanf(“%s”,s); 152、 若有以下定义，则对a数组元素的正确因用是（ ） int a[5],*p=a;

A、*&a[5] B、a+2 C、*(p+5) D、*(a+2)

153、 若有定义：int a[2][3];则对a数组的第i行第j列元素值得正确引用为（ ） A、*(*(a+i)+j) B、(a+i)[j] C、*(a+i+j) D、*(a+i)+j 154、 若有以下定义和语句，则对a数组元素地址的正确引用为（ ） int a[2][3],(*p)[3]; p=a;

A、*(p+2) B、p[2] C、p[1]+1 D、(p+1)+2 155、 以下与int *q[5];等价的定义语句是（ ）

A、int q[5]; B、int *q; C、int *(q[5]) D、int (*q)[5]

156、 若有定义int a[]={2,4,6,8,10,12,14,16,18,20,22,24},*q[4],k;则下面程序段的输出是（ for(k=0;k<4;k++) q[k]=&a[k*3]; printf(“%d\\n”,q[3][0]);

A、8 B、16 C、20 D、输出项不合法，结果不确定 157、 语句int (*prt)();的含义是（ ）

A、prt是指向一维数组的指针变量 B、prt是指向int型数据的指针变量

C、prt是指向函数的指针，该函数返回一个int型数据

D、prt是一个函数名，该函数的返回值是指向int型数据的指针 158、库函数strcpy用以复制字符串。若有以下定义和语句：

char str1[]=”string”,str2[8],*str3,*str4=”string”; 则对库函数strcpy的不正确调用是( )

A、 strcpy(str1,”HELLO1”); B、 strcpy(str2,”HELLO2”); C、 strcpy(str3,”HEELO3”); D、 strcpy(str4,”HELLO4”); 159、若已定义：

int a[]={0,1,2,3,4,5,6,7,8,9},*p=a,i;

其中0<=i<=9,则对a数组元素的引用不正确的是( ) A、a[p-a] B、 *(&a[i]) C、p[i] D、*(*(a+i)) 160、以下程序段给数组所有元素输入数据，应在下划线处填入的是

A、a+(i++) B、 &a[i+1] C、a+i D、&a[++i] main()

{int a[10], i=0;

while(i<10)scanf(“%d”,___): ??}

161、以下程序的输出结果是( )

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

） main()

{ int a[10]={1,2,3,4,5,6,7,8,9,10}, *p=a; printf(“%d\\n”,*(p+2) ); }

162、以下程序的输出结果是( )

A、不确定的值 B、3 C、2 D、 1 main()

{ int n[2]={0},i,j,k=2; for(i=0; i

for(j=0; j

163、以下程序的输出结果是 ( )

A、 17 B、 18 C、 19 D、 20 main()

{ int a[]={2,4,6,8,10}, y=1, x,*p; p=&a[1];

for(x=0; x<3; x++) y+=*(p+x); printf(“%d\\n”,y); }

164、以下程序的输出结果是( )

A、 6 B、8 C、 4 D、2 main()

{ int a[]={2,4,6,8}, *p=a, i; for(i=0; i<4; i++) a[i]=*p++; printf(“%d\\n”,a[2]); }

165、以下程序的输出结果是（ ）

A、 720 B、120 C、24 D、6 f(int b[ ],int n) {int i,r=1;

for(i=0;i<=n;i++) r=r*b[i]; return r;} main(){

int x, a[ ]={2，3，4，5，6，7，8，9}; x=f(a,3);

printf(“%d\\n”,x);}

166、以下程序中若第一个printf语句输出的是194，则第二个printf语句的输出结果是（A、212 B、204 C、1a4 D、1a6 main()

{int a[]={1,2,3,4,5,6,7,8,9,0},*p; p=a;

printf(\printf(\

） 167、以下程序的输出结果是 （ ） A、 4 4 B、2 2 C、2 4 D、4 6 main(){

int a[5]={2,4,6,8,10},*p,**k; p=a; k=&p;

printf(\printf(\

168、当运行以下程序时输入三行，每行都是在第一列上开始，代表回车键； a b cdef

则程序的输出结果是 ( )

A、abcdef B、 a C、a D、a

b b b c cd cdef d e f

#include \#define N 6 main(){ char c[N]; int i=0;

for(i=0;i

int c[4][5], (*cp)[5]; cp=c; 则对c数组元素的引用正确的是( )

A、 cp+1 B、*(cp+3) C、*(cp+1)+3 D、*(*cp+2) 170、若已定义：

int a[4][3]={1,2,3,4,5,6,7,8,9,10,11,12},(*prt)[3]=a,*p=a[0]; 则能够正确表示数组元素a[1][2]的表达式是( )

A、 *((*prt+1)[2]) B、*(*(p+5)) C、(*prt+1)+2 D、*(*(a+1)+2) 171、若有定义和语句：

int a[4][3]={1,2,3,4,5,6,7,8,9,10,11,12},(*prt)[3]=a,*p[4], i; 则不能正确表示a数组元素的表达式是( )

A、a[4][3] B、p[0][0] C、prt[2][2] D、(*(p+1))[1] 172、以下程序的输出结果是( )

A、 23 B、 26 C、33 D、36 main()

{int aa[3][3]={{2},{4},{6}},i,*p=&aa[0][0]; for(i=0;i<2; i++)

{if(i==0) aa[i][i+1]=*p+1; else ++p; printf(\}

printf(\

173、以下程序的输出结果是( )

A、 60 B、68 C、99 D、108 main()

{int a[3][4]={1,3,5,7,9,11,13,15,17,19,21,23}; int (*p)[4]=a,i,j,k=0; for(i=0;i<3;i++) for(j=0;j<2;j++) k+=*(*(p+i)+j); printf(\}

174、以下程序的输出结果是( )

A、 1,5,9, B、1,4,7, C、3,5,7, D、3,6,9, main()

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

printf(\

175、若有定义语句int (*p)[M]; 其中的标识符p是( )

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

C、一个行指针，它指向具有M个整型元素的一维数组指针 D、具有M个指针元素的一维指针数组，每个元素都只能指向整型量 176、以下能正确进行字符串赋值、赋初值的语句组是( )

A、 char s[5]={‘a’,’e’,’i’,’o’,’u’}; B、 char *s; s=”good!”; C、 char s[5]=”good!”; D、 char s[5]; s=”good”; 177、以下程序段的输出结果是( ) char str[ ]=”ABCD”,*p=str;

printf(“%d\\n”,*(p+4));

A、 68 B、 0 C、 字符D的地址 D、不确定的值 178、以下程序段的输出结果是( )

printf(“%d\\n”,strlen(“ATS\\n012\\1\\\\”)); A、 11 B、 10 C、 9 D、 8

179、当运行以下程序是输入OPEN THE DOOR〈CR〉代表ENTER键），则输出结果是（ A、Open tHE door B、open the door C、 OPEN THE DOOR D、Open The Door #include “stdio.h” char fun(char* c)

）

{ if(*c<=’Z’&&*c>=’A’) *c-=’A’-‘a’; return *c;} main()

{ char s[81]; *p=s; gets(s); while(*p)

{ p=fun(p); putchar (*p); p++;} putchar(‘\\n’);}

180、以下程序的输出结果是（ ）

A、GFEDCBA B、AGADAGA C、AGAAGAG D、GAGGAGA #include “stdio.h” #include “string.h” void fun(char *w,int m) {char s,*p1,*p2; p1=w; p2=w+m-1; while(p1

{s=*p1++; *p1= *p2--; *p2=s;} } main()

{ char a[ ]=”ABCDEFG”; fun(a,strlen(a)); puts(a);}

181、以下程序的输出结果是（ ） A、ABCD

B、 A C、 D

BCD

B

C ABC

CD C B AB D D A A main()

{ char s[ ]=”ABCD”, *p;

for(p=s; p

A、aa数组元素中的值分别是字符串”abcd” 和”ABCD” B、aa是指针变量，它指向含有两个数组元素的字符型一维数组 C、aa数组的两个元素分别存放的是含有四个字符的一维数组的首地址D、aa数组的两个元素中各自存放了字符’a’和’A’的地址 183、以下程序的输出结果是( )

A、6385 B、69825 C、63825 D、693825 main()

{char ch[2][5]={“6937”,”8254”},*p[2]; int i,j,s=0;

for(i=0; i<2; i++) p[i]=ch[i]; for(i=0;i<2;i++)

for(j=0; p[i][j]>’\\0’&&p[i][j]<=’9’; j+=2) s=10*s+p[i][j]-‘0’;

D、 ABCD

printf(“%d\\n”,s);}

184、以上程序的输出结果是( )

A、 ABCDEFGHIJKL B、 ABCD C、ABCDEFGHIJKLMNOP D、 AEIM main()

{ char *alpha[6]={“ABCD”,”EFGH”,”IJKL”,”MNOP”,”QRST”,”UVWX”};

char **p; int i; p=alpha;

for(i=0;i<4;i++) printf(“%s”,p[i]); printf(“\\n”);} 185、有以下程序

main() {

int m=12,n=34;

printf(\程序运行后的输出结果是( )

A、12353514 B、12353513 C、12343514 D、12343513 186、有以下语句:int b;char c[10];,则正确的输入语句是 ( )

A、scanf(\、 scanf(\C、scanf(\、scanf(\187、有以下程序

main(){int a,b,d=25;a=d/10%9;b=a&&(-1); printf(\程序运行后的输出结果是 ( )

A、6，1 B、2，1 C、6，0 D、2，0 188、有以下程序

main() {

int i=1,j=2,k=3;

if(i++==1&&(++j==3||k++==3)) printf(\程序运行后的输出结果是 ( )

A、1 2 3 B、2 3 4 C、2 2 3 D、2 3 3 189、有以下程序

main() {

char a[7]=\i=sizeof(a); j=strlen(a); printf(\程序运行后的输出结果是 ( )

A、2 2 B、7 6 C、7 2 D、6 2 190、以下能正确定义一维数组的选项是( )

A、int a[ ]={0,1,2,3,4,5}; B、char a[]={0,1,2,3,4,5}; C、char a={'A','B','C'}; D、int a[5]=\

191、有以下程序运行后的输出结果是 ( )

int f1(int x,int y){return x>y?x:y;} int f2(int x,int y){return x>y?y:x;} main()

{ int a=4,b=3,c=5,d=2,e,f,g; e=f2(f1(a,b),f1(c,d)); f=f1(f2(a,b),f2(c,d)); g=a+b+c+d-e-f;

printf(\

A、4,3,7 B、3,4,7 C、5,2,7 D、2,5,7

192、已有定义:char a[]=\以下叙述中正确的是 ( ) A、数组a和b的长度相同 B、a数组长度小于b数组长度 C、a数组长度大于b数组长度 D、上述说法都不对 193、有以下程序运行后的输出结果是( )

void f(int *x,int *y){int t;t=*x;*x=*y;*y=t;} main(){ int a[8]={1,2,3,4,5,6,7,8},i,*p,*q; p=a;q=&a[7]; while(p

A、8,2,3,4,5,6,7,1, B、5,6,7,8,1,2,3,4, C、1,2,3,4,5,6,7,8, D、8,7,6,5,4,3,2,1, 194、有以下程序

main() {

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

for(i=0;i<9;i++)p[i]=i;

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

程序运行后的输出结果是 ( )

A、0 1 2 B、1 2 3 C、2 3 4 D、3 4 5 195、以下叙述中错误的是 ( )

A、对于double类型数组,不可以直接用数组名对数组进行整体输入或输出 B、数组名代表的是数组所占存储区的首地址,其值不可改变

C、当程序执行中,数组元素的下标超出所定义的下标范围时,系统将给出\下标的出错信息

D、可以通过赋初值的方式确定数组元素的个数 196、有以下程序

#define N 20

fun(int a[],int n,int m) {int i,j;

for(i=m;i>=n;i--)a[i+1]=a[i]; } main()

{ int i,a[N]={1,2,3,4,5,6,7,8,9,10}; fun(a,2,9);

越界\ for(i=0;i<5;i++)printf(\程序运行后的输出结果是 ( )

A、10234 B、12344 C、12334 D、12234 197、有以下程序

main()

{int a[3][2]={0},(*ptr)[2],i,j; for(i=0;i<2;i++)

{ptr=a+i;scanf(\for(i=0;i<3;i++)

{for(j=0;j<2;j++)printf(\printf(\

若运行时输入:1 2 3<回车>,则输出结果是( )

A、产生错误信息 B、1 0 C、1 2 D、1 0 2 0 3 0 2 0 0 0 0 0 3 0 198、有以下程序

prt(int *m,int n) {int i;

for(i=0;i

{ int a[]={1,2,3,4,5},i; prt(a,5); for(i=0;i<5;i++) printf(\程序运行后的输出结果是( )

A、2,3,4,5,6, B、1,2,3,4,5, C、3,4,5,6,7, D、2,3,4,5,1, 199、以下语句或语句组中,能正确进行字符串赋值的是 ( )

A、char *sp;*sp=\、char s[10];s=\C、char s[10];*s=\、char *sp=\200、有以下程序

main()

{char s[]=\p=s;

printf(\程序运行后的输出结果是 ( )

A、15 B、16 C、12 D、59 201、 以下说法中正确的是（ ）

A) C 语言程序总是从第一个的函数开始执行

B) 在 C 语言程序中，要调用的函数必须在 main() 函数中定义 C) C 语言程序总是从 main() 函数开始执行

D) C 语言程序中的 main() 函数必须放在程序的开始部分

202、下列关于C语言用户标识符的叙述中正确的是（ ）

A) 用户标识符中可以出现在下划线和中划线（减号） B) 用户标识符中不可以出现中划线，但可以出现下划线

C) 用户标识符中可以出现下划线，但不可以放在用户标识符的开头

D) 用户标识符中可以出现在下划线和数字，它们都可以放在用户标识符的开头

203、以下有4组用户标识符，其中合法的一组是（ ）

A) for B) 8d C) if_G3 D) WND -sub do IF void Case Size a2bc define

204、下面四个选项中，全部是不正确的八进制数或十六进制数的选项是（ ）

A) 016 0x8f 018 B) 0abc 017 0xa C) 010 -0x11 0x16 D) 0a12 7ff -123

205、以下正确的叙述是（ ）

A) 在C程序中，每行中只能写一条语句

B) 若a是实型变量，C程序中允许赋值a=10，因此实型变量中允许存放整型数 C) 在C程序中，无论是整数还是实数，都能被准确无误地表示 D) 在C程序中，%（求余数运算符）是只能用于整数运算的运算符

206、下面四个选项中，均是合法的浮点数的选项是（ ）

A) +1e+1 5e-9.4 03e2 B) .60 12e-4 -8e5 C) 123e 1.2e-.4 +2e-1 D) -e3 .8e-4 5.e-0

207、已知各变量的类型说明如下：

int k, a, w=5,b; float x=1.42; 则以下不符合C语言语法的表达式是（ ） A) 12.4%(-3) B) w+=-2+x C) k=(a=2, b=3, a+b) D) a+=a-=(b=4)*(a=3)

208、以下不正确的叙述是（ ）

A) 在C程序中，逗号运算符的优先级最低 B) 在C程序中，APH和aph是两个不同的变量

C) 若a和b类型相同，在计算了赋值表达式a=b后b中的值将放入a中，而b中的值不变 D) 当从键盘输入数据时，对于整型变量只能输入整型数值，对于实型变量只能输入实型数值

209、sizeof(double) 是 （ ） 。

A ）一种函数调用 B ）一个双精度型表达式 C ）一个整型表达式 D ）一个不合法的表达式

210、若有定义：int a=8,b=5,c;

执行语句c=b/a+0.4;后，c的值为（ ）。 A）0.4 B）1 C）2.0 D）0

211、若变量a是char类型，并执行了语句：a=’B’+1.6;

则正确的叙述是（ ）。

A）a的值是字符67.5 B）a的值是浮点型

C）不允许字符型和浮点型相加 D）a的值是字符’B’的ASCII值加上1

212、在C语言中合法的长整型常数是（ ）。

A）0L B）4962710 C）324562& D)216D 213、以下选项中不合法的字符常量是（ ）。

A）“B” B）’\\010’ C）’6’ D）’D’

214、设a、b、c、d、m、n均为int型变量，且a=5、b=6、c=7、d=8、m=2、n=2，则逻辑表达式(a>b)&&n运算后，n的值为（ ）。

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

215、putchar函数可以向终端输出一个（）。

A) 整型变量表达式 B) 实型变量值 C) 字符串 D) 字符或字符型变量值

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

A) 从左起输出该字符串，右补空格 B) 按原字符长从左向右全部输出 C) 右对齐输出该字符串，左补空格 D) 输出错误信息

217、阅读以下程序，当输入数据的形式为：25，13，10（注：表示回车），则正确的输出结果为（ ）。 main()

{ int x,y,z;

scanf( “%d%d%d”,&x,&y,&z); printf( “x+y+z=%d\\n”,x+y+z); }

A) x+y+z=48 B) x+y+z=35 C) x+z=35 D) 不确定值 218、若下面程序的输入形式为：AΔBΔC（Δ表示空格），程序输出结果为 （ ）。 main()

{ char ch1,ch2,ch3;

scanf( “%c%c%c”,&ch1,&ch2,&ch3); printf( “%c%c%c”,ch1,ch2,ch3); }

A) AΔBC B) ABC C) AΔB D) ABΔC 219、已知ch是字符型变量，下面不正确的赋值语句是( )。

A) ch= ‘a+b’; B) ch=‘\\0’; C) ch=‘7’+‘9’; D) ch=5+9; 220、设有语句 char a='\\72'; 则变量 a （ ） 。

A) 包含1个字符 B) 包含2个字符 C) 包含3个字符 D) 说明不合法 221、执行下面程序中的输出语句， a 的值是（）

A) 65 B) 20 C) 15 D) 10 main() { int a;

printf(\}

222、设有语句 int a=3; 则执行了语句 a+=a-=a*a; 后，变量 a 的值是( )

A ） 3 B ） 0 C ） 9 D ） -12

223、下列关于单目运算符++、--的叙述中正确的是( )

A) 它们的运算对象可以是任何变量和常量

B) 它们的运算对象可以是char型变量和int型变量，但不能是float型变量 C) 它们的运算对象可以是int型变量，但不能是double型变量和float型变量 D) 它们的运算对象可以是char型变量、int型变量和float型变量 224、在 C 语言中，如果下面的变量都是 int 类型，则输出结果是 ( )

sum=pad=5; pad=sum++ ,pad++ , ++pad; printf(\

A) 7 B) 6 C) 5 D) 4

225、以下程序的输出结果是 ( )

#include main()

{ int i=010 , j = 10;

printf(\}

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

226、已知在ASCII 代码中，字母A的序号为65，以下程序的输出的结果是( ) 。

# include main()

{ char c1='A', c2='C'; printf(\}

A) 因输出格式不合法，输出错误信息 B）65,C C）A,Y D）65,67 227、以下程序的输出结果是( ) 。

#include #include main()

{ int a=1,b=4,c=2;

float x=10.5 , y=4.0 , z;

z=(a+b)/c+sqrt((double)y)*1.2/c+x; pritnf(\}

A) 14.000000 B) 015.400000 C) 13.700000 D) 14.900000 228、以下程序的输出结果是( ) 。

#include main()

{ int a=2,c=5;

printf(\}

A) a=%2,b=%5 B) a=2,b=5 C) a=%%d,b=%%d D) a=%d,b=%d 229、以下程序的输出结果是( ) 。

#include main()

{ int a ,b,d=241; a=d/100%9; b=(-1)&&(-1);

printf(\}

A) 6,1 B) 2,1 C) 6,0 D) 2,0

230、已知字母A的ASCII 码为十进制的65，下面程序的输出是( )。

main()

{ char ch1,ch2; ch1='B'+'4'-'3';

ch2='B'+'2'-'0';

printf(\}

A) 67,D B) C,C C) C,D D) 不确定的值

231、 对如下定义和输入语句，若使a1, a2, c1, c2 的值分别为10, 20, A, B，正确的数据输入方式是（ ） 。 (注：Δ表示空格，表示回车，下同）。

int a1, a2; char c1, c2;

scanf (\A) 10A Δ 20B B) 10 Δ A Δ 20 Δ B C) 10A20B D) 10A20 Δ B

232、由给出的数据输入和输出形式，程序中输入输出语句的正确内容是（ ）。

main( )

{ int x; float y;

printf (\； 输入语句； 输出语句； }

输入形式 enter x, y: 2 3.4 输出形式 x+y=5.40

A) scanf (\ printf (\ C) scanf (\ printf (\233、逻辑运算符两侧运算对象是（ ）。

A) 只能是0和1 B) 只能是0或非0正数 C) 只能是整型或字符型数据 D) 可以是任何类型的数据 234、判断char型变量ch是否为大写字母的正确表达式是（ ）。

A) ‘A’<=ch<=‘Z’ B) (ch>=‘A’)&(ch<=‘Z’) C) (ch>= ‘A’)&&(ch<=‘Z’) D) (‘A’<= ch)AND(‘Z’>= ch)

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

A) A%2==1 B) !(A%2==0) C) !(A%2) D) A%2

236、 设有：int a=10,b=2,c=3,d=4,m=2,n=2;执行(m=a>b)&&(n=c>d)后n的值为 （ ）。 A) 1 B) 2 C) 3 D) 0 237、以下程序的运行结果是（ ）。

main()

{ int a,b,d=100; a=d/100%8; b=(-1)&&(-1);

printf( “%d,%d”,a,b); }

A)1,1 B) 2,1 C) 8,0 D) 0,1

238、已知int x=100,y=20,z=30;以下语句执行后x,y,z的值是（ ）。 if(x>y) z=x; x=y; y=z;

A) x=10, y=20, z=30 B) x=20, y=30, z=30 C) x=20, y=100, z=100 D) x=20, y=30, z=20 239、以下程序的运行结果是（ ）。

main() { int m=6;

if(m++>5) printf( “%d\\n”,m); else ;

printf( “%d\\n”,m--); }

A) 4 B) 5 C) 6 D) 7

240、若运行时给变量x输入12，则以下程序的运行结果是（ ）。

main() { int x,y;

scanf( “%d”,&x); y=x>12 ? x+10 : x-12;

printf( “%d\\n”,y); }

A) 0 B) 22 C) 2 D) 1

241、以下关于运算符优先顺序的描述中正确的是（ ）。（逻辑运算符不包括！）

A) 关系运算符<算术运算符<赋值运算符<逻辑运算符 B) 逻辑运算符<关系运算符<算术运算符<赋值运算符 C) 赋值运算符<逻辑运算符<关系运算符<算术运算符 D) 算术运算符<关系运算符<赋值运算符<逻辑运算符 242、语句 while(!E); 中的条件 !E 等价于（ ）。

A）E = = 0 B）E!=1 C）E!=0 D） ~E

243、与 y=(x>0?1:x<0?-1:0); 的功能相同的 if 语句是（ ）。

A) if (x>0) y=1; B) if(x) else if(x<0) y=-1; if(x>0) y=1; else y=0; else if(x<0) y=-1; C) y=-1 D) y=0; if(x) if(x>=0) if(x>0)y=1; if(x>0)y=1; else if(x==0) y=0; else y=-1; else y=-1;

244、对下面三条语句（其中s1和s2为内嵌语句），正确的论断是（ ）。

（1）if (a) s1；else s2; (2) if (a= =0) s2；else s1; （3）if (a!=0) s1；else s2；

A) 三者相互等价 B) （1） 和 （2） 等价 ， 但与 （3） 不等价 C) 三者互不等价 D) （1） 和 （3） 等价 ， 但与 （2） 不等价

245、若x，y，z的初值均为1，则执行表达式w =++x || ++ y && ++ z后，x，y，z的值分别为( )A) x=1, y=1, z=2 B) x=2, y=2, z=2 C) x=1, y=2, z=1 D) x=2, y=1, z=1 246、下面程序的输出是 ( )

A) -1 B) 0 C) 1 D) 不确定的值

。

main()

{ int x=100, a=10, b=20, ok1=5, ok2=0; if(a

if(ok2) x=10; x=-1;

printf(\}

247、语句 while(E); 中的表达式 E 等价于 （ ）。 A) E==0 B) E!=1 C)E!=0 D)E==1 248、下面程序段的运行结果是（ ）。 int n=0;

while(n++<=2);printf(\ A)2 B)3 C)4 D) 有语法错 249、对以下程序段描述正确的是（ ）。 x=-1; do{ x=x*x; } while(x);

A) 是死循环 B) 循环执行二次 C) 循环执行一次 D) 有语法错误 250、若有如下语句 int x=-3;

do{printf(\ 则上面程序段输出的是（ ）。

A) -5 B) 1和-2 C ) 3和0 D) 是死循环 251、C语言程序的基本单位是____ 。 A) 程序行 B) 语句 C) 函数 D) 字符、 252、C语言程序的三种基本结构是____ 。

A、顺序结构，选择结构，循环结构 B、递归结构，循环结构，转移结构 C、嵌套结构，递归结构，顺序结构 D、循环结构，转移结构，顺序结构 253、C语言规定，程序中各函数之间___ 。

A) 既允许直接递归调用也允许间接递归调用 B) 不允许直接递归调用也不允许间接递归调用 C) 允许直接递归调用不允许间接递归调用 D) 不允许直接递归调用允许间接递归调用 254、C语言中可处理的文件类型是( )

A) 文本文件和数据文件 B)文本文件和二进制文件 C) 数据文件和二进制文件 D)数据代码文件 255、C语言可执行程序的开始执行点是( )

A) 程序中第一条可执行语句 B) 程序中第一个函数 C) 程序中的main函数 D) 包含文件中的第一个函数 256、C语言提供的合法的数据类型关键字是

A)double B) short C) integer D) char

257、C语言中,运算对象必须是整型数的运算符是

A) % B) \\ C) %和\\ D) * 258、C语言中函数返回值的类型是由( )决定。

A) return语句中的表达式类型 B) 调用函数的主调函数类型 C) 调用函数时临时 D) 定义函数时所指定的函数类型

259、C语言中数组名作为参数传递给函数，作为实在参数的数组名被处理为_____。

A、 该数组的长度。 B、该数组的元素个数。 C、 该数组中各元素的值。 D、 该数组的首地址。 260、C语言中数组下标的下限是________。 A、1 B、0 C、视具体情况 D、无固定下限 261、C语言中提供的合法关键字是____ 。 A、swith B、cher C、case D、default 262、C语言中文件的存取方式是________。

A、顺序存取 B、随机存取 C、顺序存取、随机存取均可 D、顺序存取、随机存取均不可 263、C语言中最简单的数据类型包括 ________。 A) 整型、实型、逻辑型 B) 整型、实型、字符型 C) 整型、字符型、逻辑型 D) 整型、实型、逻辑型、字符型 264、sizeof(float)是( )

A) 一种函数调用 B) 一个不合法的表示形式 C) 一个整型表达式 D) 一个浮点表达式 265、表达式:10!=9的值是 A) true B) 非零值 C) 0 D) 1

266、表示关系x<=y<=z的c语言表达式为 A) (X<=Y)&&(Y<=Z) B) (X<=Y)AND(Y<=Z) C) (X<=Y<=Z) D) (X<=Y)&(Y<=Z)

267、程序片段：在TC20中, int i=65536; printf(\的输出结果是____ A) 65536 B) 0 C) 有语法错误，无输出结果 D) -1

268、当调用函数时，实参是一个数组名，则向函数传送的是____ A) 数组的长度 B) 数组的首地址 C) 数组每一个元素的地址 D) 数组每个元素中的值

269、对嵌套子程序调用说法正确的是____。 A、 外层子程序可以调用所有的内层子程序 B、 内层了程序只可以调用包含本身的外层子程序，不可以隔层调用 C、 外分程序必须能完全套住内分程序 D、 以上说法均不正确

270、对于基类型相同的两个指针变量之间，不能进行的运算是 A) < B) = C) + D) - 271、合法的C语言中，合法的长整型常数是 A) '\\t' B) \

272、假定int类型变量占用两个字节，其有定义：int x[10]={0,2,4};，则数组x在内存中所占字节数是 A) 3 B) 6 C) 10 D) 20

273、假定有以下变量定义: int k=7 ,x=12; 则能使值为3的表达式是 A x%=(k%=5) B x%=(k-k%5) C x%=k-k%5 D (x%=k)-(k%=5)

274、若要求在if后一对圆括号中表示a不等于0的关系,则能正确表示这一关系的表达式为 A) a<>0 B) !a C) a=0 D) a

275、若已定义x和y为double类型，则表达式:x=1，y=x+3/2的值是 A)1 B)2 C)2、0 D)2 276、若有定义：int a=8，b=5，c;，执行语句c=a/b+0、4;后，c的值为 A) 1.4 B) 1 C) 2.0 D) 2.4

277、若有以下定义和语句 char c1='b',c2='e'; printf(\则输出结果是: A)2,M B)3,E C)2,E D)输出项与对应的格式控制不一致，输出结果不确定

278、若有以下函数调用语句： fun(a+b,(x,y),fun(n+k,d,(a,b)));在此函数调用语句中实参的个数是 A)3 B)4 C)5 D)6

279、若执行下面的程序时从键盘上输入3和4，则输出是____

92、设x的值为4，则表达式x++的值是 .

93、设x、y、t均为int型变量，则执行语句：x=y=3;t=++x||++y;后，y的值为________。 94、设a=3，b=2，则表达式a^b>>2的值的二进制表示为________。

95、设ch是char型变量，其值为A，且有下面的表达式： ch=(ch>='A'&&ch<='Z')?(ch+32):ch 的值是____。

96．为表示关系x≥y≥z,应使用C语言表达式_____ __。

97. 请读程序: main() {union {int k; char i[2]; }*s,a; s=&a; s->i[0]=0x39;s->i[1]=0x38; printf(“%x、n”，s->k); } 则上面程序的输出结果是____。

98. 有如下函数调用语句 func(rec1,rec2+rec3,(rec4,rec5); 该函数调用语句中，含有的实参个数是________。

99. 有语句char str1[10],str2[10]={\则能将字符串china赋给数组str1的正确语句是________。

100. 在C语言中，fclose()函数返回____时， 表示关闭成功。 101. 在C语言中，fclose()函数返回____时， 表示关闭不成功。 102. 在C语言中，打开函数文件指针值是____时， 表示打开成功。 103. 在C语言中，打开函数文件指针值是____时， 表示打开失败。 104．C语言程序的基本单位是____。

105. C语言程序的三种基本结构是__ _、__ _、__ _。 106. C语言规定，程序中各函数之间是平行的，不允许_ 定义。 107. C语言中可处理的文件类型是 _。 108. C语言可执行程序的开始执行点是 _。

109. C语言中,运算对象必须是整型数的运算符是 _。 110. C语言中函数返回值的类型是由 决定。

111. C语言中数组名作为参数传递给函数，作为实在参数的数组名被处理为____ _。 112. C语言中数组下标的下限是________。

113. sizeof(float)的功能是__ _。 114. 表达式:10!=9的值是__ _。

115. 当调用函数时，实参是一个数组名，则向函数传送的是____ _。

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

117. 请读程序片段(字符串内没有空格): printf(\的输出结果是_ _ 。

118. 若a为int类型，且其值为3，则执行完表达式a+=a-=a*a后，a的值是 _。 119. 若int类型占两个字节，则以下语句输出为________。 int k=-1; printf(\120. 若已定义x和y为double类型，则表达式:x=1，y=x+3/2的值是 _。 三、判断题（请在每个题后的括号内对的打“√”错的打“×”，每题1分，共263题） 1. C语言中整型数据类型占4个字节。 （ ） 2. C语言中整型数据可以赋给实型变量。 （ ） 3. C语言中一个表达式可以出现各种数组类型。 （ ） 4. C语言中a3,q-b,yy都是正确的标识符。 （ ） 5. C语言标识符中大小写通用。 （ ） 6. C语言中的标识符只能由数字和字母组成。 （ ） 7. C语言中的标识符首字符只能是字母。 （ ） 8. C语言中整数有八进制、十进制和十六进制三种形式。 （ ）

9. C语言中，表达式a^代表a*a。 （ ） 10. C语言中a和’a’含义不同，a是标识符，’a’是字符常量。 （ ） 11．C语言中的函数可以单独编译，即修改哪个编译哪个。 （ ） 12．C语言中的基本数据类型包括整型、实型、字符型和字符串型。 （ ） 13．C语言中无论是整数还是实数，只要在允许的范围内都能准确无误的表示。 ( ) 14．若输入字符串的长度超过字符数组所能容纳的字符个数时,系统将自动报错 ( ) 15．C语言程序的基本单位是函数 。 （ ） 16．C语言程序可以包含多个主函数 。 （ ） 17．C语言中int型是所占字节最短的数据类型。 （ ） 18．在C语言中实型包括float 型和double型，它们两个类型存放数据范围相同。( ) 19．若s是int 型变量，且s=6,则s%2+(s+1)%2的值为6.5。 （ ） 20．若a是int 型变量，则（a=4*5,a*2）,a+6的值为 26 。 （ ） 21．若a是int 型变量，则a=25/3%3的值为 2.6 。 ( ) 22．C语言各种运算符中！的优先级最高。 （ ） 23．C语言中，逻辑运算符&&优先级高于逻辑运算符||。 （ ） 24．C语言的所有运算符运算方向都是从左到右。 （ ） 25．表达式pow(2.8,sqrt(double (x)))值的数据类型为float型。 （ ） 26. 在C语言中，表示逻辑“真”值用非零的数字。 ( ) 27. 设y为int型变量，请写出描述“y是奇数”的表达式y%2= =0。 ( ) 28. C语言提供的三种逻辑运算符是&&、||、！。 （ ） 29. 已知A=7.5，B=2，C=3.6，表达式A>B&&C>A||AB的值是1。 （ ） 30. 若a=6，b=4，c=2，则表达式!(a-b)+c-1&&b+c/2的值是1。 （ ） 31. 表达式a++||b++,若a++的值为非零，则计算机不执行b++。 （ ） 32. 表达式a++&&b++,无论在什么情况下，都要执行a++和b++。 （ ） 33. 若有定义int i=3;则表达式i++和i的值都是4。 （ ）

（ ）

35. 在C语言中，sizeof（a）是求变量a所占字节数，它是一个函数。 （ ） 36. 运算符的优先级正确排序是：

赋值运算符<逻辑运算符<关系运算符<算术运算符。 （ ） 37. (x>=1)&&x<=10能正确表示当x的取值在[1，10]范围内为真，否则为假。 （ ） 38. ‘A’<=ch<=’Z’是判断char型变量ch是否为大写字母的表达式。 （ ） 39. 若有int x=3,y=4,z=5;则表达式x||y+z&&y-z的值为0。 （ ） 40. 逻辑运算符两侧运算对象的数据类型只能是整型或字符类型。 （ ） 41. 若有a=0，则if（a=5）表示条件满足。 （ ） 42. 若有int x=10,y=20,z=30;则执行程序段if(x>y)z=x;x=y;y=z;后x=20,y=30,z=30。 （ ） 43. 程序段int a=0,b,c;if（a==0）;b=a;else c=a;能够正确运行。 （ ） 44. C语言中，条件语句可以改写成if-esle语句。 （ ） 45. 若有int w=1,x=2,y=3,z=4;则条件表达式wy&&!x=y);是正确的if语句形式。 （ ） 47. 程序main(){int m=5;if(m++>5)printf(“%d\\n”,m);

else printf(“%d\\n”,m--);}结果是5。 （ ）

48. 若有条件表达式(exp)?a++:b++,则表达式（exp==1）与（exp）等价。 （ ） 49. 在C语言中if语句共有三种，单if结构，if-else结构，if-else if?else 结构。 （ ）

34. 在C语言中，(int)和int区别在于（int）是运算符，是强制转换成整型，int是变量类型说明。

50. 设有变量定义：int a=10,c=9;则表达式（--a！=c++）？--a：++c的值是10。 （ ） 51. 条件“22&&x<3&&x<-10。 ( ) 52．C语言中的输入语句只能用scanf实现。 （ ） 53．以下程序的输出结果是*3.140000,3.142* 。 （ ） main( ){ printf(“*%f,%4.3f*\\n”,3.14,3.1415); }

54． C语言中scanf语句和printf语句可以输入、输出任意多个数据 。 （ ） 55． 若有程序段int a,b;scanf(“%d,%d”,&a,&b);则从键盘输入 30 40时是正确的。（ ） 56． scanf ( 格式控制，输入项表 ) 中“输入项表”必须是存储单元的地址。 （ ） 57．C语言中用“1”表示逻辑值“假” ，用“0”表示逻辑值“真” 。 （ ） 58．i=0,j=1,语句 if(j++||++i);执行后i、j的值分别是1、2。 （ ） 59. C语言中，putchar()函数可以向终端输出一个字符串。 （ ） 60. C语言中，getchar()函数可以从终端得到一个字符。 （ ）

61. C语言中，getchar()函数与scanf()函数的区别在于getchar()只能用于字符的输入，而scanf()可以

输入任意类型的数据。 （ ）

62. C语言中，输入语句getchar(ch)；表示给变量ch输入一个字符。 （ ） 63. 已有定义，int a=-2;printf(“%8lx”,a);是错误的输出格式。 （ ） 64. 若有输出语句printf(“%u”,a)；%u代表输出的是无符号的整型十进制 （ ） 65. 若有输入语句scanf(“%d %d”,&a,&b)；输入的两个整数必须由一个空格隔开 （ ） 66. 若有int a=5,b=10;printf(“LL”,a,b)；输出结果是5 6 （ ） 67. 在c语言中’\\n’与”\\n”占字节数相同。 （ ） 68. 在c语言中共有255个字符。 （ ） 69．若有定义char ch ; 语句 ch=’’; 是一个正确的赋值语句。 （ ） 70．若有定义char *pp[]={“a”, “ b”, “e” }; 其中pp是一个一维数组。 （ ） 71．若变量 i和p已正确定义，程序中*(p+i) 可以写成 p[i] 的形式。 （ ） 72．C语言中对文件进行操作，一定要先用“FILE”定义文件指针。 ( ) 73．对结构体成员的引用,可以直接引用成员名而不用在成员前加“结构变量名。”( ) 74． C语言中，字符（char）型数据在微机内存中的存储形式是补码。 （ ） 75．若有定义char ch[10] ; 语句 ch=”ABCD ”; 是一个正确的赋值语句。 （ ） 76. C语言程序主要由函数和过程组成。 （ ） 77．TURBO C中double类型变量所占字节数是4个。 （ ） 78．C语言中运算对象必须是整型的运算符是“/”。 （ ） 79．逻辑运算符中优先级最高的运算符是“&&”。 （ ） 80. 0.01e-2是一个正确的C语言常量。 （ ） 81. #define M 100 中的M可以在主程序中改变。 （ ） 82. x已正确定义，语句if(!x) ；没有语法错。 （ ） 83. int i=5; for( ; ;i++){i+=5;} 循环结束后，i的值为10. ( ) 84. scanf语句只能输入数字，不能输入字符。 （ ） 85. printf语句既能输出数字，也能输出字符。 （ ） 86. C语言中的自定义函数可以不经过调用就直接编译连接成可执行文件。 （ ） 87. C语言中的自定义函数中必须有return语句。 （ ） 88. ”\\n”是一个合法的字符串常量。 （ ） 89. break语句只能用于switch 语句和循环语句。 （ ） 90. C语言中，switch语句可以改写成if-esle语句。 （ ） 91. C语言中，else必须与离它最近的if配对使用。 （ ）

92. C语言中，选择结构中，if必须与else配对使用。 （ ） 93. C语言中，switch(表达式)，其中表达式必须是条件表达式。 （ ）

（ ）

95. C语言中，循环结构共三种，即：while、dowhile和for结构。 （ ） 96. C语言中，循环结构while(1)，其循环条件为真，表示永远满足。 （ ） 97. C语言中，for（表达式1;表达式2;表达式3）循环结构，三个表达式都可以省略。 （ ） 98. 程序段 while(i<=100)s=s+i;i++;是正确的，它的可以实现从1加到100的和。 （ ） 99. C语言中，三种循环结构可以任意嵌套。 （ ） 100. C语言中，do-while语句与while语句完全等价。 （ ） 101. C语言中，循环结构for(表达式1；；表达式3)是正确的。 （ ）

（ ）

103. 程序段int k=10;whle(k==0)k=k-1;中的循环体语句执行一遍。 （ ） 104. 语句while(!E)；中的表达式!E等价于E==0。 （ ） 105. 程序段int n=0;while(n++<=2);printf(“%d”,n);则n的值是4。 ( ) 106. do-while语句的循环体只能是一条语句，所以不能使用复合语句。 （ ) 107. 程序段int x=-1;do{x=x*x;}while(!x);是死循环。 ( ) 108. 程序段int x=3;do{printf(“%d\\n”,x-=2);}while(!(--x));输出的是1和-2。 ( ) 109. 在for循环的循环体语句中，可以包含多条语句，但必须由大括号括起来。 ( ) 110. while(1){x++;}，当x的取合适的初值时，可以避免死循环。 ( ) 111. C语言中，do-while语句可以改写成while语句。 （ ）

112． 语句printf(\与puts(str);是等价的，都是从字符串指定位置开始输出，一直到最后并

自动换行。 ( )

113．while(1) scanf（“%d” ，&a）; 该语句死循环。 （ ） 114．while(0) scanf（“%d” ，&a）; 该语句死循环。 （ ） 115．if(1) a=1; else a=2; 该语句执行后a的值是1。 （ ） 116．赋值运算符的优先级高于逗号运算符。 （ ） 117．char cc[8]={‘a’,‘b’,‘c’,‘d’}; 数组cc放的是字符串。 （ ） 118．表达式(12&&‘a’||0)的值为1。 （ ）

（ ）

120．只要用递归函数能实现的功能，一定可以用循环语句实现。 （ ） 121. C语言中，建立函数的目的之一是提高程序的可读性。 （ ） 122. C语言中，double fun(int x;int y)是正确的函数定义形式。 （ ） 123. C语言中，用户若需要调用标注库函数，调用前必须利用#include包含函数库。 （ ） 124. C语言中，用户若需要调用标注库函数，调用前必须重新定义。 （ ） 125. C语言中，实参和与其对应的形参各占用独立的存储单元。 （ ） 126. C语言中，若函数中没有return语句，则返回一个不确定的值。 （ ） 127. C语言中，形参与实参的数据类型可以不一致。 （ ） 128. C语言中允许函数值类型缺省定义，此时该函数值隐含的类型是int。 （ ） 129. 函数调用可以出现在函数的实参中。 （ ） 130. 函数调用可以嵌套，函数的定义也可以嵌套。 （ ） 131．若定义void ac(int i,int n)函数，则在函数中不能有return语句 （ ）

94. C语言中，switch(表达式){ case 表达式常量 ：语句 }其中表达式常量可以是任意常量。

102. C语言中，循环结构for(表达式1；表达式2；表达式3)中表达式2必须是条件表达式。

119．若a正确定义，语句scanf(“%s”,a);和gets(a);数组a都能接收字符串，没有任何区别。

132. C语言中，被调函数的定义部分必须放在调用函数上方。 （ ） 133. 在函数中，return语句的个数不限，因此可以用它返回多个值。 （ ） 134. 在函数中，形参与实参的个数必须一致，且形参与实参的值可以相互传递。 （ ） 135. 在主函数中声明的函数，只有主函数调用，其他函数不能调用。 （ ） 136. C语言中，指针变量只能存放变量的地址。 （ ） 137．局部变量只对main函数起作用，而全局变量对所有函数起作用。 （ ） 138．若有宏定义#define M 3+4，程序中可以用7代替M。 （ ） 139．局部变量既能在函数体中定义，又能在复合语句中定义。 （ ） 140．全局变量只能在程序开始定义，即main函数的上面定义。 （ ） 141. C语言中，取地址符号&与指针运算符*优先级相同。 （ ） 142. C语言中，用来存放指针地址的变量就是地址。 （ ） 143. 若有定义，int a=100,*p=&a,**k=&p;则*k=100。 （ ） 144. 若有定义，int a,*p=&a;则scanf(“%d”,*p);是正确的赋值。 （ ） 145. 若有定义，int *point,a=4;point=&a;则point、&a、*&point都代表地址。 （ ） 146. 若有定义，int a=5;则int *p=&a;表示在对P进行说明的同时进行初始化，

使p指向a。 （ ） 147. 若有定义，int *p，*q;q=p;inta,*p,*q p=q=&a;是正确的语句。 （ ） 148. 若有定义，int *p=&a,*q=&b,b,a; p=q;是正确的语句。 （ ）

149. 若有定义，int k=2，*ptr1,*ptr2;且ptr1和ptr2均已指向k，则ptr2=k是正确的语句。

（ ）

150. 程序段char s[]=”china”;char *p;p=s;s和p完全相同。 （ ）

151. 程序段char s[]=”china”;char *p;p=s;数组s中的内容和指针变量p中的内容相等。

（ ）

152. 程序段char s[]=”china”;char *p;p=s; *p与s[0]相等。 （ ） 153. 程序段char *s=“abcde”;s+=2;printf(“%d”,s);运行结果是cde。 ( ） 154. 设char *s=”\\ta\\017bc”;则指针便量s指向的字符串所占字节数是6。 ( ） 155. char s[5]=”ABCDE”能够正确进行字符串赋值。 ( ） 156. 程序段char str[20];scanf(“%s”,&str);是正确的。 ( ） 157. 程序段char str[ ]=“ABC”，*p=str;printf(“%d\\n”,*(p+3));

运行结果是69。 ( ） 158. 若有char s1[]=”stringrr” 库函数strcpy(s1,”string2”)是将字符串

”string2”复制到s1中。 ( ） 159. 若有char a[]=”It is mine”;则a+1表示的是字符t的地址。 ( ） 160. 若有char a[]=”It is mine”;则a中只能存放10个字符。 ( ） 161．语句len=strlen(“a\\n”);执行后len的值是3。 （ ） 162. C语言中，若有int a[5]={12,34,56,78,90},*p=a;则*p++=13。 （ ） 163. C语言中，若有int a[5]={12,34,56,78,90},*p=a;则p++=&a[0]。 （ ） 164. C语言中，若有程序段,int a=100,*p, *q;p=&a;*p=*q;是正确的。 （ ）

（ ）

166．若有以下定义：int a[10] ={0}; 则表示只有a[0]的值是0；其余元素的值未定。（ ） 167．在C语言中以下语句是正确的，int a,*p=&a; 此语句表示指针变量p指向a。 ( ) 168．在C语言中若有int a[10];则a[10] 是最后一个元素。 ( ) 169．在C语言中，int a[10];scanf(“%d”,a);表示一次性地给数组a的10元素赋值。（ ）

165. 程序段，int a=100,b=200,*p=&a,*q=&b,*t;*t=*p;*p=*q;*q=*t;可以实现a与b两个数的交换。

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