C语言程序设计（西华大学）知到智慧树章节测试课后答案2024年秋西华大学

C语言程序设计（西华大学）知到智慧树章节测试课后答案2024年秋西华大学第一章单元测试

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

A:C语言的函数可以嵌套定义B:C语言的子程序有过程和函数两种C:C语言编译时不检查语法D:C语言所有函数都是外部函数

答案:C语言的子程序有过程和函数两种以下叙述中正确的是（）。

A:C语言中的函数不可以单独进行编译B:C语言的源程序不必通过编译就可以直接运行C:C源程序经编译形成的二进制代码可以直接运行D:C语言中的每条可执行语句最终都将被转换成二进制的机器指令

答案:C语言中的每条可执行语句最终都将被转换成二进制的机器指令C语言的注释定界符是（）。

A:/**/B:{}C:\**\D:[]

答案:/**/C语言源程序的基本单位是（）。

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

答案:函数一个算法应该具有“确定性”等五个特性，下面对另外4个特性的描述中错误的是（）

A:可行性B:有零个或多个输出C:有穷性D:有零个或多个输入

答案:有零个或多个输出以下叙述中正确的是()。

A:C语言比其他语言高级B:C语言可以不用编译就能被计算机识别执行C:C语言以接近英语国家的自然语言和数学语言作为语言的表达形式D:C语言出现的最晚,具有其他语言的一切优点

答案:C语言以接近英语国家的自然语言和数学语言作为语言的表达形式有一个命名为C001.C的C语言源程序，当正常执行后，在当前目录下不存在的文件是

A:C001.CB:C001.EXEC:C001.DATD:C001.OBJ

答案:C001.DAT能将高级语言编写的源程序转换为目标程序的是（）。

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

答案:编译程序结构化程序由三种基本结构组成,由这三种基本结构组成的算法（）。

A:可以完成任何复杂的任务B:只能完成部分复杂的任务C:只能完成一些简单的任务D:能完成符合结构化的任务

答案:能完成符合结构化的任务以下叙述中错误的是()。

A:用C语言编写的程序称为源程序，它以ASCII代码形式存放在一个文本文件中B:C语言源程序经编译后生成后缀为.obj的目标程序C:C程序经过编译、连接步骤之后才能形成一个真正可执行的二进制机器指令文件D:C语言中的每条可执行语句和非执行语句最终都将被转换成二进制的机器指令

答案:C语言中的每条可执行语句和非执行语句最终都将被转换成二进制的机器指令C语言程序将从源程序中第一个函数开始执行

A:错B:对

答案:错C语言程序中可以有多个函数,但只能有一个主函数。

A:对B:错

答案:对在C语言中，程序的模块化是利用函数实现的

A:错B:对

答案:对结构化程序设计中由三种基本结构构成的程序只能解决小规模的问题

A:对B:错

答案:错所有C程序都需要编译链接无误后才能进行

A:对B:错

答案:对C程序在运行过程中所有计算都以十进制方式进行

A:对B:错

答案:错C语言具有简洁明了的特点。

A:对B:错

答案:对C语言是一种具有某些低级语言特征的高级语言。

A:错B:对

答案:对C语言的书写格式不会影响程序的可读性。

A:错B:对

答案:错

第二章单元测试

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

A:printf("\n");B:fprintf(stdout,"\n")C:fwrite("\n",1,1,stdout);D:putchar("\n");

答案:putchar("\n");以下标识符中，不能作为合法的C用户定义标识符的是（）。

A:toB:signedC:_ifD:answer

答案:signed下面四个选项中，均是不合法的用户标识符的选项是（）。

A:AP_0doB:b-agotointC:floatla0_AD:_123tempint

答案:b-agotoint执行以下程序段后，输出结果和a的值是（）。

inta=10;printf("%d",a++);

A:11和10B:10和10C:11和11D:10和11

答案:10和11下列字符序列中，是C语言保留字的是（）。

A:scanfB:sizeofC:sqrtD:include

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

A:9861B:o13C:5LD:0

答案:o13若整型变量a与i已正确定义，且i已正确赋值，合法的语句是（）。

A:a==1B:a++=i;C:++i;D:a=a++=5;

答案:++i;下列变量说明语句中，正确的是（）。

A:intx,z;B:chara;b;c;C:char:abc;D:intx;z;

答案:intx,z;设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:0B:2C:1D:3

答案:2C语言标准格式输出函数printf()的参数表是由若干个表达式组成。

A:错B:对

答案:对C语言规定:定义符号常量时必须用大写字母。

A:错B:对

答案:错double型变量在内存中占的字节数比int型变量在内存中占的字节数多。

A:对B:错

答案:对C语言标准输入操作中,gets()函数一次只可读取一个字符。

A:对B:错

答案:错下划线是标识符中的合法字符。

A:错B:对

答案:对变量的类型通常指存储类型和数据类型两种。

A:错B:对

答案:对C语言标准输出操作中,putchar()函数可以输出显示一个字符串。

A:错B:对

答案:错一个变量的数据类型被强制转换后，它将保持被强制转换后的数据类型。

A:对B:错

答案:错任何表达式语句都是表达式加分号组成的。

A:错B:对

答案:对

第三章单元测试

下列()表达式的值为真,其中a=5;b=8;c=10;d=0

A:(a*2-c)||dB:a&&dC:a*2>8+2D:a-b

答案:a-b在C语言中，要求运算数必须是整型或字符型的运算符是（）。

A:&&B:||C:&D:!

答案:&如果inta=2,b=3,c=0,下列描述正确的是（）

A:a&&b>c的结果为假B:a>b!=c和a>(b!=c)的执行顺序是一样的C:a||(b=c)执行后b的值为0D:!a!=(b!=c)表达式的值为1

答案:!a!=(b!=c)表达式的值为1voidmain()

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

switch(x)

{case

0:b++;

case

1:a++;

case

2:a++;b++;

}

printf("a=%d,b=%d",a,b);}该程序的输出结果是(

)

A:1,1B:1,0C:2,1D:2,2

答案:2,1以下程序的运行结果是（

）。

voidmain()

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

if(a<b)

if(b<0)c=0;

else

c+=1;

printf(“%d”,c);

}

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

答案:2设有定义：inta=1,b=2,c=3;，以下语句中执行效果与其它三个不同的是（）。

A:if(a>b)c=a,a=b,b=c;B:if(a>b){c=a,a=b,b=c;}C:if(a>b)c=a;a=b;b=c;D:if(a>b){c=a;a=b;b=c;}

答案:if(a>b)c=a;a=b;b=c;有以下程序

#include<stdio.h>

voidmain()

{intc=0,k;

for(k=1;k<3;k++)

switch(k)

{default:c+=k;

case2:

c++;

break;

case4:

c+=2;break;

}

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

}

程序运行后的输出结果是（

）。

A:9B:5C:3D:7

答案:3与语句：k=a>b?(b>c?1:0):0；功能相同的是（）。

A:if((a>b)||(b>c)k=1;

elsek=0;B:if((a>b)&&(b>c))k=1;

elsek=0;C:if(a>b)k=1;

elseif(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;若a是数值类型，则逻辑表达式(a==1)||(a!=1)的值是（）。

A:1B:2C:不知道a的值，不能确定D:0

答案:1一个结构化程序必须同时由顺序、分支、循环三种结构组成

A:错B:对

答案:对逻辑表达式的值只能为1或0。

A:错B:对

答案:对有条件表达式：(EXP)?i++;j--，中(EXP)与EXP==1是等价的

A:对B:错

答案:错正确表达某个人的年龄age在10~20岁之间（不含边界）的C语言表达式是10

A:对B:错

答案:错在if语句的三种形式中，如果要想在满足条件时执行一组(多个)语句，则必须把这一组语句用{}括起来组成一个复合语句。

A:对B:错

答案:对在switch语句中，每一个的case常量表达式的值可以相同。

A:错B:对

答案:错case语句后如没有break，顺序向下执行。

A:错B:对

答案:对C语言表达式’0’<=c<=’9’可以判断c中的字符是否为数字字符

A:对B:错

答案:错条件表达式不能取代一般if的语句。

A:错B:对

答案:错if(a=5)是允许的。

A:错B:对

答案:对

第四章单元测试

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

A:do-while的循环体至少无条件执行一次B:do-while循环体不能是复合语句C:While的循环控制条件比do-while的循环控制条件严格D:do-while允许从外部转到循环体内

答案:do-while的循环体至少无条件执行一次以下不是死循环的语句是（）。

A:for(;(c=getchar())!=’\n’;)printf(“%c”,c);B:for(;;x+=i);C:for(i=10;;i++)sum+=i;D:while(1){x++;}

答案:for(;(c=getchar())!=’\n’;)printf(“%c”,c);以下程序段的输出结果是（

）。

inti,j,m=0;

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

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

m++;

printf(“%d”,m);

A:15B:20C:25D:12

答案:20有以下程序：#include<stdio.h>voidmain(){inty＝9；for(

；y>0；y－－)if(y%3＝＝0)

printf("%d"，－－y)；}程序的运行结果是()。

A:741B:875421C:852D:963

答案:852有以下程序：#include<stdio.h>voidmain()

{inti，j，m＝1；for(i＝1；i<3；i＋＋){for(j＝3；j>0；j－－){if(i*j>3)

break；m*＝i*j；}}printf("m＝%d\n"，m)；

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

A:m＝4B:m＝2C:m＝5D:m＝6

答案:m＝6有以下程序

#include<stdio.h>voidmain()

{inty=10;

while(y--);

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

}

程序执行后的输出结果是（

）。

A:y=-1B:while构成无限循环C:y=0D:y=1

答案:y=-1有以下程序

#include<stdio.h>

voidmain()

{intn=2,k=0;

while(k++&&n++>2);

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

程序运行后的输出结果是（

）。

A:13B:02C:57D:12

答案:12以下程序中的变量已正确定义for(i=0;i<4;i++,j++)

for(k=1;k<3;k++);

printf（”*”）;程序段的输出结果是（

）。

A:*B:********C:**D:****

答案:*设变量已正确定义，以下不能统计出一行中输入字符个数（不包含回车符）的程序段是（）。

A:for(n=0;getchar()!=’\n’;n++);B:n=0;while((ch=getchar())!=’\n’)n++;C:n=0;for(ch=getchar();ch!=’\n’;n++);D:n=0;while(getchar()!=’\n’)n++;

答案:n=0;for(ch=getchar();ch!=’\n’;n++);有以下程序#include<stdio.h>voidmain(){inti,j;

for(i=3;i>=l;i--)

{for(j=1;j<=2;j++)

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

printf("\n");

}}程序的运行结果是（

）。

A:45

34

23B:234

345C:23

34

45D:432

543

答案:45

34

23for循环的三个表达式可以任意省略，while,do-while也是如此。

A:对B:错

答案:错循环体如包括有一个以上的语句，则必须用{}括起来，组成复合语句。

A:错B:对

答案:对break则是结束整个循环过程，不再判断执行循环的条件是否成立。

A:对B:错

答案:对do-while循环至少要执行一次循环语句。

A:错B:对

答案:对break用于结束本次循环

A:对B:错

答案:错continue不是结束本次循环，而是终止整个循环的执行。

A:对B:错

答案:错C语言的三种循环不可以互相嵌套。

A:对B:错

答案:错do-while循环的while后的分号可以省略。

A:错B:对

答案:错结构化程序使用goto语句会很便捷

A:对B:错

答案:错已定义inti=-3;则while(i++);是死循环

A:错B:对

答案:错

第五章单元测试

以下数组定义中错误的是()。

A:intx[2][3]＝{1,2,3,4,5,6}；B:intx[][3]＝{{1,2,3}，{4,5,6}}；C:intx[][3]＝{0}；D:intx[2][3]＝{{1,2}，{3,4}，{5,6}}；

答案:intx[2][3]＝{{1,2}，{3,4}，{5,6}}；有以下程序：#include<stdio.h>#defineN

4voidfun(inta[][N]，int

b[]){inti；for(i＝0；i<N；i++)

b[i]＝a[i][i]-a[i][N-1-i]；}voidmain(){intx[N][N]＝{{1,2,3,4},{5,6,7,8},{9,10,11,12},{13,14,15,16}},y[N],i；fun(x，y)；for(i＝0；i<N；i++)

printf("%d，"，y[i])；

printf("\n")；

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

A:-3，-3，-3，-3，B:0,1,2,3，C:-3，-1,1,3,D:-12，-3,0,0,

答案:-3，-1,1,3,设有定义：chars[81];inti＝0;，以下不能将一行(不超过80个字符)带有空格的字符串正确读入的语句或语句组是()。

A:gets(s)；B:while((s[i++]＝getchar())!='\n')；s[i]＝'\0'；C:do{scanf("%c";&s[i]);}while(s[i++]!='\n')；s[i]＝'\0'；D:scanf("%s"，s)；

答案:scanf("%s"，s)；有以下程序：#include<stdio.h>voidmain(){char

s[]="012xy\08s34f4w2";

inti,n=0;

for(i=0;s[i]!=0;i++)

if(s[i]>='0'&&s[i]<='9')

n++;

printf("%d\n",n);}程序运行后的输出结果是()。

A:8B:7C:3D:0

答案:3下列定义数组的语句中，正确的是()。

A:intx[0..10]；B:intN＝10；

intx[N]；C:intx[]；D:#defineN10

intx[N]；

答案:#defineN10

intx[N]；有以下程序：#include<stdio.h>voidmain(){inta[]＝{2,3,5,4}，i；for(i＝0；i<4；i++)switch(i%2){case0：

switch(a[i]%2){case0：a[i]++；break；case1：a[i]--；

}break；case1：a[i]＝0；}for(i＝0；i<4；i＋＋)

printf("%d"，a[i])；

printf("\n")；}程序运行后的输出结果是()。

A:3040B:0304C:3344D:2050

答案:3040有以下程序：#include<stdio.h>voidmain(){intb[3][3]＝{0,1,2,0,1,2,0,1,2}，i，j，t＝1；for(i＝0；i<3；i++)for(j＝i；j<＝i；j++)

t+＝b[i][b[j][i]]；printf("%d\n"，t)；}程序运行后的输出结果是()。

A:4B:3C:9D:1

答案:4有以下程序#include<stdio.h>voidmain(){chars[]="012xy\08s34f4w2";

inti,n=0;

for(i=0;s[i]!=0;i++)

if(s[i]>='0'&&s[i]<='9')

n++;

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

}程序运行后的输出结果是（

）。

A:0B:8C:3D:7

答案:3有以下程序段charname[20];intnum;scanf("name=%snum=%d",name;&num);当执行上述程序段，并从键盘输入：name=Lilinum=1001<回车>后，name的值为（

）。

A:name=Lilinum=1001B:LiliC:name=LiliD:Lilinum=

答案:Lili在C语言中能逐个地使用下标变量，也能一次引用整个数组。

A:错B:对

答案:错能对二维数组a进行正确初始化的语句是inta[2][]={{1,0,1},{5,2,3,}};

A:错B:对

答案:错若有定义语句：intb[3][4];按在内存中的存放顺序，b数组的第4个元素是a[1][3].

A:对B:错

答案:错能对二维数组a进行正确初始化的语句是inta[][3]={{1,0,1},{},{1,1}};

A:对B:错

答案:错在c语言中，引用数组元素时，其数组下标的数据类型允许是整型表达式

A:对B:错

答案:对一个数组是由连续的一块内存单元组成的，数组名就是这块连续内存单元的首地址

A:错B:对

答案:对C语言允许用字符串的方式对数组作初始化赋值。

A:对B:错

答案:对用字符串方式赋值比用字符逐个赋值要多占一个字节，用于存放字符串结束标志’\0’。

A:对B:错

答案:对

第六章单元测试

函数调用可以作为一个独立的语句存在

A:对B:错

答案:对若函数调用时的实参为变量，函数的实参和其对应的形参共占同一存储单元

A:对B:错

答案:错定义时，函数的形参只是形式上的存在，不占用具体存储单元

A:对B:错

答案:对函数可以没有参数，但是不能没有返回值

A:错B:对

答案:错函数定义时必须给出函数体，函数体内至少有一条语句

A:对B:错

答案:错C语言中，函数可以用原型说明，也可用简单说明

A:错B:对

答案:错函数的存储类别有外部的和静态的两种，它们的作用域分别是程序级的和文件级的

A:对B:错

答案:对C程序函数的形参不可以说明为static型变量

A:对B:错

答案:对C程序函数中定义的自动变量，系统不自动赋确定的初值

A:对B:错

答案:对在一个C源程序文件中所定义的全局变量，其作用域为所在程序的全部范围

A:对B:错

答案:错有以下程序：

#include<stdio.h>

intfun(inta,intb)

{if(b==0)

returna;

else

return(fun(--a,--b));

}

voidmain(){printf("%d\n",fun(4,2));}程序的运行结果是(

)。

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

答案:2有以下程序：#include<stdio.h>intf(intx)；voidmain(){intn＝1，m；m＝f(f(f(n)))；

printf("%d\n"，m)；}intf(intx)

{returnx*2；}程序运行后的输出结果是()。

A:8B:1C:2D:4

答案:8有以下程序：#include<stdio.h>voidfun(inta[]，intn){inti，t；

for(i＝0；i<n/2；i＋＋)

{t＝a[i]；a[i]＝a[n-1-i]；a[n-1-i]＝t；}}voidmain(){intk[10]＝{1,2,3,4,5,6,7,8,9,10}，i；fun(k,5)；for(i＝2；i<8；i++)

printf("%d"，k[i])；printf("\n")；}程序的运行结果是()。

A:876543B:321678C:1098765D:345678

答案:321678有以下程序：#include<stdio.h>intfun(intx，inty){if(x!=y)

return((x＋y)/2)；else

return(x)；}voidmain(){inta＝4，b＝5，c＝6；printf("%d\n"，fun(2*a,fun(b,c)));}程序运行后的输出结果是()。

A:3B:8C:12D:6

答案:6有以下程序：#include

<stdio.h>int

fun(){static

int

x＝1；x*＝2；return

x；}voidmain(){inti，s＝1；for(i＝1；i<＝3；i++)

s*＝fun()；printf("%d\n"，s)；}程序运行后的输出结果是()。

A:0B:30C:10D:64

答案:64有以下程序

#include<stdio.h>

intf(intx);

voidmain()

{inta,b=0;

for(a=0;a<3;a++)

{b=b+f(a);

purchar('A'+b);

}

}

intf(intx)

{

returnx*x+1;

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

A:ABEB:BD1C:BCDD:BCF

答案:BD1有以下程序#include<stdio.h>#defineN

3voidfun(inta[][N],intb[]){inti,j;

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

{b[i]=a[i][0];

for(j=1;j<N;j++)

if(b[i]<a[i][j])

b[i]=a[i][j];

}

}

voidmain(){intx[N][N]={1,2,3,4,5,6,7,8,9},y[N],i;

fun(x,y);

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

printf("%d,",y[i]);

printf("\n");}

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

)。

A:1,3,5B:3,6,9C:2,4,8D:3,5,7

答案:3,6,9有以下程序#include<stdio.h>inta=1,b=2;voidfun1(inta,intb){printf("%d%d",a,b);}voidfun2(){a=3;b=4;}voidmain(){fun1(5,6);

fun2();

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

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

)。

A:5612B:5634C:3456D:1256

答案:5634设有如下函数定义intfun(intk){if(k<1)return0;

elseif(k==1)

return1;

else

returnfun(k-1)+1;}若执行调用语句：n=fun(3);，则函数fun总共被调用的次数是（

）。

A:3B:2C:4D:5

答案:3有以下程序

#include<stdio.h>intfun()

{staticintx=1;

x+=1;

returnx;

}voidmain()

{inti,s=1;

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

s+=fun();

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

}

程序运行后的输出结果是（

）。

A:120B:21C:6D:11

答案:21有以下程序#include<stdio.h>intf(intt[],intn);voidmain(){inta[4]={1,2,3,4},s;

s=f(a,4);

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

}intf(intt[],intn){if(n>0)

returnt[n-1]+f(t,n-1);

elsereturn0;

}程序运行后的输出结果是（

）。

A:10B:4C:14D:6

答案:10有以下程序#include<stdio.h>intf(intx,inty)

{return((y-x）*x);}voidmain(){inta=3,b=4,c=5,d;

d=f(f(a,b),f(a,c));

printf(“%d\n”,d);}程序运行后的输出结果是（

）。

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

答案:9有以下程序

#include<stdio.h>

intf(intx)

{inty;

if(x==0||x==1)return(3);

y=x*x-f(x-2);

returny;

}

voidmain()

{intz;

z=f(3);

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

}

程序的运行结果是（

）。

A:0B:9C:8D:6

答案:6在C语言中，只有在使用时才占用内存单元的变量，其存储类型是（）。

A:auto和staticB:static和registerC:auto和registerD:extern和register

答案:auto和register有以下程序voidf(intb[]){inti;

for(i=2;i<6;i++)b[i]*=2;}voidmain(){inta[10]={1,2,3,4,5,6,7,8,9,10},i;

f(a);

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

printf(“%d,”,a[i]);}程序运行后的输出结果是（

）。

A:1，2，6，8，10，12，14，16，9，10，B:1，2，6，8，10，12，7，8，9,10C:1，2，3，4，5，6，7，8，9，10，D:1，2，3，4，10，12，14，16，9，10，

答案:1，2，6，8，10，12，7，8，9,10在函数调用过程中，如果函数funA调用了函数funB,函数funB又调用了函数funA，则（）。

A:C语言中不允许这样的递归调用B:称为函数的间接递归调用C:称为函数的循环调用D:称为函数的直接递归调用

答案:称为函数的间接递归调用以下程序中函数f的功能是将n个字符串按由大到小的顺序进行排序。voidf(charp[][10],intn)

{chart[20];

inti,j;

for(i=0;i<n-1;i++)

for(j=i+1;j<n;j++)

if(strcmp(p[i],p[j])<0)

{strcpy(t,p[i]);strcpy(p[i],p[j]);strcpy(p[j],t);}

}voidmain()

{charp[][10]={“abc”,“aabdfg”,“abbd”,“dcdbe”,“cd”};

inti;f(p,5);

printf(“%d\n”,strlen(p[0]));

}

程序运行后的输出结果是（

）。

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

答案:5有如下程序

voidf(intx,inty)

{intt;

if(x<y)

{t=x,x=y;}

}

voidmain()

{inta=4,b=3,c=5;

f(a,b);

f(a,c);

f(b,c);

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

}

执行后输出结果是（

）。

A:5,3,4B:5,4,3C:4,3,5D:3,4,5

答案:4,3,5

第七章单元测试

有以下程序：#include<stdio.h>#definef(x)x*x*xvoidmain(){inta=3,s,t;

s=f(a+1);

t=f((a+1));

printf("%d,%d\n",s,t);}程序运行后的输出结果是(

)。

A:10,10B:64,10C:10,64D:64,64

答案:10,64有以下程序：#include<stdio.h>#definePT3.5;#define

S(x)

PT*x*x;voidmain(){inta＝1,b＝2;

printf("%4.1f\n",S(a＋b));}程序运行后的输出结果是()。

A:7.5B:31.5C:14.0D:程序有错无输出结果

答案:程序有错无输出结果fun函数的功能是：通过键盘输入给x所指的整型数组所有元素赋值。在下列划线处应该填写的是（）。#include<stdio.h>#defineN5viodfun(intx[N]){intm;

for(m=N-1;m>=0;m--)

scanf(“%d”,

);}

A:&x[m+1]B:&x[++m]C:x+mD:x+(m++)

答案:x+m有以下程序#include<stdio.h>#defineS(x)4*(x)*x+1voidmain(){intk=5,j=2;

printf("%d\n",S(k+j));}程序运行后的输出结果是（

）。

A:143B:33C:28D:197

答案:143有以下程序#include<stdio.h>#defineN8voidfun(int*x,inti){*x=*(x+i);｝voidmain(){inta[N]={1,2,3,4,5,6,7,8｝,i;fun(a,2);for(i=O;i<N/2;i++)

{printf("%d",a[i]);｝printf("\n");

｝程序运行后的输出结果是（

）。

A:1234B:1313C:2234D:3234

答案:3234在“文件包含”预处理语句的使用形式中，当#inlcude后面的文件名用“”（双引号）括起时，寻找被包含文件的方式是（）。

A:仅仅搜索源程序所在目录B:先在源程序所在目录搜索，再按系统设定的标准方式搜索C:直接按系统设定的标准方式搜索目录D:仅仅搜索当前目录

答案:先在源程序所在目录搜索，再按系统设定的标准方式搜索有以下程序#include<stdio.h>#defineN4voidfun(inta[][N],intb[]){inti;

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

b[i]=a[i][i];}voidmain(){intx[][N]={{1,2,3),{4),{5,6,7,8),{9,10}},y[N],i;

fun(x,y);

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

printf("%d,",y[i]);

printf("\n");}程序的运行结果是（）。

A:1,4,5,9B:1,2,3,4C:3,4,8,10D:1,0,7,0

答案:1,0,7,0有一个名为init.txt的文件，内容如下：

#define

HDY(A,B)

A/B

#define

PRINT(Y)

Printf(“y=%d\n”,Y)有以下程序#include“init.txt”voidmain(){inta=1,b=2,c=3,d=4,k；k=HDY(a+c，b+d)；PRINT(k)；}下面针对该程序的叙述正确的是（

）。

A:运行结果为y=6B:编译有错C:运行结果为y=0D:运行出错

答案:运行结果为y=6下列说法中正确的是（

）。

A:在程序的一行上可以出现多个有效的预处理命令行B:使用带参的宏时，参数的类型应与宏定义时的一致C:宏替换不占用运行时间，只占用编译时间D:在以下定义中CR是称为”宏名”的标识符

#defineCR045

答案:宏替换不占用运行时间，只占用编译时间预处理命令行必须位于C源程序的起始位置

A:对B:错

答案:错C语言的预处理不能实现宏定义和条件编译的功能

A:错B:对

答案:错预处理命令行的最后不能以分号表示结束

A:对B:错

答案:对在程序中凡是以“＃”开始的语句行都是预处理命令行

A:对B:错

答案:对若程序中有宏定义行:#defineN100，宏定义行中定义了标识符N的值为整数100

A:错B:对

答案:错

有以下程序：

#include<stdio.h>

#defineN5

#defineMN+1

#definef(x)(x*M)

voidmain()

{inti1,i2;

i1=f(2);

i2=f(1+1);

printf("%d

%d\n",i1,i2);

}程序的运行结果是(

)。

A:1212B:127C:1111D:117

答案:117

第八章单元测试

指针数组的元素可以是不同类型的指针。

A:错B:对

答案:错若有定义int(*pt)[3];定义了一个名为pt的指针变量，它可以指向每行有三个整数元素的二维数组

A:对B:错

答案:对若有定义语句：inta[2][3],*p[3];

则p[0]=&a[1][2];是正确的

A:对B:错

答案:对指针可以加上或减去一个int型数，也可以加上一个指针。

A:错B:对

答案:错定义语句：int*p[4];与int*(p[4]);是等价的

A:对B:错

答案:对有以下程序：

#include<stdio.h>

voidmain()

{inta=1,b=3,c=5;

int*p1=&a,*p2=&b,*p=&c;

*p=*p1*(*p2);

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

}执行后的输出结果是(

)。

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

答案:3

有以下程序：

#include<stdio.h>

voidf(int*p,int*q);

voidmain()

{intm=1,n=2,*r=&m;

f(r,&n);

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

}

voidf(int*p,int*q)

{

p=p+1;

*q=*q+1;}程序运行后的输出结果是(

)。

A:1,3B:2,3C:1,4D:1,2

答案:1,3有以下程序：#include<stdio.h>

voidfun(char*a,char*b)

{

while(*a=='*')

a++;

while(*b=*a){b++;a++;}}

voidmain()

{char*s="*****a*b****",t[80];

fun(s,t);

puts(t);

}程序的运行结果是(

)。

A:*****a*bB:abC:a*bD:a*b****

答案:a*b****设有以下函数：

voidfun(intn,char*s)

{

……

}则下面对函数指针的定义和赋值均正确的是(

)。

A:void(*pf)(int,char*);pf=fun;B:void

(*pf)(int,char);

pf=&fun;C:void*pf();*pf=fun;D:void

*pf();

pf=fun;

答案:void(*pf)(int,char*);pf=fun;有以下程序：

#include<stdio.h>

voidfun(int*s,intn1,intn2)

{inti,j,t;

i=n1;j=n2;

while(i<j)

{t=s[i];s[i]=s[j];s[j]=t;i++;j--;}

}

voidmain()

{inta[10]={1,2,3,4,5,6,7,8,9,0},k;

fun(a,0,3);

fun(a,4,9);

fun(a,0,9);

for(k=0;k<10;k++)

printf("%d",a[k]);

printf("\n");

}程序的运行结果是(

)。

A:4321098765B:5678901234C:0987654321D:0987651234

答案:5678901234以下选项中正确的语句组是()。

A:char*s;s="BOOK!";B:char*s;s={"BOOK!"};C:chars[];s="BOOK!";D:chars[10];s="BOOK!";

答案:char*s;s="BOOK!";有以下程序：#include<stdio.h>voidfun1(char*p){char*q;

q=p;

while(*q!='\0')

{(*q)++;q++;}}voidmain(){chara[]={"Program"},*p;

p=&a[3];

fun1(p);

printf("%s\n",a);}程序执行后的输出结果是(

)。

A:ProhsbnB:ProgsbnC:PrphsbnD:Program

答案:Prohsbn有以下函数：

int

aaa(char*s)

{char*t=s;

while(*t++);

t--;

return(t-s);

}以下关于aaa函数功能叙述正确的是(

)。

A:求字符串s所占字节数B:将串s复制到串tC:比较两个串的大小D:求字符串s的长度

答案:求字符串s的长度有以下程序：#include<stdio.h>#include<string.h>voidmain(){charstr[][20]＝{"One*World"，"One*Dream！"}，*p＝str[1]；printf("%d，"，strlen(p))；

printf("%s\n"，p)；}程序运行后的输出结果是()。

A:9，One*WorldB:9，One*Dream！C:10，One*WorldD:10，One*Dream！

答案:10，One*Dream！有以下程序：#include<stdio.h>#include<stdlib.h>intfun(intn){int*p；p＝(int*)malloc(sizeof(int))；*p＝n；

return

*p；}voidmain(){inta；a=fun(10)；

printf("%d\n"，a＋fun(10))；}程序的运行结果是()。

A:出错B:20C:0D:10

答案:20有以下程序：#include<stdio.h>intadd(inta，intb)

{return(a＋b)；}voidmain(){intk，(*f)(int,int)a＝5，b＝10；f＝add；…}则以下函数调用语句错误的是()。

A:k＝add(a，b)；B:k＝(*f)(a，b)；C:k＝*f(a，b)；D:k＝f(a，b)；

答案:k＝*f(a，b)；以下语句中存在语法错误的是()。

A:charss[20]＝{"right？"}；B:char*ss＝{"right？"}；C:charss[6][20]；ss[1]＝"right？"；D:char*ss[6]；ss[1]＝"right？"；

答案:charss[6][20]；ss[1]＝"right？"；有以下程序：#include<stdio.h>voidswap(char*x，char*y){char

t；

t＝*x；

*x＝*y；

*y＝t；}voidmain(){char*s1＝"abc"，*s2＝"123"；

swap(s1，s2)；

printf("%s，%s\n"，s1，s2)；}程序执行后的输出结果是()。

A:abc,123B:321，cbaC:123，abcD:1bc，a23

答案:1bc，a23有以下函数：intfun(char

*x，char

*y){intn＝0；while((*x==*y)&&*x!='\0'){x++;y++;n++;}return

n;}函数的功能是()。

A:将y所指字符串赋给x所指存储空间B:统计x和y所指字符串中最前面连续相同的字符个数C:统计x和y所指字符串中相同的字符个数D:查找x和y所指字符串中是否有''

答案:统计x和y所指字符串中最前面连续相同的字符个数设变量p是指针变量，语句p=NULL;是给指针变量赋NULL值，它等价于()。

A:p=0;B:p="";C:p='0';D:p=’’;

答案:p=0;

第九章单元测试

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

A:对B:错

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

A:错B:对

答案:对函数可以返回指向结构体变量的指针

A:错B:对

答案:对函数的返回值类型不能是结构体类型，只能是是简单类型

A:对B:错

答案:错设有定义:

structcomplex

{intreal,unreal;}data1={1,8},data2;

则data2=(2,6);是正确的。

A:对B:错

答案:错以下结构体类型说明和变量定义中正确的是()。

A:struct{intn;charc;}REC;

RECt1,t2;B:structREC;

{intn;charc;};

RECt1,t2;C:typedefstruct{intn;charc;}REC;

RECt1,t2;D:typedefstructREC;

{intn=0;charc='A';}t1,t2;

答案:typedefstruct{intn;charc;}REC;

RECt1,t2;有以下程序：#include<stdio.h>#include<string.h>structA{

inta;

charb[10];

doublec;};voidf(structAt);voidmain(){

structAa={1001,"ZhangDa",1098.0};

f(a);

printf("%d,%s,%6.1f\n",a.a,a.b,a.c);}voidf(structAt){

t.a=1002;

strcpy(t.b,"ChangRong");

t.c=1202.0;}程序运行后的输出结果是(

)。

A:1001,ZhangDa,1098.0B:1001,ChangRong,1098.0C:1002,ChangRong,1202.0D:1002,ZhangDa,1202.0

答案:1001,ZhangDa,1098.0有以下程序段：

structst

{intx;int*y;}*pt;

inta[]={1,2},b[]={3,4};

structstc[2]={10,a,20,b};

pt=c;以下选项中表达式的值为11的是(

)。

A:(pt++)->xB:pt->xC:++pt->xD:*pt->y

答案:++pt->x有以下程序：

#include<stdio.h>

structS{intn;inta[20];};

voidf(int*a,intn)

{

inti;

for(i=0;i<n-1;i++)

a[i]+=i;

}

main()

{inti;

structSs={10,{2,3,1,6,8,7,5,4,10,9}};

f(s.a,s.n);

for(i=0;i<s.n;i++)

printf("%d,",s.a[i]);

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

)。

A:2,3,1,6,8,7,5,4,10,9,B:3,4,2,7,9,8,6,5,11,10,C:1,2,3,6,8,7,5,4,10,9,D:2,4,3,9,12,12,11,11,18,9,

答案:2,4,3,9,12,12,11,11,18,9,有以下程序：#include<stdio.h>#include<string.h>typedefstruct

{charname[9];charsex;floatscore[2];}STU;voidf(STUa){

STUb={"Zhao",'m',85.0,90.0};

inti;

strcpy(,);

a.sex=b.sex;

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

a.score[i]=b.score[i];}voidmain(){STUc={"Qian",'f',95.0,92.0};

f(c);

printf("%s,%c,%2.0f,%2.0f\n",,c.sex,c.score[0],c.score[1]);}程序的运行结果是(

)。

A:Qian,f,95,92B:Zhao,f,95,92C:Zhao,m,85,90D:Qian,m,85,90

答案:Qian,f,95,92下面结构体的定义语句中，错误的是()。

A:structord{intx；inty；intz；}；structorda；B:structord{intx；inty；intz；}a；C:structord{intx；inty；intz；}structorda；D:struct{intx；inty；intz；}a；

答案:structord{intx；inty；intz；}structorda；设有以下程序段structMP3

{charname[20];

charcolor;

floatprice;}std,*ptr;ptr=&std;若要引用结构体变量std中的color成员，写法错误的是（）。

A:std.colorB:(*ptr).colorC:ptr->colorD:std->color

答案:std->color有以下函数#include<stdio.h>structstu{intmun;charname[10];intage;};viodfun(structstu*p){printf(“%s\n”,p->name);}voidmain(){structstux[3]={{01,”zhang”,20},{02,”wang”,19},{03,”zhao”,18}};

fun(x+2);}程序运行输出结果是（）。

A:zhangB:zhaoC:wangD:19

答案:zhao#include<stdio.h>structord{intx，y;}dt[2]={1,2,3,4};main(){structord*p=dt;printf("%d,",(++p)->x);

printf("%d\n",++(p->y));}程序运行后的输出结果是（

）。

A:1,2B:3,4C:2,3D:3,5

答案:3,5有如下程序段：#include<stdio.h>

voidmain(){structa{intx;inty;}num[2]={{20,5},{6,7}};printf("%d\n",num[0].x/num[0].y*num[1].y);}执行后的输出结果是（

）。

A:0B:5C:28D:20

答案:28有以下定义和语句structworkers{intnum;

charname[20];

charc;

struct

{intday;intmonth;intyear;｝s;｝;structworkersw,*pw;pw=&w;能给w中year成员赋1980的语句是（

）。

A:pw->year=1980;B:w.s.year=1980;C:*pw.year=198O;D:w.year=1980;

答案:w.s.year=1980;有以下程序#include<stdio.h>#include<string.h>structA{inta;charb[10];doublec;};structAf(structAt);voidmain(){structAa={1001,”ZhangDa”,1098.0};

a=f(a);

printf(“%d,%s,%6.1f\n”,a.a,a.b,a.c);}structAf(structAt){t.a=1002;

strcpy(t.b,”ChangRong”);

t.c=1202.0;

returnt;}程序运行后的输出结果是（

）。

A:1002,ChangRong,1202.0B:1002,ZhangDa,1202.0C:1001,ChangRong,1098.0D:1001,ZhangDa,1098.0

答案:1002,ChangRong,1202.0有以下程序#include<stdio.h>structst{intx,y;}data[2]={l,10,2,20};voidmain(){structst*p=data;

printf("%d,",p->y);

printf("%d\n",(++p)->x);}程序的运行结果是（）。

A:10,1B:10,2C:20,2D:20,1

答案:10,2有以下程序#include<stdio.h>structtt

{intx;structtt*y;}*p;structtta[4]={20,a+1,15,a+2,30,a+3,17,a};voidmain(){inti;

p=a;

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

{printf("%d,",p->x);p=p->y;}}程序的运行结果是（

）。

A:20,30B:20,15C:30,17D:15,30

答案:20,15设有以下定义

uniondata

{intd1;floatd2;}demo;

则下面叙述中错误的是

A:变量demo与成员d2所占的内存字节数相同B:若给demo.d1赋99后,demo.d2中的值是99.0C:变量demo中各成员的地址相同D:变量demo和各成员的地址相同

答案:若给demo.d1赋99后,demo.d2中的值是99.0

第十章单元测试

C语言的文件操作中，既可以顺序读写，又可以随机读写

A:对B:错

答案:对关闭打开的文件时使用函数fclose()，该函数无参数。

A:对B:错

答案:错打开一个已存在的文件并进行了写操作后，原有文件中的全部数据必定被覆盖

A:错B:对

答案:错C语言中的文件是流式文件，因此只能顺序存取数据

A:对B:错

答案:错文件由数据序列组成，可以构成二进制文件或文本文件

A:对B:错

答案:对在利用fread函数从二进制文件中读数据时，可以用数组名给数组中所有元素读入数据

A:对B:错

答案:对在程序结束时，应当用fclose函数关闭已打开的文件

A:对B:错

答案:对设fp为指向某二进制文件的指针，且已读到此文件末尾，则函数feof(fp)的返回值为()。

A:0B:非0值C:NULLD:\0'

答案:非0值设文件指针fp已定义，执行语句fp=fopen