C语言程序设计（山东联盟）知到智慧树章节测试课后答案2024年秋菏泽学院

C语言程序设计（山东联盟）知到智慧树章节测试课后答案2024年秋菏泽学院第一章单元测试

能将高级语言编写的源程序转换为目标程序的是()。

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

答案:编译程序C语言的注释定界符是()。

A:/**/B:()C:[]D:{}

答案:/**/以下标识符中,不能作为合法的C用户定义标识符的是()。

A:_123B:IFC:a3_b3D:void

答案:voidC语言源程序的基本单位是()。

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

C:函数D:子程序

答案:函数计算机能直接执行的程序是用(

)程序设计语言编写的。

A:汇编语言B:C语言

C:机器语言

D:C++

答案:机器语言

C程序中main函数的位置是（

）。

A:必须在程序的开始B:必须在程序的中间位置C:可以任意位置D:必须在程序的最后

答案:可以任意位置C语言程序上机调试步骤是（

）。

A:编写源程序、执行B:编写源程序、编译、执行C:编写源程序、编译、组建、执行D:编写源程序、组建、执行

答案:编写源程序、编译、组建、执行语句的结束标志是冒号“：”。

A:对B:错

答案:错C程序中1条语句必须写在1行。

A:错B:对

答案:错属于低级语言的是（）。

A:JAVA语言B:机器语言C:汇编语言D:C语言

答案:机器语言；汇编语言

第二章单元测试

C语言中，最基本的数据类型是（）

A:整型，字符型，逻辑型B:整型，实型，字符型，逻辑型C:整型，实型，字符型D:整型，实型，逻辑型

答案:整型，实型，字符型以下不合法的整型常量是（

）。

A:12345B:0xabcC:147D:68

答案:0xabc以下浮点数的表示不正确的是（

）。

A:22.3B:e23C:7.19E21D:12.E2

答案:e23C程序中变量可以不定义而直接使用。

A:对B:错

答案:错不能将字符串赋给字符变量。

A:对B:错

答案:对以下不合法的实型常量是（

）。

A:5B:5.0C:.5D:0.5

答案:5以下哪个是字符数据类型关键字（

）。

A:stringB:cC:charD:CHAR

答案:char在程序运行期间，变量可以多次被赋值。

A:对B:错

答案:对以下关于符号常量的说法正确的是（

）。

A:可以将圆周率这个常量值定义为符号常量，定义方法为：#define

PI=3.1415926B:符号常量是以标识符形式出现的常量，一经定义，它所代表的常量值在其作用域内不能改变C:使用符号常量不仅便于程序的调试和维护，还能大大提高程序的运行速度D:符号常量名可以不遵循C语言的标识符和命名规则

答案:符号常量是以标识符形式出现的常量，一经定义，它所代表的常量值在其作用域内不能改变以下定义变量的语句错误的是（

）。

A:int

x1;B:float

y1;C:Double

a1;D:double

z1;

答案:Double

a1;以下能正确定义变量并给变量赋值的是（

）。

A:inta=5,b=5;B:inta=b=5;C:inta,b;

a=b=6;D:inta=5,b;

b=5;

答案:inta=5,b=5;；inta,b;

a=b=6;；inta=5,b;

b=5;以下是合法C语言常量的是（

）。

A:‘a’B:012C:“a”D:e-2

答案:‘a’；012；“a”以下合法的C语言整型常量是（

）。

A:011B:01aC:-0xffffD:160

答案:011；-0xffff；160若已定义inta=11;执行printf("a=%d,a=%o,a=%x",a,a,a);语句后的输出结果是（

）。

A:a=11,a=12,a=13B:a=11,a=13,a=bC:a=11,a=11,a=bD:a=11,a=13,a=c

答案:a=11,a=13,a=b函数putchar(65)的功能是向终端输出（

）。

A:有编译错误B:6C:65D:A

答案:A

使用scanf（）函数，在输入数据时，若遇非法输入则认为该数据输入结束。

A:错B:对

答案:对getchar()和scanf（）均为输入函数，它们之间可通用，没有任何区别。

A:错B:对

答案:错

第三章单元测试

若变量已正确定义，表达式(j=3,j++)的值是____。

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

答案:3若"intn;floatf=13.8;"，则执行"n=(int)f%3"后，n的值是（）。

A:4.6B:4.33333C:1D:4

答案:1若有定义“chara;intb;floatc;doubled;”，则表达式“a*b+d-c”值的类型为____。

A:charB:intC:doubleD:float

答案:double若x为浮点型，则表达式x=10/4为（）。

A:2.5B:2.0C:3D:2

答案:2.0假设字符变量ch中存放有小写英文字母，将其转换为相应的大写英文字母的表达式是()。

A:ch=ch-'a'+'A'B:ch-='a'+'A'C:tolower(ch)D:ch=ch+32

答案:ch=ch-'a'+'A'C语言中，要求运算对象只能为整数的运算符是（）。

A:/B:>C:%

D:*

答案:%

为了确保表达式n/2的值为float型，可写成float(n/2)。

A:错B:对

答案:错若有定义：inta=8,b=5,c;，执行语句：c=a/b+0.4;后，c的值是（）。

A:2.0B:1C:2D:1.4

答案:1设有i=10，在表达式j=i--，则j的值是（）。

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

答案:10在C语言程序中，表达式5%2的结果是（）。

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

答案:1若x、i、j和k都是int型变量，则计算x=（i=4，j=16，k=32）表达式后，x的值是（）。

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

答案:32设x和y都是int型变量，则以下语句：x+=y;y=x-y;x-=y;的功能是交换x和y的值。

A:错B:对

答案:对若变量已正确定义，以下合法的赋值表达式是（）。

A:y=int(a)B:++(a+b)C:a=a/(b=5)D:a=1/b=2

答案:a=a/(b=5)逻辑运算符两侧运算对象的数据类型（）。

A:只能是0或1B:可以是任何类型的数据C:只能是整型或字符型数据D:只能是0或非0正数

答案:可以是任何类型的数据在赋值表达式中，赋值号左边既可以是变量也可以是任意表达式。

A:错B:对

答案:错若a为int型，且其值为3，则执行完表达式：

a+=6后，a的值是（）。

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

答案:9单目运算符、赋值运算符和条件运算符均为右结合性。

A:对B:错

答案:对能表示x为偶数的表达式是（）.

A:x%2B:x%2!=0C:x%2==1D:x%2==0

答案:x%2==0已知inti=10；表达式'3<=i<=5'的值是（）

A:19B:1C:20D:0

答案:1能正确表示“当x的取值在[1，10]和[200，210]范围内为真，否则为假”的表达式是（）

A:(x>=1)||(x<=10)&&(x>=200)||(x<=210)B:(x>=1)&&(x<=10)||(x>=200)&&(x<=210)C:(x>=1)||(x<=10)||(x>=200)||(x<=210)D:能正确表示“当x的取值在[1，10]和[200，210]范围内为真，否则为假”的表达式是（）

答案:(x>=1)&&(x<=10)||(x>=200)&&(x<=210)

第四章单元测试

以下程序运行时，输入的x值在（）范围时才会有输出结果。

A:大于3且不等于10的整数B:大于3且等于10的整数C:小于3的整数D:不等于10的整数

答案:大于3且不等于10的整数若a是基本整型变量，c是单精度实型变量，输入语句____是错误的。

A:scanf("d=%d,c=%f”,&a,&c);B:scanf("%d%f”,&a,&c);C:scanf("%d,%f”,&a,&c);D:scanf("%d%f”,a,c);

答案:scanf("%d%f”,a,c);main()

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

if(a<b)

c=0;

else

c++;

printf(“%d”,c);

}

该程序的输出结果是（）

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

答案:3有以下程序

main()

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

if(x>y)

if(y<z)

printf(“%d”,++z);

else

printf(“%d”,++y);

printf(“%d”,x++);

}

程序的运行结果是（）

A:1B:3C:31D:321

答案:1若x=0，y=3，z=3,以下表达式值为0的是（）。

A:x%2&&y==zB:x<y?1:0

C:!xD:y=x||z/3

答案:x%2&&y==z在C程序中，运算符%仅能用于整型数的运算。

A:错B:对

答案:对有以下程序

voidmain()

{inta;

scanf(“%d”,&a);

if(a<9)printf(“%d”,a);

elseprintf(“%d”,a--);

}程序运行时键盘输入9<回车>，则输出的结果是（）

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

答案:9为了避免嵌套的if—else语句的二义性，C语言规定else总是与（）组成配对关系。

A:在其之前未配对的最近的ifB:在其之前未配对的ifC:缩排位置相同的ifD:同一行上的if

答案:在其之前未配对的最近的if赋值运算符的结合性为左结合。

A:对B:错

答案:错if语句的基本形式是：if(表达式)语句，以下关于“表达式”值的叙述中正确的是（）

A:可以是任意合法的数值B:必须是正数C:必须是逻辑值D:必须是整数值

答案:可以是任意合法的数值

第五章单元测试

设有程序段intm=20;

while(m=0)m=m++;以下说法正确的是（）

A:循环体语句执行一次B:循环是无限循环C:while循环执行10次D:循环体语句一次也不执行

答案:循环体语句一次也不执行以下叙述正确的是（）。

A:do-while语句构成的循环不能用其它语句构成的循环来代替.B:do-while语句构成的循环只能用break语句退出.C:用do-while语句构成的循环,在while后的表达式为非零时结束循环.D:用do-while语句构成的循环,在while后的表达式为零时结束循环

答案:用do-while语句构成的循环,在while后的表达式为零时结束循环在以下给出的表达式中，与do--while(E)语句中的（E）不等价的

表达式是（）。

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

答案:(E==0)对for(表达式1;;表达式3)可理解为（）。

A:for(表达式1;1;表达式3)B:for(表达式1;表达式1;表达式3)C:for(表达式1;0;表达式3)D:for(表达式1;表达式3;表达式3)

答案:for(表达式1;1;表达式3)从循环体内某一层跳出,继续执行循环外的语句是（）。

A:break语句B:continue语句C:return语句D:空语句

答案:break语句下列程序的输出为（）。

main()

{

int

y=10;

while(y--);

printf(“y=%d

”,y);

}

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

答案:y=-1若i为整型变量，则以下循环执行次数是（）。

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

A:1次B:无限次C:2次D:0次

答案:0次C语言中while和do-while循环的主要区别是（）。

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

答案:do-while的循环体至少无条件执行一次有以下程序

main()

{inta=1,b=2;

while(a<6){b+=a;a+=2;}

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

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

)

A:5,11B:7,1C:6,1D:7,11

答案:7,11有以下程序段

intn=0,p;

do

{

scanf(“%d”,&p);

n++;

}while(p!=12345&&n<3);

此处do-while循环的结束条件是______。

A:p的值不等于12345并且n的值小于3B:p的值等于12345或者n的值大于等于3C:p的值不等于12345或者n的值小于3D:p的值等于12345并且n的值大于等于3

答案:p的值等于12345或者n的值大于等于3以下程序段中的变量已正确定义

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

for(k=1;k<3;k++)printf('*');

程序段的输出结果是()

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

答案:****以下程序的运行结果是（）。

main()

{

int

i,b,k=0;

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

{b=i%2;

while(b>0){b--;k++;}}

printf(“k=%d,b=%d”,k,b);}

A:k=8,b=-1B:k=3,b=0C:k=8,b=-2D:k=3,b=-1

答案:k=3,b=0循环结构中的continue语句是使整个循环终止执行

A:对B:错

答案:错while和do…while循环不论什么条件下它们的结果都是相同的.

A:对B:错

答案:错

第六章单元测试

在一个被调用函数中，关于return语句使用的描述，错误的是（）

A:被调用函数中，如果有返回值，就一定要有return语句B:被调用函数中，一个return语句可以返回多个值给调用函数C:被调用函数中可以使用多个return语句D:被调用函数中可以不用return语句

答案:被调用函数中，一个return语句可以返回多个值给调用函数以下（）函数的定义是错误的?

A:voidf(inti){returni+1;}B:voidf(inti){}C:intf(){return0;}D:voidf(){}

答案:voidf(inti){returni+1;}C语言中函数返回值的类型是由（）决定的。

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

答案:定义函数时所指定的函数类型C语言规定，必须用(

)作为主函数名。

A:FunctionB:stdioC:mainD:include

答案:main下列说法正确的是(

)。

A:main函数可以放在C程序的中间部分，但在执行C程序时是从程序开头执行的B:main函数可以放在C程序的中间部分，但在执行C程序时是从main函数开始的C:main函数必须放在C程序的最后D:main函数必须放在C程序的开头

答案:main函数可以放在C程序的中间部分，但在执行C程序时是从main函数开始的以下程序的输出结果是（）。

voidfun(intx,inty,intz)

{z=x*x+y*y;}

main()

{inta=31;

fun(5,2,a);

printf(“%d”,a);

}

A:29B:31C:无定值D:0

答案:31C语言规定，简单变量作实参，它与对应形参之间的数据传递方式是：(

)。

A:由用户指定传递方式B:单向值传递C:双向值传递D:地址传递

答案:单向值传递以下函数头定义正确的是：(

)。

A:double

fun(int

x,y)B:double

fun(intx,inty);C:double

fun(intx;inty)D:double

fun(intx,inty)

答案:double

fun(intx,inty)现有如下程序

#include“stdio.h”

intfun(intx)

{printf(“x=%d”,++x);

}

intmain()

{fun(12+5);return0;}

则程序的输出结果是(

)。

A:x=17

B:x=18C:x=12

D:x=13

答案:x=18有以下程序,执行后输出的结果是(

)。

voidf(intx,inty)

{intt;

if(x<y){t=x;x=y;y=t;}

}

main()

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

f(a,b);

f(a,c);

f(b,c);

printf('%d,%d,%d',a,b,c);}

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

答案:4,3,5以下关于Ｃ语言程序中函数的说法正确的是：(

)。

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

答案:函数的定义不可以嵌套，但函数的调用可以嵌套return语句在一个函数体内只能有一个。

A:错B:对

答案:错在C语言中，一个函数一般由两个部分组成，它们是函数首部和函数体。

A:错B:对

答案:对

第七章单元测试

凡是函数中未指定存储类别的局部变量，其隐含的存储类别是____。

A:staticB:registerC:externD:auto

答案:auto下列程序的输出结果是()。

#include<stdio.h>intf(intn){

staticintk,s;

n--;for(k=n;k>0;k--)s+=k;

returns;}intmain(void){

intk;

k=f(3);printf("(%d,%d)",k,f(k));

return0;}

A:(3,6)B:(6,6)C:(6,12)D:(3,3)

答案:(3,6)在一个C源程序文件中，若要定义一个只允许本源文件中所有函数使用的全局变量，则该变量需要使用的存储类别是（

）。

A:registerB:staticC:externD:auto

答案:static以下程序的输出结果是（

）。

#defineMAX(x,y)(x)>(y)?(x):(y)

main()

{

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

t=MAX(a+b,c+d)*10;

printf('%d',t);

}

A:7B:70C:6D:60

答案:7变量的有效范围与其定义的位置有关，（

）的作用域在整个源程序文件中都有效。

A:在第一个函数中定义的变量B:在主函数中定义的变量C:在函数中定义的静态变量D:在定义第一个函数之前所定义的变量

答案:在定义第一个函数之前所定义的变量以下关于编译预处理的叙述中错误的是（

）。

A:预处理命令不是C语言本身的组成部分B:预处理命令行只能位于源程序中的所有语句之前C:一条有效的预处理命令必须单独占据一行D:预处理命令行必须以#开始

答案:预处理命令行只能位于源程序中的所有语句之前如果在一个函数中的复合语句中定义了一个变量，则该变量（

）。

A:在该函数中有效B:只在该复合语句中有效C:在本程序范围内有效D:为非法变量

答案:只在该复合语句中有效进行宏定义时，宏名必须使用大写字母表示。

A:对B:错

答案:错在C语言中，在register寄存器中存储变量比在内存中存储变量运算速度快。

A:错B:对

答案:对

第八章单元测试

下面的程序段将输出▁▁▁▁▁。doublea[]={1,2,3,4,5};

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

A:48B:5C:0D:40

答案:40下面程序的运行结果是（）#include<stdio.h>intmain(){

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;

}

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

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

printf("");

return0;}

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

答案:3344以下正确地定义了一维整型数组a的语句组是（）

A:intn;scanf(“%d”,&n);inta[n];B:intn=10,a[n];C:inta[SIZE];(在程序开始有#defineSIZE10）D:inta(10);

答案:inta[SIZE];(在程序开始有#defineSIZE10）假定int类型变量占用两个字节，其有定义：intx[10]={0,2,4};则数组x在内存中所占字节数是（）。

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

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

A:[整型变量]B:[整型常量表达式]C:[整型常量]或[整型表达式]D:[整型表达式]

答案:[整型常量表达式]若有说明：inta[10];，则对a数组元素的正确引用是（）.

A:a(5)B:a[3.5]C:a[10]D:a[10-10]

答案:a[10-10]下面关于数组的描述不正确的是（）.

A:数组是构造数据类型B:数组是基本数据类型C:数组是相同数据类型的集合D:同一个数组共用一个数组名

答案:数组是基本数据类型以下能对一维数组a进行正确初始化的语句形式是（）.

A:inta[]={0};B:inta[3]=(10,5,8);C:inta[10]={};D:inta[10]=(0,0,0,0,0);

答案:inta[]={0};若有定义：intx[10]={1,2,4};则数组元素x[4]的值是（）。

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

答案:0若有说明：inta[5];，则下面可以输出数组a中所有元素值的是（）。

A:for(i=0;i<5;i++)

printf("%d",a[i]);B:while(b[i]!='')

printf("%d",a[i]);C:for(i=1;i<=5;i++)

printf(“%d”,a[i]);D:printf(“%d”,a);

答案:for(i=0;i<5;i++)

printf("%d",a[i]);下列不是给数组的第一个元素赋值的语句是（）.

A:inta[4];

scanf("%d",a);B:a[1]=2;C:inta[4]={1};D:inta[4]={2*3};

答案:a[1]=2;若有说明：inta[10]={6,7,8,9,10}；则该语句不正确，因为数组长度与初值个数不相同。

A:错B:对

答案:错一般地,一维数组各元素分配在连续地内存单元之中。

A:错B:对

答案:对

第九章单元测试

有两个字符数组s1,s2,则以下正确的输入格式是(

)

A:scanf("%s%s",s1,

s2);B:scanf("%s%s",&s1,

&s2);C:gets("s1"),

gets("s2");D:gets(s1,s2);

答案:scanf("%s%s",s1,

s2);以下不能对二维数组a进行正确初始化的语句是(

)

A:int

a[

][3]={{1,2},{0}};B:int

a[2][3]=

{{1,2},{3,4},{5,6}};C:int

a[

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

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

答案:int

a[2][3]=

{{1,2},{3,4},{5,6}};以下对二维数组a的正确说明是(

)

A:float

a[3][4];B:float

a(3,4);C:float

a(3)(4);D:int

a[3][

];

答案:float

a[3][4];若有说明：inta[][3]={1,2,3,4,5,6,7};，则a数组第一维的大小是（）

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

答案:3有以下程序段：inta[][4]={1,2,3,4,5,6,7,8,9,10,11,12};printf(“%d”,a[1][5]);，执行后输出的结果是（

）

A:4B:10C:11D:编译有错误

答案:编译有错误若有初始化语句：inta[3][4]={0};，则下面正确的叙述是（）。

A:数组a中每个元素均可得到初值0B:此初始化语句不正确C:数组a中各元素都可得到初值，但其值不一定为0D:只有元素a[0][0]可得到初值0

答案:数组a中每个元素均可得到初值0如有说明：inta[3][4];，则对a数组元素的正确引用是（）。

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

答案:a[1+1][0]对两个数组a和b进行初始化：chara[]=“ABCDEF";

charb[]={'A','B','C','D','E','F'};

则以下叙述正确的是（）

A:a与b数组完全相同B:a与b长度相同C:a的长度比b长D:a与b中都存放字符串

答案:a的长度比b长下列能正确定义二维实型数组a的选项是（）.

A:floata(3,4);B:floata[3][4];C:floata[3][]={{1},{0}};D:floata[3][];

答案:floata[3][4];下面描述正确的是（）.

A:字符串"STOP□"与“STOP"相等（其中□表示1个空格）B:两个字符串所包含的字符个数相同时，才比较字符串C:字符个数多的字符串比字符个数少的字符串大D:字符串"That"小于字符串"The"

答案:字符串"That"小于字符串"The"若有定义：chara[4]="abc",b[20]="Hello";，则执行语句strcat(b,a);后，数组b中的内容为（）.

A:abcHelloB:HelloC:abcD:Helloabc

答案:Helloabc字符数组中的数据存储时必须以'\0'结尾。

A:错B:对

答案:错有定义：chara[]="1";则a数组的长度是2。

A:对B:错

答案:对下列字符串赋值语句中，能正确把字符串Cprogram赋给数组的语句是（）

A:chara[10];

strcpy(a,"Cprogram");B:chara[10]={'C','','p','r','o','g','r','a','m',''};C:chara[]={'C','','p','r','o','g','r','a','m'};D:chara[10]={"Cprogram"};

答案:chara[10];

strcpy(a,"Cprogram");；chara[10]={'C','','p','r','o','g','r','a','m',''};；chara[10]={"Cprogram"};如有说明：inta[3][4];，则对a数组元素的合法引用是（）

A:a[0][2]B:a[0][4]C:a[1][3]D:a[2][0]

答案:a[0][2]；a[1][3]；a[2][0]

第十章单元测试

for(j=h+1;j<=max-1;j++)printf("%04d",a[j]);输出结果中，若数组小于1000则前面显示前导字符0.

A:对B:错

答案:对程序能实现求20的阶乘值。ints=1;n=1;for(n=1;n<=20;n++)s=s*n;

A:错B:对

答案:错对数组下标的访问规律变化，可用数组赋指定值实现。

A:错B:对

答案:对扫雷游戏设计数据结构只能用二维数组。

A:对B:错

答案:错程序设计基本过程包括：

A:代码的编写、调试、运行。B:界面设计。C:理解题意，分析需求。D:确定数据的组织形式即数据结构。E:总体设计和详细设计

答案:代码的编写、调试、运行。；界面设计。；理解题意，分析需求。；确定数据的组织形式即数据结构。；总体设计和详细设计一个递归算法必须包括（）。

A:终止条件和递归部分B:终止条件和循环部分C:递归部分D:循环部分

答案:终止条件和递归部分对于递归函数f，调用f(4)，其返回值为（）。

intf(intn)

{

if(n)

returnf(n-1)+n;

elsereturnn;

}

A:4B:其余选项均不是C:0D:10

答案:10调用函数f(27)的输出结果是（）。

voidf(intn)

{

if(n<5)

printf("%d",n);

else{

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

f(n/5);

}

}

A:201B:102C:21D:20

答案:201有如下函数调用语句：func(rec1，rec2+rec3，(rec4，rec5))；则该函数调用语句中，含有的实参个数是（）。

A:3B:5C:有语法错D:4

答案:3在C语言中，下列错误的说法是。

A:不允许在函数定义中再定义函数B:递归程序不可能用非递归算法实现C:函数可以递归调用D:对于continue语句，可以通过改变程序的结构而不使用它

答案:递归程序不可能用非递归算法实现对于以下递归函数f，调用f(4)，其返回值为（）。

intf(intn)

{returnf(n-1)+n;}

A:10B:11C:0D:其余选项均不是

答案:其余选项均不是有两个字符数组a,b，则以下正确的输入语句是（）.

A:scanf("%s%s",&a,&b);B:gets(a,b);C:gets("a"),gets("b");D:scanf("%s%s",a,b);

答案:scanf("%s%s",a,b);若用数组名作为函数调用时的实参，则实际上传递给形参的是()。

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

答案:数组首地址对字符串进行输入输出操作时，只能对字符串整体进行输入输出。

A:对B:错

答案:错若有说明：inta[][4]={0,0};则表示二维数组a的第一维大小为1。

A:错B:对

答案:对

第十一章单元测试

使用指针变量访问目标变量，也称为对目标变量的（）访问。

A:直接B:一次性C:一般性D:间接

答案:间接若有说明：int

i,j=7,*p=&i;则与i=j;等价的语句是（）.

A:i=p;B:i=**p;C:i=&j;D:*p=*&j;

答案:*p=*&j;inta=2，*p=&a，*q=p，则以下非法赋值语句是（）。

A:*p=*q;B:p=q;C:a=*q;D:q=a;

答案:q=a;若有定义“int*p,m=5,n;”，则下列选项中正确的是（）.

A:p=&n;

scanf("%d",*p);B:p=&n;

*p=m;C:p=&n;

scanf(“%d”,&p);D:scanf("%d",&n);

*p=n;

答案:p=&n;

*p=m;若定义：inta=5,*b=&a;则printf(“%d”,*b);的输出结果是（）。

A:a的地址B:5C:6D:无确定值

答案:5下列关于指针概念的描述，错误的是（）.

A:指针的值是可以改变的B:指针中存放的是某变量或对象的地址值C:指针的类型是他所存放的数值的类型D:指针是变量，它也具有一个内存地址值

答案:指针的类型是他所存放的数值的类型如果x是整型变量，则合法形式为（）。

A:&*xB:*xC:&(x+5)D:*&x

答案:*&x变量的指针，其含义是指该变量的（）。

A:值B:一个标志C:地址D:名

答案:地址系统对变量的直接访问是将变量的地址放在另一个内存单元中。

A:错B:对

答案:错“inti,k,*p=&i;”中定义的“*p=&i；”等价于“int*p;p=&i;”。

A:对B:错

答案:对

第十二章单元测试

假设scanf语句执行时输入ABCDE<回车>，能使puts(s)语句正确输出ABCDE字符串的程序段是__。

A:chars[5]={'A','B','C','D','E'};puts(s);B:char*s;scanf("%s",s);puts(s);C:chars[5]={"ABCDE"};puts(s);D:char*s;s="ABCDE";puts(s);

答案:char*s;s="ABCDE";puts(s);下面程序的运行结果是（）。

#include<stdio.h>intmain(void){

intx[5]={2,4,6,8,10},*p,**pp;

p=x;

pp=&p;

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

printf(”%d”,**pp);

return0;}

A:24B:44C:22D:46

答案:24根据声明inta[10],*p=a;，下列表达式错误的是（）。

A:a++B:a[9]C:p[5]D:*p++

答案:a++若有定义“inta[10]={1,2,3,4,5,6,7,8,9,10},*p;”，则下列语句正确的是（）。

A:for(p=a;p<(a+10);++a)B:for(p=a;a<(p+10);a++)C:for(p=a;p<(a+10);p++)D:for(p=a,a=a+10;p<a;p++)

答案:for(p=a;p<(a+10);p++)若有定义“inta[10],*p=a;”，则p+5表示（）。

A:a[4]的地址B:a[6]的值C:a[5]的值D:a[5]的地址

答案:a[5]的地址若有定义chara[]="Iamaboy",*b="Iamaboy";，则下列叙述错误的是（）。

A:b中存放的地址就是数组a的首地址B:b中存放的地址值可以改变C:a+3表示的是字符m的地址D:b指向其他字符串时，字符串的长度不受限制

答案:b中存放的地址就是数组a的首地址若有语句inta[10]={0,1,2,3,4,5,6,7,8,9},*p=a,则（）不是对a数组元素的正确引用（0<=i<=10）。

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

答案:*(*(a+i))若有定义“inta[5],*p=a;”，能正确引用a数组元素的是（）。

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

答案:*(a+2)设有定义语句“floats[10],*p1=s,*p2=s+5;”，下列表达式错误的是（）。

A:p2--B:p1-p2C:p1<=p2D:p1=0xffff

答案:p1=0xffff以下程序段的输出结果是（）。

char*p[]={"ABC","DEF","GHI"};

intj;

puts(p[1]);

A:ABCB:BC:CD:DEF

答案:DEF用指针变量可以指向一维数组中的元素，也可以指向多维数组中的元素。

A:错B:对

答案:对数组名代表数组的起始地址。

A:对B:错

答案:对有如下说明:int

a[10]={1,2,3,4,5,6,7,8,9,10},*p=a;则数值为9的表达式是*(p+8)。

A:对B:错

答案:对

第十三章单元测试

以下程序运行后的输出结果是____。

#include<stdio.h>structs{

intx;

inty;}data[2]={10,100,20,200};intmain(){

structs*p=data+1;

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

return0;}

A:10B:21C:20D:11

答案:20有如下定义：

structStudent{

charname[10];

intage;

chargender;}std[3],*p=std;则以下各输入语句中错误的是：

A:scanf("%s",&);B:scanf("%c",&std[0].gender);C:scanf("%c",&(p->gender));D:scanf("%d",&(*p).age);

答案:scanf("%s",&);有如下定义：struct

date{intyear;intmonth;

intday;};struct

{charname[20];charsex;structdatebirthday;}person;下面正确的赋值语句是（）。

A:person.year=1980;B:person.birthday.year=1980;C:birthday.year=1980

;D:year=1980

;

答案:person.birthday.year=1980;共用体变量在程序执行期间（）。

A:部分成员一直驻留在内存中B:所有成员一直驻留在内存中C:没有成员一直驻留在内存中D:只有一个成员一直驻留在内存中

答案:部分成员一直驻留在内存中设有以下定义：structsk{inta;floatb;}data;int*p;若要使p指向data中的a域，正确的赋值语句是（）。

A:p=&a;B:p=&data.a;C:*p=data.a;D:p=data.a;

答案:p=&data.a;对于结构体变量的引用，下列叙述正确的是（）。

A:如果成员本身就是一个结构体，只能对最低级的成员进行赋值等引用和运算。B:对结构体成员可以进行各种运算，其中“.”优先级最低。C:两个同一类型的结构体变量之间不能整体赋值。D:只能引用结构体变量成员的地址，不能引用结构体变量的地址。

答案:如果成员本身就是一个结构体，只能对最低级的成员进行赋值等引用和运算。以下叙述错误的是（）。

A:可以通过typedef增加新的类型B:可以用typedef将已存在的类型用一个新的名字代表C:用typedef定义新类型后，原有类型名仍有效D:用typedef可以为各种类型起别名，但不能为变量起别名

答案:可以通过typedef增加新的类型在一个单链表head中，若要在指针p所指结点后插入一个q指针所指结点，则执行（）。

A:q->next=p->next;p=q;B:p->next=q->next;q->next=p;C:q->next=p->next;p->next=q;D:p->next=q->next;p->next