程序设计基础（C语言）知到智慧树章节测试课后答案2024年秋温州理工学院

程序设计基础（C语言）知到智慧树章节测试课后答案2024年秋温州理工学院绪论单元测试

本线上课程教学流程是通过问题“情景引入”、“讲授新知”、“启发探究”、“学以致用”、“课外拓展”五个环节开展教学的。（）

A:对B:错

答案:对

第一章单元测试

以下哪个叙述是不正确的编程风格（）。

A:使用括号来改善表达式的清晰度

B:使用有意义的标志符

C:程序中的注释可有可无

D:大小写字母用在不同场合，一般除了符号名和常量名用大写字母外，其它一律用小写字母

答案:程序中的注释可有可无

C语言程序的执行，总是起始于（）。

A:程序中的第一个函数

B:程序中的第一条可执行语句

C:main函数

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

答案:main函数

下面程序的输出是：

#include<stdio.h>intmain(){

intk=11;

printf("k=%d,k=%o,k=%x\n",k,k,k);

return0;}

A:k=11,k=12,k=11

B:k=11,k=13,k=13

C:k=11,k=13,k=bD:k=11,k=013,k=0xb

答案:k=11,k=13,k=b下面对C语言特点，不正确描述的是（）。

A:C语言的可移植性较差

B:C语言是一种结构式模块化程序设计语言

C:C语言兼有高级语言和低级语言的双重特点，执行效率高

D:C语言既可以用来编写应用程序，又可以用来编写系统程序

答案:C语言的可移植性较差

以下叙述正确的是（）

A:C语言本身没有输入输出语句

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

C:在C程序中，main函数可有可无

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

答案:C语言本身没有输入输出语句

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

A:必须在最开始

B:可以任意

C:必须在系统调用的库函数的后面

D:必须在最后

答案:可以任意

a,b均为整数,且b!=0,则表达式a/b*b+a%b的值是（）

A:b

B:a

C:a被b除的整数部分

D:a被b除的商的整数部分

答案:a

设有以下语句:intx=10;x+=3+x%(-3),则x的值是（）

A:11

B:12

C:15

D:14

答案:14

设x为int型变量,则执行语句x=10和x+=x-=x-x后,x的值为()

A:20

B:30

C:40

D:10

答案:20

main()

{

inta=12,b=12;

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

}

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

A:11,13

B:10,10

C:11,10

D:12,12

答案:11,13

阅读下面的程序

main()

{

inti,j;

scanf("%3d%2d",&i,&j);

printf("i=%d,j=%d\n",i,j);

}

如果从键盘上输入1234567＜回车＞,则程序的运行结果是()

A:i=1234,j=567

B:i=123,j=4567

C:i=123,j=45

D:i=1,j=2

答案:i=123,j=45

表达式pow(2,sqrt(9)）值的数据类型为int。(

)

A:错B:对

答案:错假设所有变量均为整型,则表达式(a=2,b=5,b++,a+b)的值是8()

A:错B:对

答案:对’aBS’是非法常量()

A:对B:错

答案:对C语言中运行’a’+1，所显示的值为97()

A:对B:错

答案:错C语言中%c用于输出字符型数据()

A:对B:错

答案:对

第二章单元测试

#include＜stdio.h＞

intmain(){

intsum=0;

printf("符号在后自增：%d\n",sum++);

printf("符号在前自增：%d\n",++sum);

return0;}

程序代码中包含了选择结构（）

A:错B:对

答案:错经过以下语句定义后，表达式z+=x＞y?++x:++y（）。intx=1,y=2,z=3；

A:2

B:5

C:3

D:6

答案:6

执行以inta=10;printf(“%d”,a++);后的输出结果和a的值是（）。

A:10和10

B:11和11

C:11和10

D:10和11

答案:10和11

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

A:int18.5%3

B:a=a+7=c+b

C:a:=b+1

D:a=b=c+2

答案:a=b=c+2

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

A:9

B:10

C:7

D:8

答案:8

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

A:-12

B:-3

C:9

D:6

答案:-12

可以用只带有一个printf（）函数的输出语句同时输出多个整型和字符型数据。（）

A:对B:错

答案:对charc1=“abc”；putchar（c1）；可以输出整个字符串“abc”。（）

A:错B:对

答案:错main（）

{charc1=97,c2=98;

printf(“%d%c”,c1,c2);

}

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

A:97b

B:ab

C:9798

D:a98

答案:97b

语句printf(“a\bre\’hi\’y\\\bou\n”;的输出结果是（说明：‘\b’是退格符）（）。

A:abre’hi’y\bou

B:re’hi’you

C:a\bre\’hi\’y\bou

D:a\bre\’hi\’y\\\bou

答案:re’hi’you

intx=3,y=2;

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

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

A:5

B:1

C:3

D:7

答案:3

printf(“%d\n”,(int)(2.5+3.0)/3);

上面语句的输出结果是（）。

A:0

B:2

C:有语法错误不能通过编译

D:1

答案:1

第三章单元测试

在if语句中，条件判断表达式不一定需要用括号括起来，在语句之后必须加分号。（）

A:对B:错

答案:错if语句的三种形式中，所有的语句应为单个语句，如果要想在满足条件时执行一组(多个)语句，则必须把这一组语句用{}括起来组成一个复合语句。在}之后能再加分号。（）

A:对B:错

答案:错一个if语句内不能出现两次及两次以上的else（）

A:对B:错

答案:错关于switch语句，break语句是语句中必须的一部分（）。

A:错B:对

答案:错关于switch语句的说法正确的是（）。

A:switch语句的每个case分支中只能设置一个语句。

B:switch语句后边的圆括号可以省略。

C:switch语句中default分支是可选的。

D:switch语句中各个case分支顺序没有规定，但是default分支必须处在所有case分支之后，否则会影响程序执行效果。

答案:switch语句中default分支是可选的。

第四章单元测试

下面有关for循环的正确描述是()

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

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

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

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

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

对for(表达式1;;表达式3)可理解为()

A:for(表达式1;表达式1;表达式3

B:for(表达式1;表达式3;表达式3)

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

D:for(表达式1;1;表达式3)

答案:for(表达式1;1;表达式3)

X=5；

do{

y=x--;

if(!y){printf(“*”);continue;}

printf(“#”);

}while(3＜=x＜=4);

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

A:输出错误信息

B:死循环

C:；

D:##*

答案:死循环

设有程序段:intk＝10;while(k＝0)k＝k－1;则下面描述中正确的是（）

A:循环体语句一次也不执行

B:无限循环

C:循环执行10次

D:循环体语句执行一次

答案:循环体语句一次也不执行

charc[]="abc";inti=0;do{}while(c[i++]!='\0')

;printf("%d",i-1);以上程序段的输出结果为（）

A:abcB:2C:3

D:ab

答案:3

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

A:E!=1B:E==0C:E!=0D:E==1

答案:E==0break和continue语句用法几乎一样，只能用在循环结构中（）

A:对B:错

答案:错关于break和continue语句，以下选项正确的是()。

A:break语句结束循环后继续执行循环语句的后续语句

B:continue语句结束循环后继续执行循环语句的后续语句

C:continue语句在for循环和while循环中都可以使用

D:break语句只作用于语句所在层循环

答案:break语句结束循环后继续执行循环语句的后续语句

；continue语句在for循环和while循环中都可以使用

；break语句只作用于语句所在层循环

for(y=1;y＜10;)

y=((x=3*y,x+1),x-1);printf("x=%d,y=%d",x,y);

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

A:x=y=27

B:x=27,y=27

C:x=15,y=14

D:x=12,y=13

答案:x=15,y=14

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

A:不定

B:4

C:3

D:5

答案:4

第五章单元测试

sqrt()函数与pow()函数类似，再调用sqrt()函数前我们需要做什么准备（）。

A:调用库#include＜math.h＞

B:定义函数doublesqrt;

C:调用库#include＜math＞

D:不需要多做准备

答案:调用库#include＜math.h＞

被调函数的实参与形参的相同点正确的有（）。

A:两者的变量名称必定相同

B:两者的变量类型必定相同

C:两者的地址必定相同

D:两者的值必定相同

答案:两者的变量类型必定相同

；两者的值必定相同

函数必须有返回值。（）

A:对B:错

答案:错在使用函数的嵌套调用时，被调用的函数必须要有返回值。()

A:错B:对

答案:错提前声明sum函数，以下代码正确的有：()

A:sum(inta,intb){};

B:doublesum(doublea,doubleb){};

C:doublesum(doublea,doubleb);

D:intsum(int,int)

答案:doublesum(doublea,doubleb);

以下代码中，正确的是：()

A:

intsum(inta){

returna+b;

}

intcal(intn){

returnsum(n,n+1);

}

B:

intsum(inta,intb){

a+b;

}

intcal(intn){

returnsum(n,n+1);

}

C:

intsum(inta,intb){

returna+b;

}

intcal(intn){

returnsum(n,n+1);

}

D:

intsum(inta,intb){

returna+b;

}

intcal(intn){

returnsum(n);

}

答案:

intsum(inta,intb){

returna+b;

}

intcal(intn){

returnsum(n,n+1);

}

在自定义函数中调用其它函数与在主函数中调用其它函数语法格式是相同的。()

A:错B:对

答案:对递归调用的基本思想就是自己调用自己，一个使用递归技术的方法将直接或间接地调用自身的方法。()

A:对B:错

答案:对一个递归的定义可以用递归过程求解，也可以用非递归过程求解，但单从运行时间来看，通常递归过程比非递归过程()

A:较快

B:相同

C:无法确定

D:较慢

答案:较慢

下列关于函数递归调用描述不正确的是()。

A:向下的递归调用过程被称为是“递归过程”

B:递归过程必须解决的问题有三个

C:向上携带返回表达式的过程被称为是“回溯过程”

D:函数的递归调用就是函数对自身的调用

答案:递归过程必须解决的问题有三个

一个递归的定义可以用递归的过程求解，通常递归的执行过程是()的。

A:高效

B:高质量

C:低质量

D:低效

答案:低效

关于方法的递归，一下说法正确的是()。

A:方法递归其实就是调用其他方法

B:方法递归是指方法的返回值不同

C:说法都不对

D:方法递归就是指在一个方法的内部调用自身的过程

答案:方法递归就是指在一个方法的内部调用自身的过程

第六章单元测试

定义数组inta[5]={0}，最后一个0的索引下标是多少（）

A:4

B:0

C:5

D:-1

答案:4

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

A:*p+9

B:*p+=9

C:P+7

D:*(p+8)

答案:*(p+8)

下列关于数组说话正确的是（）

A:数组的大小是可变的，可以有不同的类型的数组元素

B:数组的大小是可变的，但所有数组元素的类型必须相同

C:数组的大小是固定的，但可以有不同的类型的数组元素

D:数组的大小是固定的，所有数组元素的类型必须相同

答案:数组的大小是固定的，所有数组元素的类型必须相同

下列4个数组定义中，错误的为（）

A:Intn,d[n]

B:#defineN5longb[N];

C:Inta[7]

D:Charc[5]

答案:Intn,d[n]

在数组中，数组名表示()。

A:数组所有元素的首地址

B:数组最后1个元素的首地址

C:数组第2个元素的首地址

D:数组第1个元素的首地址

答案:数组第1个元素的首地址

合法的数组定义是()。

A:chara="string";

B:chara[]={0,1,2,3,4,5}

C:chara[]="string";

D:inta[5]={0,1,2,3,4,5};

答案:chara[]="string";

intN=5,b[N][N]正确定义了数组。()

A:对B:错

答案:错若有说明：inta[][3]={1,2,3,4,5,6,7};则a数组第一堆的大小是()

A:4

B:无确定值

C:2

D:3

答案:3

若有说明：inta[][4]={0,0}，则下面正确的叙述是：()

A:有元素a[0][0]和元素a[1][0]可得到初值0，其他元素均得不到初值0。

B:数组a的每个元素都可得到初值0。

C:二维数组a的第一维大小为1。

D:因为二维数组a中第二维大小的值除经初值个数的商为1，故数组a的行数为1。

答案:数组a的每个元素都可得到初值0。

；二维数组a的第一维大小为1。

；因为二维数组a中第二维大小的值除经初值个数的商为1，故数组a的行数为1。

语句floata[3][4];定义了a为3*4（3行4列）的数组。()

A:错B:对

答案:对

第七章单元测试

若有语句:inta=4,*p=&a;下面均代表地址的一组选项是:（）。

A:*&a,&a,*pB:&a,p,&*pC:*&p,*p,&aD:a,p,&*a

答案:&a,p,&*p下面说明不正确的是：（）。

A:float(*p)();B:int**p;C:int*a[4];D:char*(*a[]);

答案:char*(*a[]);已有变量定义和函数调用语句：inta=25;print_value(&a);则下面函数的正确输出结果是（）。

voidprint_value(int*x)

{printf("%d\n",++(*x));}

A:26B:25C:24D:23

答案:26若有语句intb[5]={1,2,3,4,5},*p=b;则（）不是对b数组元素的正确引用（其中0<=i且i<5）。

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

答案:*(*(b+i))如果a是整型变量，则合法的形式是（）。

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

答案:*&xvoid类型的指针不指向某种类型的数据，所以没有意义。（）

A:错B:对

答案:错C语言中，执行表达式(*p)++后p的指向改变了。（）

A:对B:错

答案:错Int(*p)[4]它表示p是一个指针数组，它包含4个指针变量元素。（）

A:对B:错

答案:错如果指针变量p已指向数组中的一个元素，则p+1指向同一数组中的下一个元素。（）

A:错B:对

答案:对指针数组的每个元素都是一个指针变量。（）

A:错B:对

答案:对

第八章单元测试

已经声明了一个如下的结构体类型Student：

下列哪个选项能定义一个Student类型的结构体变量？（）

A:Students=newStudent;B:structStudentst;C:Students[5];D:S="John";

答案:structStudentst;已经声明了一个如下的结构体类型Car：

以下哪个选项的结构体成员引用是正确的？（）

A:Car->year;B:car[year];C:Car.brand;D:car.price;

答案:car.price;设有以下程序段

structperson

{

charname[4];

charsex;

floatweight;

}zhang,*ptr;

ptr=&zhang;

若要从键盘读入姓名给结构体变量zhang的name成员,以下写法中错误的是（）。

A:scanf("%s",zhang*name);B:scanf("%s",(*ptr).name);C:scanf("%s",);D:scanf("%s",ptr->name);

答案:scanf("%s",zhang*name);设有如下定义

struct{intn;charc;}a[2],*p=a;

则以下错误引用结构体成员n的是（）。

A:p->nB:a[0].nC:(*p).nD:(*a)->n

答案:(*a)->n在使用结构体指针时，以下哪些操作是可能的（）。

A:通过指针变量值添加成员B:通过解引用符获取结构体的数据C:动态分配内存以存储结构体实例D:通过指针进行结构体成员的访问

答案:通过解引用符获取结构体的数据；动态分配内存以存储结构体实例；通过指针进行结构体成员的访问结构体指针指向一个结构体类型变量。（）

A:对B:错

答案:对结构体指针可以动态分配自身所占有的内存空间。（）

A:错B:对

答案:错如果有一个名为personArray的结构体指针数组，要访问第三个元素的某个成员，可以使用（）。

A:personArray->member[2]B:personArray[2].memberC:personArray[2]->memberD:personArray.member[2]

答案:personArray[2]->member在动态内存分配中，如果要为结构体指针数组ptrArray分配内存，通常会使用（）。

A:malloc(sizeof(structMyStruct*)*n);B:malloc(sizeof(MyStruct)*n);C:malloc(sizeof(ptrArray)*n);D:malloc(sizeof(structMyStruct)*n);

答案:malloc(sizeof(structMyStruct*)*n);结构体指针数组与结构体数组的区别包括（）。

A:结构体指针数组的元素是指针类型，而结构体数组的元素是非指针类型B:结构体数组在声明时需要指定大小，而结构体指针数组可以动态改变大小C:结构体指针数组支持更灵活的内存管理，数组元素占有的内存空间大小可以不一样D:结构体指针数组存储的是结构体指针，而结构体数组直接存储结构体变量

答案:结构体指针数组的元素是指针类型，而结构体数组的元素是非指针类型；结构体指针数组存储的是结构体指针，而结构体数组直接存储结构体变量结构体指针数组需要遍历数组来访问每个结构体的成员。（）

A:对B:错

答案:对结构体指针数组可以动态分配数组所占有的内存空间。（）

A:错B:对

答案:错下列结构体类型在函数中的运用说法正确的是（）。

A:结构体数组的元素是结构体指针B:结构体变量不可以作为返回值C:形式参数的类型是结构体指针，实际参数的类型也必须是结构体指针D:结构体数组在函数中会隐式转换为结构体指针

答案:结构体数组在函数中会隐式转换为结构体指针已知函数定义voidfun(structexpar)，下列函数调用正确的是（）。

A:structexpar;fun(par);B:structex2par;fun(&par);C:structexpar;fun(&par);D:structex2par;fun(par);

答案:structexpar;fun(par);当需要传递结构体指针给函数时，可以使用什么作为参数（）。

A:结构体数组B:结构体指针C:结构体变量D:结构体变量的地址

答案:结构体数组；结构体指针；结构体变量的地址结构体指针不能作为函数返回值。（）

A:错B:对

答案:错函数可以不通过结构体直接修改成员的值。（）

A:错B:对

答案:对有以下程序

#include<stdio.h>

structtt

{intx;structtt*y;}s[3]={1,0,2,0,3,0};

main()

{structtt*p=s+1;

p->y=s;

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

p=p->y;

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

}

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

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

答案:2,1如果有一个名为person的结构体，其中包含一个嵌套的结构体address，要