程序设计基础（山东工商学院）知到智慧树章节测试课后答案2024年秋山东工商学院

程序设计基础（山东工商学院）知到智慧树章节测试课后答案2024年秋山东工商学院第一章单元测试

一个C程序可能出现的错误有（）。

A:语法错误

B:其他三个选项中所说的错误都可能出现

C:逻辑错误

D:运行错误

答案:其他三个选项中所说的错误都可能出现

C语言源程序中一般可以包含几个函数？（）。

A:必须两个以上

B:0个

C:至少一个

D:1个

答案:至少一个

关于C语言，以下描述中错误的是（）。

A:一个C程序总是从main函数开始执行

B:C语言的注释通常是以"/*"开始并以"*/"结束

C:一个C程序可以包含多个main函数

D:每个语句的最后必须有一个分号

答案:一个C程序可以包含多个main函数

计算机能直接执行的文件是（）。

A:扩展名为txt的文件

B:扩展名为exe的文件

C:扩展名为obj的文件

D:扩展名为c的文件

答案:扩展名为exe的文件

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

A:C语句必须以分号结束

B:一条C语句必须在一行内写完

C:C程序中出现的预编译，均为语句，如#include＜stdio.h＞就是一条C语句

D:C程序中的每一行只能写一条语句

答案:C语句必须以分号结束

程序的运行结果不正确，这种错误属于（）。

A:逻辑错误

B:编译错误

C:语法错误

D:连接错误

答案:逻辑错误

在函数体中，关于数据定义语句和非数据定义语句（即执行语句）的位置，下面说法正确的是（）。

A:C89标准规定：有些必须放在前面，有些可以放在后面

B:C89标准规定：所有数据定义语句必须在任何非数据定义语句的前面

C:C89标准对于上述两种语句的位置没有要求

D:C99标准规定：所有数据定义语句必须在任何非数据定义语句的前面

答案:C89标准规定：所有数据定义语句必须在任何非数据定义语句的前面

在C语言程序中（）。

A:main函数必须放在程序的开始位置

B:main函数只能出现在库函数中

C:main函数可以放在其它函数的前面、后面或中间

D:main函数必须放在程序的最后

答案:main函数可以放在其它函数的前面、后面或中间

C语言属于以下程序设计语言的哪个类别？（）。

A:面向对象语言

B:机器语言

C:高级语言

D:汇编语言

答案:高级语言

下列选项中，属于多行注释的是（）。

A://

B:\\

C:/**/

D:/*

答案:/**/

以下四个程序中，完全正确的是（）。

A:include＜stdio.h＞

intmain()

{

/*programming*/

printf("programming！\n")；

return0;

}

B:#include＜stdio.h＞

intmain()；

{

/*programming/*

printf("programming！\n")；

return0;

}

C:#include＜stdio.h＞

intmain()

{

/*programming*/

printf("programming！\n")

return0;

}

D:#include＜stdio.h＞

intmain()

{

/*programming*/

printf("programming！\n");

return0;

}

答案:#include＜stdio.h＞

intmain()

{

/*programming*/

printf("programming！\n");

return0;

}

第二章单元测试

以下哪个选项中是合法的用户自定义标识符?（）。

A:b-b

B:float

C:_isw

D:123asd

答案:_isw

下面选项中，属于合法的字符常量的是（）。

A:'ab'

B:"\0"

C:'\084'

D:'\x43'

答案:'\x43'

下面几组代码中正确的是（）。

A:intconsta=1;

B:constinta;a=1;

C:constinta;

D:constinta=1;

答案:constinta=1;

能正确定义3个变量并为它们赋初值5的是（）。

A:intx,y,z=5;

B:intx=y=z=5;

C:intx=5,y=5,z=5;

D:x=y=z=5;

答案:intx=5,y=5,z=5;

下面4个选项中，能使符号常量代表3的定义是（）。

A:#defineN3;

B:#defineN3

C:defineN3

D:#defineN=3

答案:#defineN3

设整数和实数的大小都不超过各自变量的存储范围，下面4种说法中，正确的是（）。

A:整数的存储不都是精确的，实数的存储都不是精确的

B:整数和实数的存储都不是精确的

C:整数的存储都是精确的，实数的存储不都是精确的

D:整数的存储都是精确的，实数的存储都不是精确的

答案:整数的存储都是精确的，实数的存储不都是精确的

下面4个选项中，全部都是合法整型常量的是（）。

A:-0xcdf,01A,0xe

B:-01,012,0668

C:160,-0xffff,011

D:-0x48A,2e5,0x

答案:160,-0xffff,011

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

A:-.18,123e4,0.0

B:123,2e4.2,e5

C:160.,0.12,e3

D:-e3,.234,1e3

答案:123,2e4.2,e5

c是字符变量，关于语句“c='A'+'6'-3;”,下面说法正确的是（）。

A:执行后c的值是'D'

B:无法执行

C:执行后c的值是't'

D:执行后c的值是68

答案:执行后c的值是't'

关于字符串"CHINA"，下面说法正确的是（）。

A:它可以用一个字符串变量存储，存储它的字符串变量占用5个字节的内存

B:其他三个说法都不对

C:它在内存中占6个字节

D:它在内存中占5个字节

答案:它在内存中占6个字节

参与运算的对象必须是整数的运算符是（）。

A:%和/

B:%

C:*

D:/

答案:%

intx=10,y=3;

printf("%d,%d\n",x--,--y);

上面程序段的运行结果是（）。

A:10,3

B:102

C:10,2

D:9,3

答案:10,2

chara='1',b='2';

printf("%c,",b++);

printf("%d\n",b-a);

数字0的ASCII码是48，上面程序段的运行结果是（）。

A:2,50

B:3,2

C:2,2

D:50,2

答案:2,2

字符串"ab\108g"在内存中占的字节数是（）。

A:8

B:7

C:6

D:5

答案:6

关于表达式a*=b+c，下面说法正确的是（）。

A:其他三个说法都不对

B:它与a=a*b+c等价

C:它与a=a*b=b+c等价

D:它与a=a*(b+c)等价

答案:它与a=a*(b+c)等价

若有定义

inta=10,c=2;constintb=5;

则正确的赋值表达式是（）。

A:b=10

B:(a+b)=c*8

C:a=(b+c)*6

D:6=a

答案:a=(b+c)*6

关于算术运算，下面四个说法中正确的是（）。

A:1/2的结果是0

B:-5/3的结果是-2

C:5.0/9的结果是0

D:20*3%7，应先计算3%7

答案:1/2的结果是0

设a、b都是int型变量,则表达式（a=1,a+=1,b=a,b*2,a+b）的值是（）。

A:2

B:4

C:6

D:其他三个答案都不对

答案:4

表达式('A'+0.32f)计算结果的类型是（）。

A:int

B:double

C:char

D:float

答案:double

设有数据定义

charc1=65,c2=66;

inta1=1,a2=2;

floatx1=1.1,x2=2.2;

则下面四个选项中，系统不进行类型转换就能直接运算的是（）。

A:a1+a2

B:c1+c2

C:x1+x2

D:c1+a1

答案:a1+a2

第三章单元测试

charx=0xffff;

printf("%d\n",x--);

上面程序段的运行结果是（）。

A:-32767

B:fffe

C:-32768

D:-1

答案:-1

doubled;

floatf;

longl;

inti;

i=f=l=d=20/3;

printf("%d,%1d,%.1f,%.1f,",i,l,f,d);

上面程序段的运行结果是（）。

A:6,6,6.0,6.0

B:6,6,6.7,6.0

C:6,6,6.0,6.7

D:6,6,6.7,6.7

答案:6,6,6.0,6.0

unsigneda=65535;

printf("%d,%o,%x",a,a,a);

TC中整型变量占2个字节，则上面程序段的运行结果是（）。

A:65535,177777,ffff

B:65535,65535,65535

C:-1,65535,ffff

D:-1,177777,ffff

答案:-1,177777,ffff

关于putchar()的说法正确的是（）。

A:putchar()可用于输出字符串

B:putchar()函数括号中可以写字符变量或常量，也可以写整型变量或常量

C:其作用是由用户向计算机输出一个字符

D:putchar()不能对转义字符进行操作

答案:putchar()函数括号中可以写字符变量或常量，也可以写整型变量或常量

要从键盘给两个整型变量a、b输入数据，输入格式是1,2＜Enter＞，能完成此任务的代码是（）。

A:getchar(a,b);

B:scanf("%d%d",&a,&b);

C:scanf("%d%d",a,b);

D:scanf("%d,%d",&a,&b);

答案:scanf("%d,%d",&a,&b);

想通过代码“scanf("%d%d,%d",&a,&b,&c);”把1、2、3分别存入3个整型变量a、b、c，则正确的键盘输入应该是（）。

A:1＜Enter＞2＜Enter＞3＜Enter＞

B:1＜Enter＞＜Tab＞2,3＜Enter＞

C:12＜Tab＞3＜Enter＞

D:1,2,3＜Enter＞

答案:1＜Enter＞＜Tab＞2,3＜Enter＞

关于格式控制字符串%-m.ns,正确的说法是（）。

A:如果n＞m，则截取n个字符输出，突破m的限制

B:m表示输出的字符串最少占m列，n为小数精度

C:如果n＜m，则字符串向右靠拢，左端补0

D:如果n＞m，则只截取m个字符，其余的舍弃

答案:如果n＞m，则截取n个字符输出，突破m的限制

以下不属于格式控制字符的是（）。

A:%E

B:%D

C:%X

D:%f

答案:%D

a、b、c都是整型变量，用“scanf("%d%2d%*2d%d",&a,&b,&c);”给3个变量输入数据，设输入格式是12345678＜Enter＞,则3个变量的值分别是（）。

A:12,34,78

B:1,34,78

C:1,34,7

D:12,34,56

答案:12,34,78

charc1='1',c2='2';

c1=getchar();

c2=getchar();

上面的程序段运行时从键盘输入a＜Enter＞,则正确的叙述是（）。

A:c1被赋予字符a,c2无确定值

B:c1被赋予字符a,c2被赋予换行符

C:程序将等待输入第二个字符

D:c1被赋予字符a,c2维持原值

答案:c1被赋予字符a,c2被赋予换行符

inti;

floatf;

scanf("i=%d,f=%f",&a,&f);

上面程序段准备把10和5.12分别存给i和f，则正确的输入应是（）。

A:10＜Enter＞5.12＜Enter＞

B:10＜空格＞5.12＜Enter＞

C:i=10,f=5.12＜Enter＞

D:i=10＜Enter＞f=5.12＜Enter＞

答案:i=10,f=5.12＜Enter＞

inta;

charb;

floatc;

scanf("%d%c%f",&a,&b,&c);

若上面程序段运行时键盘输入的字符序列为2223a123o.12,则a、b、c的值分别是（）。

A:原值不变

B:2223，a,123o.12

C:2223,a,123

D:2223,a,原值

答案:2223,a,123

第四章单元测试

inta=3,b=2,c=1,f;

f=a＞b＞c;

上面程序段执行后，f的值是（）。

A:不确定

B:2

C:1

D:0

答案:0

#include＜stdio.h＞

intmain()

{

inta=1,b=2,m=0,n=0,k;

k=(n=b＞a)||(m=a＜b);

printf("%d,%d",k,m);

return0;

}

上面程序的运行结果是（）。

A:1,1

B:1,0

C:0,2

D:0,0

答案:1,0

以下四个选项中，执行完程序段后y的值不为3的是（）。

A:intx=5,y=2;if(x)y=3;

B:intx=0,y=0;if(x=y)y=3;

C:intx=5,y=2;if(2)y=3;

D:intx=0,y=2;if(x=y)y=3;

答案:intx=0,y=0;if(x=y)y=3;

inta=2,b=-1,c=2;

if(a＜b)

if(b＜0)

c=0;

elsec++;

上面的程序段执行后，c的值是（）。

A:2

B:0

C:3;

D:1

答案:2

intx=10,y=20,z=30;

if(x＞y)

z=x;x=y;y=z;

上面代码段执行后，x，y，z的值是（）。

A:20,10,10

B:10,20,30;

C:20,30,10

D:20,30,30

答案:20,30,30

逻辑运算符中，运算优先级按从高到低正确排序的是（）。

A:!||&&

B:||&&!

C:&&!||

D:!&&||

答案:!&&||

以下是if语句的基本形式：

if(表达式)语句

其中“表达式”（）。

A:必须是关系表达式

B:可以是任意合法的表达式

C:必须是逻辑表达式

D:必须是逻辑表达式或关系表达式

答案:可以是任意合法的表达式

若有表达式(！w)?(--x):(++y),则下列选项中与其等价的表达式是（）。

A:(w!=0)?(--x):(++y)

B:(w==1)?(--x):(++y)

C:(w==0)?(--x):(++y)

D:(w!=1)?(--x):(++y)

答案:(w==0)?(--x):(++y)

intw='b',x=14,y=15;

w=((x||y)&&(w＜'a'));

执行上面程序段后，w的值为（）。

A:1

B:NULL

C:0

D:-1

答案:0

if((x=y=2)＞=x&&x=5)

y*=x;

上面程序段执行后，整型变量x、y的值分别是（）。

A:5,2

B:5,10

C:2,4

D:赋值号级别低于&&，导致代码存在语法错误第10题

答案:赋值号级别低于&&，导致代码存在语法错误第10题

intx,y;

scanf("%d%d",&x,&y);

if(x＞y)

x=y;y=x;

else

x++;y++;

printf("%d,%d",x,y);

关于上面程序段，下列说法正确的是（）。

A:有语法错误

B:若输入“43”，输出“3,4”

C:若输入“34”，输出“4,5”

D:若输入“43”，输出“4,4”

答案:有语法错误

1.#include＜stdio.h＞

2.intmain()

3.{

4.intm;

5.printf("Inputm:");

6.scanf("%d",&m);//输入一个整数

7.if(m＞0)//是否为正数

8.{

9.if(m%2==0)//是正数，且能被2整除，则是正偶数

10.{

11.printf("%disapositiveeven\n",m);

12.}

13.else//不能被2整除，则是正奇数

14.{

15.printf("%disapositiveodd\n",m);

16.}

17.}

18.

19._______________//判断是否为负数

20.

21.{

22._______________

23.

24.{

25.printf("%disanegativeeven\n",m);//是负偶数

26.}

27.else

28.{

29.printf("%disanegativeodd\n",m);//是负奇数

30.}

31.}

32.else

33.{

34.printf("%diszero.Itisaneven\n",m);

35.}

36.return0;

37.}

上面程序代码的功能是判断输入整数的正负性和奇偶性，能将代码补充完整且正确的选项是（）。

A:第19行代码：if(m＜0)，第22行代码：if(m%2!=0)

B:第19行代码：elseif(m＜0)，第22行代码：if(m%2==0)

C:第19行代码：if(m＜0),第22行代码：if(m%2==0)

D:第19行代码：elseif(m＜0)，第22行代码：if(m%2!=0)

答案:第19行代码：elseif(m＜0)，第22行代码：if(m%2==0)

以下程序段中,与语句:k=a＞b?(b＞c?1:0):0;功能相同的是（）。

A:if((a＞b)||(b＞c))k=1;elsek=0;

B:if(a＞b)k=1;elseif(b＞c)k=1;elsek=0;

C:if((a＞b)&&(b＞c))k=1;elsek=0;

D:if(a＜=b)k=0;elseif(b＜=c)k=1;

答案:if((a＞b)&&(b＞c))k=1;elsek=0;

intx=1,a=0,b=0;

switch(x)

{

case0:b++;

case1:a++;

case2:a++;b++;

}

上面程序段执行后，a，b的值分别是（）。

A:2,1

B:1,1

C:2,2

D:1,0

答案:2,1

intx=1,y=2,z=3;

switch(x=1){

case1:

switch(y==2){

case1:printf("*");break;

case2:printf("%");break;

}

case0:

switch(z){

case1:printf("$");break;

case2:printf("&");break;

default:printf("#");

}

}

上面程序段的运行结果是（）。

A:*$

B:*#

C:%#

D:$

答案:*#

第五章单元测试

关于while语句,错误的说法是（）。

A:循环体至少要执行一次

B:可以用条件控制循环体的执行次数

C:循环体可以是包含若干条语句的复合语句

D:循环体有可能一次也不执行

答案:循环体至少要执行一次

对于整型变量x,与while(！x)等价的是（）。

A:while(x！=0)

B:while(x==1)

C:while(x！=1)

D:while(x==0)

答案:while(x==0)

关于do-while循环,以下叙述正确的是（）。

A:do-while循环由do开始,用while(表达式)结束,在while(表达式)后面必须写分号

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

C:do-while循环中,根据情况可以省略while后面的表达式3题

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

答案:do-while循环由do开始,用while(表达式)结束,在while(表达式)后面必须写分号

#include＜stdio.h＞

intmain()

{

intx,i;

for(x=3;x＜=100;x++){

if(x%2==0)_____;

for(i=2;i＜=x-1;i++)

if(x%i==0)_____;

if(i==x)printf("%d",x);

}

return0;

}

上面程序的功能是找出3～100间的素数,程序中所缺的两处应为（）。

A:breakbreak

B:continuecontinue

C:breakcontinue

D:continuebreak

答案:continuebreak

设变量已正确定义,下面程序中能计算f=n!的是（）。

A:f=1;for(i=1;i＜n;i++)f*=i;

B:f=1;for(i=n;i＞1;i++)f*=i;

C:f=0;for(i=1;i＜=n;i++)f*=i;

D:f=1;for(i=n;i＞=2;i--)f*=i;

答案:f=1;for(i=n;i＞=2;i--)f*=i;

#include＜stdio.h＞

intmain()

{

intx,s=0;

for(x=1;x＜=5;x++){

switch(x%3){

case0:

default:s+=3;格式不对

case1:s+=1;break;

case2:s+=2;

}

}

printf("%d",s);

return0;

}

上面程序的运行结果是（）。

A:10

B:6

C:13

D:7

答案:10

#include＜stdio.h＞

intmain()

{

inti,j;

for(i=3;i＞=1;i--)

{

for(j=1;j＜=2;j++)

printf("%d",i+j);7题

printf("");

}

return0;

}

上面程序的运行结果是（）。

A:233445

B:234345

C:432543

D:453423

答案:453423

#include＜stdio.h＞

intmain()

{

inti=10,x=0;

for(;i＜10;i++)

x=x+i;

printf("%d",x);

return0;

}

上面程序运行后,循环体运行的次数为（）。

A:1

B:无限

C:0

D:10

答案:0

以下不是死循环的选项是（）。

A:for(;(c=getchar())!='\n';)printf("%c",c);

B:for(;;x+=k);

C:while(1){x++;}

D:for(k=10;;k--)sum=sum+k;

答案:for(;(c=getchar())!='\n';)printf("%c",c);

关于循环的控制，以下说法正确的是（）。

A:在循环体内使用break和continue的作用相同

B:continue语句的作用是结束整个循环的执行

C:从多层循环嵌套内退出时,必须使用goto语句

D:只能在循环体内和switch语句内使用break语句

答案:只能在循环体内和switch语句内使用break语句

有关for语句中，正确的是（）。

A:for循环是先执行循环体,后判断表达式

B:for循环中,不能用break跳出循环体

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

D:for语句的循环体只能是一条语句

答案:for语句的循环体只能是一条语句

#include＜stdio.h＞

intmain()

{

inti=1,n=1;

for(;i＜3;i++)

{

continue;

n=n+i;

}

printf("%d",n);

return0;

}

上面程序运行后,变量n的值为（）。

A:1

B:4

C:3

D:2

答案:1

#include＜stdio.h＞

intmain()

{

intx,s;

for(x=0,s=0;x＜=10;x++)

{

if(x%3==0)

continue;

else

{

if(x%4==0)

continue;

elses+=x;

if(s%5==0)break;

}

}

printf("%d",s);

return0;

}

上面程序的运行结果是（）。

A:5

B:15

C:35

D:25

答案:15

#include＜stdio.h＞

intmain()

{

intx=012;

do

printf("%d",x--);

while(--x);

return0;

}

上面程序的运行结果是（）。

A:10864

B:8642

C:86420

D:108642

答案:108642

#include＜stdio.h＞

intmain()

{

ints=0,i=5;

while(s+=i,i-=2)

printf("%d",s);

return0;

}

上面程序的运行时,循环的执行次数是（）。

A:15

B:无限次

C:9

D:5

答案:无限次

第六章单元测试

下面对于函数的描述中,正确的是（）。

A:函数的定义和函数的调用都可以嵌套

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

C:函数的定义和函数的调用都不可以嵌套

D:函数的定义可以嵌套,但函数的调用不可以嵌套

答案:函数的定义不可以嵌套,但函数的调用可以嵌套

fun(floatx)

{

floaty;

longz;

y=x*x;

z=(long)y;

return(z);

}

上面fun函数的类型是（）。

A:float

B:int

C:void

D:long

答案:int

以下函数声明中正确的是（）。

A:doublefun(intx;inty);

B:doublefun(x,y);

C:doublefun(intx,y);

D:doublefun(intx,inty);

答案:doublefun(intx,inty);

有以下函数定义:voidfun(intn,doublex){…},若以下选项中的变量都已经正确定义且赋值,则对函数fun的正确调用语句是（）。

A:fun(10,12.5);

B:voidfun(n,x);

C:k=fun(10,12.5);

D:fun(inty,doublem);

答案:fun(10,12.5);

#include＜stdio.h＞

inta=1,b=2;

voidswap(intc,intd)

{

intt;

t=a;a=b;b=t;

t=c;c=d;d=t;

}

intmain()

{

intc,d;

scanf("%d,%d",&c,&d);

swap(c,d);

printf("%d,%d,%d,%d\n",a,b,c,d);

return0;

}

假设用户输入5,3,则上面程序的运行结果是（）。

A:2,1,5,3

B:2,1,3,5

C:1,2,3,5

D:1,2,5,3

答案:2,1,5,3

#include＜stdio.h＞

voidfun(inta,intb)

{

intt;

a=456;

b=567;

t=a,a=b,b=t;

}

intmain()

{

intx=10,y=20;

fun(x,y);

printf("%d,%d\n",x,y);

return0;

}

上面程序的运行结果是（）。

A:567,456

B:456,567

C:10,20

D:20,10

答案:10,20

#include＜stdio.h＞

voidf(intx)

{}

intmain()

{

inta=1;

f(a);

return0;

}

对于上面的程序,以下说法正确的是（）。

A:x是实参,a是形参

B:x是形参,a是实参

C:x是形参,a也是形参

D:x是实参,a也是实参

答案:x是形参,a是实参

关于实参和形参，以下说法中不正确的是（）。

A:实参个数与形参个数必须相等

B:实参可以是常量、变量或表达式

C:实参类型应与对应的形参类型一致或兼容

D:形参可以是常量、变量或表达式

答案:形参可以是常量、变量或表达式

关于实参和形参占用内存空间问题，以下说法正确的是（）。

A:若实参是变量,则它和对应的形参各自占用独立的存储单元

B:形参是虚拟的,不占用存储单元

C:实参与对应的形参共用存储单元

D:只有当实参与对应的形参同名时才共占用存储单元

答案:若实参是变量,则它和对应的形参各自占用独立的存储单元

#include＜stdio.h＞

longfib(intg)

{

switch(g)

{

case0:return0;

case1:

case2:return1;

}

return___________;

}

intmain()

{

longk;

k=fib(7);

printf("k=%ld\n",k);

}

上面的程序是用递归的方法求菲波拉契数列1、1、2、3、5、8……第7项fib(7),横线处所缺的代码是（）。

A:fib(7)

B:fib(g-1)+fib(g-2)

C:fib(g)+fib(g)

D:fib(g)+fib(g-1)

答案:fib(g-1)+fib(g-2)

函数中没有return语句,则下面说法中正确的是（）。

A:该函数被调用时将返回一个不确定的值

B:该函数被调用时不会返回任何值

C:该函数被调用时将返回NULL

D:该函数被调用时将返回一个系统默认值

答案:该函数被调用时将返回一个不确定的值

#include＜stdio.h＞

intfun(intn)

{

if(n==1)

return1;

else

return(n+fun(n-1));

}

intmain(){

intx;

scanf("%d",&x);

x=fun(x);

printf("%d",x);

return0;

}

若程序运行时键盘输入10,则上面程序的运行结果是（）。

A:65

B:55

C:54

D:45

答案:55

若定义函数时不写返回值的类型,则函数值的类型是（）。

A:long

B:void

C:int

D:double

答案:int

第七章单元测试

若在一个函数的复合语句中定义了一个变量，则该变量（）。

A:在本源文件范围内有效

B:在复合语句中定义非法

C:在整个函数中有效

D:只在该复合语句中有效

答案:只在该复合语句中有效

某源文件中定义了一个全局变量，其作用范围是（）。

A:从定义处到本源文件结束

B:整个源文件的范围

C:不知道有无声明，所以不确定

D:所有源文件

答案:不知道有无声明，所以不确定

在函数体中定义的局部变量，其作用范围是（）。

A:定义它的函数内

B:定义它的大括号内

C:定义它的源文件内

D:所有源文件

答案:定义它的大括号内

关于函数的形参，下列说法正确的是（）。

A:形参只是一个符号，不是变量

B:形参是动态局部变量

C:形参是静态局部变量

D:函数形参的声明不在任何大括号内，所以形参是全局变量

答案:形参是动态局部变量

定义局部变量时不指定存储类型，则其存储类型是（）。

A:extern

B:register

C:static

D:auto

答案:auto

关于静态局部变量，正确的说法是（）。

A:其他三种说法都不对

B:执行到它的作用域时分配空间，离开它的作用域时释放空间

C:程序装载时分配空间，程序结束时才释放空间

D:从分配空间到程序结束，它一直存在，期间在任何地方都可以使用它

答案:程序装载时分配空间，程序结束时才释放空间

定义了一个变量但未赋初值，关于它的初值，下面说法正确的是（）。

A:若是静态局部变量，则为0；若是自动变量或寄存器变量，则不确定

B:若是static型的全局变量，为0；若是extern型的全局变量，则不确定

C:若是动态存储，则为0；若是静态存储，则不确定

D:若是全局变量，则为0；若是局部变量，则不确定

答案:若是静态局部变量，则为0；若是自动变量或寄存器变量，则不确定

关于全局变量的生存期，下面说法正确的是（）。

A:从程序装载到程序运行结束

B:取决于它定义的位置

C:从源文件开始执行到源文件执行结束

D:取决于它所在的源文件

答案:从程序装载到程序运行结束

若全局变量定义时未规定属性，则它的属性是（）。

A:auto

B:register

C:static

D:extern

答案:extern

#include＜stdio.h＞

inta=2,b=3;

intmax(inta,intb)

{

intc;

c=a＞b?a:b;

printf("%d",c);

returnc;

}

intmain()

{

inta=4;

max(a,b);

printf("%d",max(a,b));

return0;

}

上面程序的运行结果是（）。

A:444

B:4

C:34

D:24

答案:444

intfac(intn)

{

staticintf=1;

f*=n;

returnf;

}

intmain()

{

inti,n;

for(i=1;i＜=5;i++)

n=fac(i);

printf("%d",n);

return0;

}

上面程序的运行结果是（）。

A:120

B:5

C:24

D:100

答案:120

根据变量的作用域可将变量分为（）。

A:全局变量和局部变量

B:自动变量和寄存器变量

C:静态变量和动态变量

D:自动变量和临时变量

答案:全局变量和局部变量

全局变量和局部静态变量分配空间的时机是（）。

A:执行到变量作用域的时候

B:主函数执行时

C:装载exe文件时

D:主函数结束时

答案:装载exe文件时

在程序运行过程中不占内存空间的变量是（）。

A:寄存器变量

B:全局变量

C:自动局部变量

D:静态局部变量

答案:寄存器变量

允许在其它源文件中使用的是（）。

A:static型全局变量

B:register型变量

C:extern型全局变量

D:static型局部变量

答案:extern型全局变量

第八章单元测试

关于宏定义，下面说法正确的是（）。

A:宏定义不是语句，最后可以没有分号

B:宏定义不是语句，最后不能有分号

C:宏定义虽是语句，但最后可以没有分号

D:宏定义是一条语句，最后必须有分号

答案:宏定义不是语句，最后可以没有分号

关于宏展开，下面说法错误的是（）。

A:宏展开可以发现宏定义中的错误

B:宏展开只是简单地文本替换

C:宏展开不进行语法检查

D:宏展开不做数据类型的判别

答案:宏展开可以发现宏定义中的错误

设有宏定义

#definePI3.14159

在宏展开时，3.14159会被认为是（）。

A:7个文字符号

B:单精度实数

C:双精度实数

D:字符串

答案:7个文字符号

文件包含时，可以用＜＞也可以用""将被包含文件括起来，关于这两种包含方式，下面说法正确的是（）。

A:能用＜＞的一般也可以用""

B:两者作用相同

C:能用＜＞的不能用""，反之亦然

D:能用""的一般也可以用＜＞

答案:能用＜＞的一般也可以用""

文件包含命令中用＜＞包括被包含的文件，表示（）。

A:要到本源文件所在的目录中查找它

B:其他三种说法都不对

C:到系统设定的包含目录中查找它

D:既到系统设定的目录中查找，又到本源文件所在目录查找

答案:到系统设定的包含目录中查找它

关于文件包含，下面说法错误的是（）。

A:被包含的文件可以是头文件也可以是源文件

B:文件包含就是把被包含文件的内容插入到包含命令所在处

C:文件包含可以用尖括号也可以用双引号，但作用不同

D:同一个文件不允许用两个#include命令包含两次或两次以上

答案:同一个文件不允许用两个#include命令包含两次或两次以上

若有宏定义

#defineN2+1

则printf("%d",N*(N+1))的输出结果是（）。

A:8

B:5

C:12

D:6

答案:6

有一种方法可以避免一个文件的内容被包含两次或以上，该方法除了文件包含命令外，还需要使用（）。

A:宏定义和分支结构

B:条件编译

C:宏定义和条件编译

D:宏定义

答案:宏定义和条件编译

下面关于条件编译的说法，正确的是（）。

A:条件编译两个分支中若都有代码，则这两部分代码都要参加编译

B:条件编译就是在正式编译时，根据条件选择一部分代码留下参与编译，另一部分舍弃

C:若一个程序既能写成条件编译，又能写成分支结构，则用条件编译写成的源程序比用分支结构写成的源程序生成的可执行文件更短

D:条件编译就是在程序执行时，根据条件选择一部分代码执行，另一部分不执行

答案:若一个程序既能写成条件编译，又能写成分支结构，则用条件编译写成的源程序比用分支结构写成的源程序生成的可执行文件更短

若有定义

#defineM(n)a=n*2

inta;

则printf("%d",M(5+1)*3)的输出结果是（）。

A:其他三个答案都不对

B:36

C:21

D:11

答案:11

第九章单元测试

下面四段程序中，能正确输出变量a的值的是（）。

A:inta=1,*p;*p=&a;printf("%d",*p);

B:inta=1,*p;*p=a;printf("%d",*p);

C:inta=1,*p=a;printf("%d",*p);

D:inta=1,*p=&a;printf("%d",*p);

答案:inta=1,*p=&a;printf("%d",*p);

关于指针和指针变量，下面说法正确的是（）。

A:指针和指针变量是同一个东西

B:指针和指针变量各自有各自的范畴，互相之间没有关系

C:指针变量的范畴包含着指针的范畴

D:指针的范畴包含着指针变量的范畴

答案:指针的范畴包含着指针变量的范畴

关于直接寻址和间接寻址，下面说法错误的是（）。

A:直接寻址比间接寻址直观

B:直接寻址不需要指针

C:间接寻址必须用指针

D:间接寻址比直接寻址高效

答案:间接寻址比直接寻址高效

关于指针变量的属性以及它是否占用内存空间，下面说法正确的是（）。

A:指针变量的值是一个整数

B:指针变量既有值，又有地址

C:char*型的指针变量，占1字节的内存空间

D:指针变量不占内存空间

答案:指针变量既有值，又有地址

要定义两个指针变量，下面代码正确的是（）。

A:int*p1,int*p2;

B:int*p1,*p2;

C:int*p1,p2;

D:int*(p1，p2);

答案:int*p1,*p2;

若有定义：

int*p;

则以下说法正确的是（）。

A:变量类型是int

B:变量名是p

C:变量名是*p

D:变量的基类型是int*

答案:变量名是p

关于指针变量指向哪里，下面说法正确的是（）。

A:若定义指针变量（局部自动型）但是不赋值，则它指向内存0单元处

B:若定义指针变量并且赋值为NULL，表示它指向内存0单元处的对象

C:若定义指针变量（局部自动型）但是不赋值，则它不指向任何对象

D:若定义指针变量并且赋值为NULL，表示它不指向任何实际对象

答案:若定义指针变量并且赋值为NULL，表示它不指向任何实际对象

若有定义

intx,*p;

则能使p指向x的表达式是（）。

A:p=*x

B:p=&x

C:*p=x

D:p=x

答案:p=&x

若有定义：

int*p,a=1,b;

则以下正确的程序段是（）。

A:p=&b;scanf("%d"，&p);

B:p=&b;scanf("%d"，p);

C:p=&b;scanf("%d"，*p);

D:scanf("%d",&b）;*p=b;

答案:p=&b;scanf("%d"，p);

若有定义：

inta=511,*b=&a;

则printf("%d\n",*b)的输出结果为（）。

A:511

B:不确定值

C:b的地址

D:a的地址

答案:511

第十章单元测试

以下对一维数组a的定义中，正确的是（）。

A:intk=10;inta[k];

B:inta[5];

C:chara(10);

D:inta[0..100];

答案:inta[5];

以下对一维数组的定义中，不正确的是（）。

A:doublex[5]={2.0,4.0,6.0,8.0,10.0};

B:inty[5]={0,1,3,5,7,9};

C:charch1[]={'1','2','3','4','5'};

D:charch2[]={'\x10','\xa','\x8'};

答案:inty[5]={0,1,3,5,7,9};

以下对二维数组的定义中，正确的是（）。

A:inta[][3]={1，2，3，4，5，6};

B:inta[][3];

C:inta[][]＝{{1,2,3},{4,5,6}}

D:inta[4][]={1，2，3，4，5，6};

答案:inta[][3]={1，2，3，4，5，6};

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

A:3

B:6

C:20

D:10

答案:20

#include＜stdio.h＞

intmain()

{

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

printf("%d%d%d%d\n",a[0][3],a[1][2],a[2][1],a[3][0]);

return0;

}

上面程序的运行结果是（）。

A:5430

B:输出结果不确定

C:0650

D:1470

答案:0650

#include＜stdio.h＞

intmain()

{

intm[][3]={1,4,7,2,5,8,3,6,9};

inti,j,k=2;

for(i=0;i＜3;i++){

printf("%d",m[k][i]);

}

return0;

}

上面程序的运行结果是（）。

A:258

B:789

C:456

D:369

答案:369

#include＜stdio.h＞

intmain()

{

intb[3][3]={0,1,2,0,1,2,0,1,2},i,j,t=0;

for(i=0;i＜3;i++)

for(j=i;j＜=i;j++)

t=t+b[i][b[j][j]];

printf("%d\n",t);

return0;

}

上面程序的输出结果是（）。

A:3

B:4

C:1

D:9

答案:3

若有定义：inta[2][4];，则引用下标变量正确的是（）。

A:a[0][3]

B:a[2][2]

C:a[0][4]

D:a[2][2+1]

答案:a[0][3]

若有定义：intaa[8];，则不能代表数组元素aa[1]地址的是（）。

A:&aa[1]

B:&aa[0]+1

C:aa+1

D:&aa[0]++

答案:&aa[0]++

若二维数组y有m列，则排在y[i][j]前的变量个数为（）。

A:i*m+j+1

B:i*m+j-1

C:i*m+j

D:j*m+i

答案:i*m+j

若想定义一个名为s且初值为字符串"123"的字符数组，则下列定义错误的是（）。

A:chars[]={’1'，'2'，'3'，'\0'}

B:chars[]={"123\n"};

C:chars[4]={'1'，'2'，'3'}

D:chars[]={"123"};

答案:chars[]={"123\n"};

关于数组，下列描述中不正确的是（）。

A:不能在赋值语句中通过赋值运算符"="对字符型数组进行整体赋值

B:字符型数组中可以存放字符串

C:可以对字符串进行整体输入、输出

D:可以对整型数组进行整体输入、输出

答案:可以对整型数组进行整体输入、输出

语句printf("%d\n",strlen("school"));的输出结果是（）。

A:6

B:存在语法错误

C:7

D:不确定值

答案:6

若有语句：chars1[10],s2[10]="books";，则能将字符串books存入数组s1的语句是（）。

A:s1="books"

B:s1=s2

C:strcpy(s1,s2);

D:strcpy(s2,s1)

答案:strcpy(s1,s2);

若有定义inta[3][4];则能输入其第3行第2列元素（这是生活中计数方式）的正确语句为（）。

A:scanf("%d",a[3,2])

B:scanf("%d",*(*(a+2)+1))

C:scanf("%d",*(a[2]+1))

D:scanf("%d",*(a+2)+1)

答案:scanf("%d",*(a+2)+1)

设有定义：chars[12]="string";则printf("%d,%d",strlen(s),sizeof(s));的输出结果是（）。

A:12,7

B:7,12

C:12,12

D:6,12

答案:6,12

语句strcat(strcpy(str1,str2),str3);的功能是（）。

A:将字符串str1连接到字符串str2中后再复制到字符串str3之后

B:将字符串str2复制到字符串str1后再将字符串str3连接到字符串str1之后

C:将字符串str1复制到字符串str2中后再连接到字符串str3之后

D:将字符串str2连接到字符串str1后再将字符串str1复制到字符串str3中。

答案:将字符串str2复制到字符串str1后再将字符串str3连接到字符串str1之后

若有如下定义：charx[]="abcdefg";chary[]={'a','b','c','d','e','f','g'};，则正确的叙述为:（）。

A:数组x和数组y的长度相同

B:数组x和数组y等价

C:数组y的长度大于数组x的长度

D:数组x的长度大于数组y的长度

答案:数组x的长度大于数组y的长度

第十一章单元测试

若有语句int*point,a=4;和point=&a;下面均代表指针的一组选项是（）。

A:&*a,&a,*point

B:a,point,*&a

C:&a,&*point,point

D:*&point,*point,&a

答案:&a,&*point,point

有以下程序段

inta[10]={1,2,3,4,5,6,7,8,9,10},*p=&a[3],b;

b=p[5];

执行后b中的值是（）。

A:8

B:5

C:6

D:9

答案:9

若有定义inta[5],*p=a;则对a数组元素的正确引用是（）。

A:*(p+5)

B:*(a+2)

C:a+2

D:a[5]

答案:*(a+2)

若有定义inta[7],*p=a;则p+5表示（）。

A:元素a[6]的值

B:元素a[6]的指针

C:元素a[5]的指针

D:元素a[5]的值

答案:元素a[5]的指针

设已有定义:inta[10]={15,12,7,31,47,20,16,28,13,19}，*p;则下列语句中正确的是（）。

A:for(p=a;p＜(a+10);p++);

B:for(p=a;a＜(p+10);a++);

C:for(p=a;a＜p+10;++a);

D:for(p=a,a=a+10;p＜a;p++);

答案:for(p=a;p＜(a+10);p++);

#include＜stdio.h＞

intmain()

{

intx[]={10,20,30};

int*px=x;

printf("%d,",++*px);printf("%d,",*px);

px=x;

printf("%d,",(*px)++);printf("%d,",*px);

px=x;

printf("%d,",*px++);printf("%d,",*px);

px=x;

printf("%d,",*++px);printf("%d\n",*px);

return0;

}

上面程序运行后的输出结果是（）。

A:20,10,11,20,11,12,20,20

B:11,11,11,12,12,13,20,20

C:11,11,11,12,12,20,20,20

D:20,10,11,10,11,10,11,10

答案:11,11,11,12,12,20,20,20

#include＜stdio.h＞

intmain()

{

intarr[]={6,7,8,9,10};

int*ptr;

ptr=arr;

*(ptr+2)+=2;

printf("%d,%d\n",*ptr,*(ptr+2));

return0;

}

上面程序的运行结果为（）。

A:6,10

B:6,8

C:7,9

D:8,10

答案:6,10

有以下定义

chara[10],*b=a;

则不能给数组a输入字符串的语句是（）。

A:gets(b)

B:gets(a[0])

C:gets(&a[0])

D:gets(a)

答案:gets(a[0])

#include＜stdio.h＞

intmain()

{

chara[]="programming",b[]="language";

char*p1,*p2;

inti;

p1=a;

p2=b;

for(i=0;i＜7;i++)

if(*(p1+i)==*(p2+i))

printf("%c",*(p1+i));

return0;

}

上面程序输出结果是（）。

A:gm

B:or

C:ga

D:rg

答案:ga

第十二章单元测试

char*s="abcde";

s+=2;printf("%d",s);

上面程序段的输出结果是（）。

A:字符串的后半部分：cde

B:字符'c'的地址

C:不确定的输出结果

D:字符'c'

答案:字符'c'的地址

#include＜stdio.h＞

#include＜string.h＞

intmain()

{

char*s1="AbDeG";

char*s2="AbdEg";

s1+=2;

s2+=2;

printf("%d\n",strcmp(s1,s2));

return0;

}

上面程序的运行结果是一个（）。

A:0

B:负数

C:不确定值

D:正数

答案:负数

若有代码：

chara[]="Itismine";

char*p="Itismine";

则以下错误的叙述是（）。

A:p中只能存放10个字符

B:p可以指向另外的字符串，并且另外的字符串的长度不受限制

C:p变量中存放的地址值可以改变

D:a+1是字符t的指针

答案:p中只能存放10个字符

若有以下代码：intc[4][5],(*p)[5];p=c;则能正确引用下标变量的是（）。

A:p+1

B:*(p+1)+3

C:*(p[0]+2))

D:*(p+3)

答案:*(p[0]+2))

若有定义：inta[2][3];则属于a数组的第i行j列元素的指针的表达式是（）。

A:*(a+j)

B:*(a[i]+j)

C:(a+i)

D:a[i]+j

答案:a[i]+j

设已有定义:char*st="howareyou";则下列程序段中能正确执行不越界的是（）。

A:chara[11];strcpy(a,st);

B:chara[11],*p;strcpy(p=a+1,&st[4]);

C:chara[15];strcpy(++a,st)；

D:chara[],*p;strcpy(p=&a[1],st+2);

答案:chara[11],*p;strcpy(p=a+1,&st[4]);

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

A:c=*p1+*p2;

B:p1=p2;

C:c=*p1*(*p2);

D:p2=c;

答案:p2=c;

以下四个程序段中，能正确执行的是（）。

A:charstr[20];scanf("%s",&str[2]);

B:charstr[20],*p=str;scanf("%s",*p);

C:char*p;scanf("%s",p);

D:charstr[20],*p=str;scanf("%s",p[2]);

答案:charstr[20];scanf("%s",&str[2]);

若有int**pp;int*p,a=1;p=&a;则能使pp指向变量p的代码是（）。

A:pp=&p;

B:pp=*p;

C:pp=p;

D:*pp=p;

答案:pp=&p;

已定义以下函数

int*fun(int*p)

{

returnp;

}

该函数的返回值是（）。

A:形参p中存放的整数

B:形参p所指单元的地址

C:形参p所指单元中的值

D:形参p的地址

答案:形参p所指单元的地址

若有以下函数首部

intfun(doublex[10],int*n)

则下面针对此函数的函数声明语句中正确的是（）。

A:intfun(double,int)

B:intfun(double*,int*);

C:intfun(doublex,int*n);

D:intfun(double*x,intn);

答案:intfun(double*,int*);

intmain()

{

chara;

char*str=&a;

strcpy(str,"hello");

printf(str);

return0;

}

上面程序的运行结果是（）。

A:h

B:运行时出现异常错误

C:hell

D:Null

答案:运行时出现异常错误

下面选项中属于函数指针的是（）。

A:int*p;

B:int(*p)(int);

C:(int*)p(int,int);

D:int*p(int,int);

答案:int(*p)(int);

若有函数max(a,b)，并且已使函数指针变量p指向函数max，当调用该函数时，正确的调用方法是（）。

A:(*p)(a,b);

B:*p(a,b);

C:*p(max(a,b));

D:(*p)max(a,b);

答案:(*p)(a,b);

对于语句int*pa[5]；下列描述中正确的是（）。

A:pa是一个具有5个元素的指针数组，每个元素是一个int*型指针

B:pa是一个指向某数组中第5个元素的指针，该元素是int型变量

C:pa是一个指向数组的指针，所指向的数组有5个int型元素

D:pa[5]表示某个元素的第5个元素的值

答案:pa是一个具有5个元素的指针数组，每个元素是一个int*型指针

第十三章单元测试

下列对结构类型变量不正确的定义是（）。

A:struct{

intnum;

intage;}teacher1,teacher2;

B:structteacher{

intnum,age;

}a;

C:struct{

intnum;

intage;

}teacher

D:structteacher{

intnum;

intage;

}teacher1;

答案:struct{

intnum;

intage;

}teacher

设有以下定义语句：

structstudent{

intnum;

charname[10];

floatscore;

}wang,zhang;

则变量wang所占的内存字节数（注：在VC环境下要考虑内存对齐规则）是（）。

A:18

B:20

C:10

D:24

答案:20

假设有如下的定义：

struct{

intn;

charc;

floatf;

}rec;

则以下各个输入语句中，正确的是（）。

A:scanf("%d",rec);

B:scanf("%c",&rec.c);

C:scanf("%f",&rec);

D:scanf("%s",&rec.c);

答案:scanf("%c",&rec.c);

#include＜stdio.h＞

structabc{

inta,b,c;

};

intmain()

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

intt;

t=s[0].a+s[1].b;

printf("%d\n",t);

return0;

}

上面程序的输出结果是（）。

A:8

B:7

C:6

D:5

答案:6

有以下说明和定义语句

structstudent{

intage;

charnum[8];

};

structstudentstu[3]={{20,"200401"},{21,"200402"},{19,"200403"}};

structstudent*p=stu;

则以下选项中引用结构体变量成员错误的是（）。

A:(p++)-＞num

B:p-＞num

C:(*p).num

D:stu[2]-＞age

答案:stu[2]-＞age

structperson{

charname[9];

intage;

};

structpersonclass[10]={"John",17,"Paul",19,"Mary",18,"Adam",16};

根据上面的定义，能打印出字母M的语句是（）。

A:printf("%c\n",class[2].name[1]);

B:printf("%c\n",class[3].name[1]);

C:printf("%c\n",class[3].name);

D:printf("%c\n",class[2].name[0]);

答案:printf("%c\n",class[2].name[0]);

若有以下程序段：

structst{

intn;

int*m;

};

inta=2,b=3,c=5;

structsts[3]=({101,&a},{102,&b},{103,&c});

intmain(){

structst*p;

p=s;

...

}

则以下表达式中值为5的是（）。

A:*((p+2).m)

B:*((p+2)-＞n)

C:*((p+2)-＞m)

D:((p+2)-＞m)

答案:*((p+2)-＞m)

union{

shortm;

chara[8];

}a,*p=&a;

a.m=100;

a.a[0]='A’;

p-＞a[1]=1;

printf("%d,%d",sizeof(a),a.m);

上面程序的运行结果是（）。

A:8,65

B:10,100

C:8,100

D:8,321

答案:8,321

以下对共用体类型数据的描述中，错误的是（）。

A:共用体类型的定义可以出现在结构类型定义中

B:共用体变量所占的内存大小，等于占用内存最多的成员所占的内存大小

C:同一个共用体变量中，各成员长度不同，所以它们的首地址是不相同的

D:在定义共用体变量的同时允许对它的第一个成员进行初始化

答案:同一个共用体变量中，各成员长度不同，所以它们的首地址是不相同的

intmain()

{

structcmplx{intx;inty;}

cnum[2]={1,3,2,7};

printf("%d\n",cnum[0].y/cnum[0].x*cnum[1].x);

return0;

}

上面程序的输出结果是（）。

A:3

B:1

C:0

D:6

答案:6

#include＜stdio.h＞

unionutype{

inti;

floatf;

}u[2];

intmain(){

printf("%d\n",sizeof(u));

return0;

}

在VC环境下上面程序的运行结果是（）。

A:6

B:4

C:8

D:16

答案:8

unionU{

shorta;

charb[4];

}u;

u.b[0]=2;

u.b[1]=1;

u.b[2]=3;

printf("%hd\n",u.a);

VC中，上面程序的执行结果是（）。

A:513

B:其他三个答案都不对

C:258

D:130

答案:258

关于typedef，以下叙述中错误的是（）。

A:用typedef定义新的类型名后，原有类型名仍有效

B:可以通过typedef增加新的类型

C:可以用typedef将已存在的类型名用一个新的名字来代表

D:用typedef可以给各种已有类型起别名，但不能给变量起别名

答案:可以通过typedef增加新的类型

设有以下语句

typedefstructS{

intg;

charh;

}T;

则下面叙述中正确的是（）。

A:可用S定义结构体变量

B:S是struct类型的变量

C:可以用T定义结构体变量

D:T是structS类型的变量

答案:可以用T定义结构体变量

设有以下定义语句

structstudent{

intnum;

charname[8];

floatscore;

}a[2];

则在VC环境下数组a所占内存的字节数是（）。

A:40

B:16

C:20

D:32

答案:32

第十四章单元测试

表达式7&&8和7&8的值分别是（）。

A:01

B:10

C:00

D:11

答案:10

表达式7||8和7|8的值分别是（）。

A:01

B:11

C:115

D:015

答案:115

表达式7^16的值是（）。

A:23

B:1

C:21

D:0

答案:23

intmain()

{

charx=040;

printf("%d\n",x=(x＜＜1));

return0;

}

以上程序的输出结果是（）。

A:100

B:64

C:160

D:120

答案:64

若有定义：

inta=20,b=28,C;

则执行语句C=(a&b)＞＞2;后C的值为（）。

A:5

B:112

C:80

D:7

答案:5

chara=3,b=6,c;

c=a^b＜＜2;

以上程序执行后c的二进制值是（）。

A:00010100

B:000