高级语言程序设计双语知到智慧树章节测试课后答案2024年秋海南大学

高级语言程序设计(双语）知到智慧树章节测试课后答案2024年秋海南大学第四章单元测试

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

A:实参和与其对应的形参共占用一个存储单元B:有当实参和与其对应的形参同名时才共占用相同的存储单元C:实参和与其对应的形参各占用独立的存储单元D:形参是虚拟的，不占用存储单元

答案:形参是虚拟的，不占用存储单元若调用一个函数，且此函数中没有return语句，则正确的说法是＿＿＿。（）

A:该函数返回若干个系统默认值B:返回一个不确定的值C:能返回一个用户所希望的函数值D:该函数没有返回值

答案:该函数没有返回值以下正确的描述是＿＿＿。（）

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

答案:函数的定义不可以嵌套，但函数的调用可以嵌套若用数组名作为函数调用的实参，传递给形参的是＿＿＿。（）

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

答案:数组的首地址以下不正确的说法是＿＿＿。（）

A:形式参数是局部变量B:在不同函数中可以使用相同名字的变量C:在函数内的复合语句中定义的变量在本函数范围内有定义D:在函数内定义的变量只在本函数范围内有定义

答案:在函数内的复合语句中定义的变量在本函数范围内有定义关于函数声明，以下不正确的说法是＿＿＿。（）

A:如果在所有函数定义之前，在函数外部已做了声明，则各个主调函数不必再做函数型声明B:如果函数定义出现在函数调用之前，可以不必加函数原型声明C:函数在调用之前，一定要声明函数原型，保证编译系统进行全面的调用检查D:标准库不需要函数原型声明

答案:函数在调用之前，一定要声明函数原型，保证编译系统进行全面的调用检查调用函数的实参与被调用函数的形参应有如下关系＿＿＿。（）

A:ABC三点均需具备B:只要求实参与形参个数相等C:只要求实参与形参数据类型相同D:只要求实参与形参顺序相同

答案:ABC三点均需具备凡在函数中未指定存储类别的变量，其隐含的存储类别是。（）

A:寄存器B:静态C:外部D:自动

答案:自动在源程序的一个文件中定义的全局变量的作用域是.（）

A:一个函数的范围B:从定义该变量的位置开始至该文件的结束C:在本文件的全部范围D:该程序的全部范围

答案:从定义该变量的位置开始至该文件的结束下列程序运行后的输出的数据是.（）

intsum(intn)

{intp=1,s=0,i;

for(i=1;i<=n;i++)s+=(p*=i);

returns;

}

intmain()

{printf("sum(5)=%d\n",sum(5));return0;

}

A:sum(5)=155B:sum(5)=152C:sum(5)=151D:sum(5)=153

答案:sum(5)=153运行下面的程序后,其输出结果是.(A)

intmain()

{inta=6,b=2,c;

c=f(a)/f（）;

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

return0;

}

intf(intx)

{inty;

y=x++*x++;

returny;

}

A:36B:18C:9D:6

答案:6下列程序运行后，若从键盘输入ABC!四个字符后，程序输出(C).

#include<stdio.h>

intmain()

{voidreceiv();

receiv();

return0;

}

voidreceiv()

{charc;

c=getchar();

putchar（）;

if(c!='!')receiv();

putchar（）;

}

A:ABCABCB:ABC!!CBAC:ABC!!D:ABC!ABC!

答案:ABC!!CBA在函数调用时，以下说法正确的是（）

A:函数间的数据传递不可以使用全局变量B:主调函数和被调函数总是在同一个文件里C:函数调用后必须带回返回值D:实际参数和形式参数可以同名

答案:实际参数和形式参数可以同名在C语言中，表示静态存储类别的关键字是.（）

A:staticB:registerC:externD:auto

答案:static未指定存储类别的变量，其隐含的存储类别为.（）

A:externB:autoC:staticD:register

答案:autoC语言程序是由()组成.（）

A:函数B:一个主程序和若干子程序C:若干子程序D:若干过程

答案:函数请读程序:

#include

FUNC(intA,intB)

{intC;

C=A+B;

returnC;}

main()

{intX=6,Y=7,Z=8,R;

R=FUNC(X+Y,Z--);

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

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

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

答案:21以下不正确的说法是.（）

A:形式参数是局部变量B:在不同的函数中可以使用相同名字的变量C:在函数内的复合语句中定义的变量在本函数范围内有效D:在函数内定义的变量只在本函数范围内有效

答案:在函数内的复合语句中定义的变量在本函数范围内有效有以下程序

viodfun(inta,intb,intc)

{a=456;b=567;c=678;}

main()

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

fun(x,y,z);

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

输出结果是.（）

A:678,567,456B:30,20,10C:10,20,30D:456,567,678

答案:10,20,30以下选项中叙述正确的是（）.

A:函数体必须由{开始B:C程序中的注释可以嵌套C:C程序必须由main语句开始D:C程序中的注释必须在一行完成

答案:函数体必须由{开始以下叙述正确的是.（）

A:每个C程序都只能有一个main函数B:每个C程序文件中的main函数都应当放在最前面C:C程序由函数组成，可以不包含main函数D:每个C程序文件都应当包含一个main函数

答案:每个C程序都只能有一个main函数简单变量做实参时，实参与其对应的形参之间的数据传递方式是.（）

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

答案:单向值传递方式以下叙述中正确的是.（）

A:所有被调用的函数一定要在调用之前进行定义B:构成C程序的基本单位是函数C:可以在一个函数中定义另一个函数D:main（）函数必须放在其他函数之前

答案:构成C程序的基本单位是函数C语言规定，程序中各函数之间（）。

A:允许直接递归调用但不允许间接递归调用B:既允许直接递归调用也允许间接递归调用C:不允许直接递归调用但允许间接递归调用D:不允许直接递归调用也不允许间接递归调用

答案:既允许直接递归调用也允许间接递归调用关于函数的参数，以下说法错误的是（）。

A:形参如果是数组名，实参可以是指针B:形参如果是数组名，则实参必须是数组名C:形参和实参可同时用指针变量D:形参和实参可同时用数组名

答案:形参如果是数组名，则实参必须是数组名C语言规定,必须用()作为主函数名。（）

A:stdioB:includeC:mainD:Function

答案:main选项中说法正确的是。（）

A:一个函数的函数体必须要有变量定义和执行部分,二者缺一不可B:一个函数的函数体必须要有执行部分,可以没有变量定义C:一个函数的函数体可以没有变量定义和执行部分,函数可以是空函数D:ABC都不对

答案:ABC都不对选项中说法正确的是（）

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

答案:main函数可以放在C程序的中间部分,即在一些函数之前在另一些函数之后,但在执行C程序时是从main函数开始的以下说法中正确的是___。（）

A:C语言程序总是从main()函数开始执行B:C语言程序总是从第一个定义的函数开始执行C:在C语言程序中,要调用的函数必须在main()函数中定义D:C语言程序中的main()函数必须放在程序的开始部分

答案:C语言程序总是从main()函数开始执行函数体一般包括：（）

A:main()B:主函数C:声明部分D:main

答案:声明部分以下说法中正确的是。（）

A:在C语言中，实参与其对应的形参共占同一个存储单元。B:在语言中，只有当实参与其对应的形参同名时，才共占同一个存储单元。C:在C语言中，实参与其对应的形参各占独立的存储单元。D:在C语言中，形参是虚拟的，不占存储单元。

答案:在C语言中，实参与其对应的形参各占独立的存储单元。凡是函数中未指定存储类别的局部变量其隐含的存储类别是（）。

A:外部（extern）B:寄存器（register）C:静态（static）D:自动（auto）

答案:自动（auto）设变量a是整型，f是实型，i是双精度型，则表达式10+‘a’+i*f值的数据类型为（）。

A:floatB:doubleC:intD:不确定

答案:double函数调用结束后，其值还须保留的局部变量可用（）来声明。（）

A:autoB:externC:registerD:static

答案:static以下叙述中正确的是。（）

A:在源文件的一行上可以有多条预处理命令B:宏替换不占用程序的运行时间C:预处理命令行必须位于源文件的开头D:宏名必须用大写字母表示

答案:在源文件的一行上可以有多条预处理命令函数调用语句：fun((a,b),(c,d,e));，实参个数为（）。

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

答案:2运行下面程序，其输出结果是（）。

#include<stdio.h>

intx,y;

one()

{inta,b;

a=25,b=10;

x=a-b;y=a+b;

}

intmain()

{inta,b;

a=9,b=5;

x=a+b;y=a-b;

one();

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

return0;

}

A:25,35B:15,45C:15,35D:15,25

答案:15,35运行下面程序，从键盘输入四个字符xyz#,其输出是（D）。

#include<stdio.h>

intmain()

{voidrecursion();

recursion();

return0;

}

voidrecursion()

{charc;

c=getchar();

putchar（）;

if(c!='#')recursion();

putchar（）;

}

A:##zyxB:xyzzyxC:xyz##zyxD:xyz##

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

intk=0;

voidfun(intm)

{m+=k;k+=m;printf("m=%d\nk=%d",m,k++);}

intmain()

{inti=4;

fun(i++);printf("i=%dk=%d\n",i,k);

return0;

}

A:m=5k=5i=5k=5B:m=4k=4i=4k=4C:m=4k=4i=5k=5D:m=5k=5i=4k=4

答案:m=4k=4i=5k=5在一个C程序中，若要定义一个只允许本源程序文件中所有函数使用的全局变量，则该变量需要定义的存储类别为（）。

A:自动变量B:外部变量C:寄存器外部变量D:静态外部变量

答案:静态外部变量

第二章单元测试

下列四组选项中，正确的C语言标识符是（）。

A:a+bB:a123C:123D:%x

答案:a123C语言中的简单数据类型包括（）。

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

答案:整型、实型、字符型下面（）表达式的值为4。

A:(float)11/3B:11.0/3C:(int)(11.0/3+0.5)D:11/3

答案:(int)(11.0/3+0.5)在C语言中，函数的数据类型是指（）。

A:函数形参的数据类型B:调用该函数时的实参的数据类型C:函数返回值的数据类型D:任意指定的数据类型

答案:函数返回值的数据类型设变量a是整型，f是实型，i是双精度型，则表达式10+’a’+i*f值的数据类型为（）。

A:intB:floatC:不确定D:double

答案:double在C语言中，char型数据在内存中的存储形式是（）。

A:源码B:反码C:补码D:ASCII码

答案:ASCII码以下程序的执行结果是（）。

#include<stdio.h>

{

inti=10,j=10;

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

}

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

答案:11,10在以下一组运算符中,优先级最高的运算符是：（）。

A:&&B:<=C:%D:=

答案:%若k是int型变量,且有下面的程序片段：（）。

k=-3;

if(k<=0)

printf("；#")

else

printf("&&&&");

上面程序片段的输出结果是

A:&&&&B:有语法错误,无输出结果C:；#&&&&D:；#

答案:有语法错误,无输出结果为表示关系x≥y≥z,应使用C语言表达式（）。

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

答案:(x>=y)&&(y>=z)以下叙述正确的是：（）。

A:include和if都不能定义为用户标识符B:可以把include和if定义为用户标识符C:可以把if定义为用户标识符，但不能把include定义为用户标识符D:可以把include定义为用户标识符，但不能把if定义为用户标识符

答案:include和if都不能定义为用户标识符请选出合法的C语言赋值语句（）。

A:i++;B:a=58,b=58C:a=b=58D:k=int(a+b);

答案:i++;如果inta=3,b=4；则条件表达式"a<b?a:b"的值是（）。

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

答案:3

第三章单元测试

下述关于循环体的描述中，（）是错误的。

A:循环体中可以出现开关语句B:循环体中可以出现break语句和continue语句C:循环体中还可以出现循环语句D:循环体中不能出现goto语句

答案:循环体中不能出现goto语句有以下程序段：

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运行以下程序段后变量a的值是：（）。

inta=0,b=3;

switch(a+b&&a&&b++&&a++)

{

case0:a++;

case1:b++;

case2:a+=b;break;

case3:a-=b;

default:a;

}

A:5B:-3C:1D:6

答案:5执行下面程序片段的结果是（）。

intx=23;

do{

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

}while(!x);

A:打印出321B:打印出23C:不打印任何内容D:陷入死循环

答案:打印出23为了避免嵌套的条件分支语句if-else的二义性，C语言规定：C程序中的else总是与（）组成配对关系。

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

答案:在其之前未配对的最近的if以下不正确的if语句是（）。

A:if(x>y)printf(“%d\n”,x);B:if(x=y)&&(x!=0)x+=y;C:if(x!=y)scanf(“%d”,&x);elsescanf(“%d”,&y);D:if(x<y){x++;y++;}

答案:if(x=y)&&(x!=0)x+=y;C语言中，关系表达式和逻辑表达式的值是（）。

A:’T’或’F’B:0C:1D:0或1

答案:0或1结构化程序由顺序、选择、循环三种基本结构组成，以下相关叙述错误的是（）。

A:顺序结构是按语句在程序中的先后顺序逐条执行，没有分支，没有转移B:三种基本结构不可以嵌套使用C:选择结构是根据条件决定执行不同分支中的语句D:循环结构是根据条件决定是否重复、重复执行多少次循环体语句

答案:三种基本结构不可以嵌套使用以下程序段中，循环次数不超过10的是（）。

A:inti=6;do{i-=2;}while(i!=1);B:inti=5;do{i+=1;}while(i>0);C:inti=10;do{i=i+1;}while(i<0);D:inti=1;do{i+=2;}while(i!=10);

答案:inti=10;do{i=i+1;}while(i<0);以下描述中正确的是（）。

A:由于do-while循环中循环体语句只能是一条可执行语句,所以循环体内不能使用复合语句B:在while循环体中，循环体至少要执行一次C:do-while循环由do开始,用while结束,在while(表达式)后面不能写分号D:在do-while循环体中,循环体至少无条件的执行一次

答案:在do-while循环体中,循环体至少无条件的执行一次判断char型变量ch是否为大写字母的正确表达式是（）。

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

答案:(ch>=‘A’)&(ch<=‘Z’)

第八章单元测试

在C语言中，文件由（）。

A:记录组成B:数据行组成C:数据块组成D:字符(字节)序列组成

答案:字符(字节)序列组成下面各函数中能实现打开文件功能的是.（）

A:fputcB:fcloseC:fopenD:fgetc

答案:fopen若文件型指针fp指向某文件的末尾，则函数feof(fp)的返回值是（）。

A:NULLB:1C:非0值D:0

答案:1下列语句中，把变量fp说明为一个文件型指针的是（）。

A:FILEfp;B:filefp;C:FILE*fp;D:file*fp;

答案:FILE*fp;在进行文件操作时，写文件的一般含义是（）。

A:将磁盘中的信息存入计算机CPUB:将计算机内存中的信息存入磁盘C:将计算机CPU中的信息存入磁盘D:将磁盘中的信息存入计算机内存

答案:将计算机内存中的信息存入磁盘以读写方式打开一个已有的文本文件file1,并且FILE*fp，下面fopen函数正确的调用方式是（）。

A:fp=fopen(“file1”,“r+”)B:fp=fopen(“file1”,“rb”)C:fp=fopen(“file1”,“w”)D:fp=fopen(“file1”,“r”)

答案:fp=fopen(“file1”,“r+”)标准库函数fputs(p1,p2)的功能是（）。

A:从p1指向的文件中读一个字符串存入p2指向的内存B:从p1指向的内存中读一个字符串写到p2指向的文件中C:从p2指向的内存中读一个字符串写到p1指向的文件中D:p2指向的文件中读一个字符串存入p1指向的内存

答案:从p1指向的内存中读一个字符串写到p2指向的文件中若要打开A盘上user子目录下名为abc.txt的文本文件进行读、写操作，下面符合此要求的函数调用是（）。

A:fopen("A:\\user\\abc.txt","w")B:fopen("A:\user\abc.txt","rb")C:fopen("A:\user\abc.txt","r")D:fopen("A:\\user\\abc.txt","r+")

答案:fopen("A:\user\abc.txt","rb")若fp已正确定义并指向某个文件，当未遇到该文件结束标志时函数feof(fp)的值为（）。

A:－1B:一个非0值C:0D:1

答案:－1当已经存在一个file1.txt文件，执行函数fopen(“file1.txt”,”r+”)的功能是（）。

A:打开file1.txt文件，清除原有的内容；B:打开file1.txt文件，只能读取原有内容；C:打开file1.txt文件，只能写入新的内容；D:打开file1.txt文件，可以读取和写入新的内容；

答案:打开file1.txt文件，可以读取和写入新的内容；

第五章单元测试

以下不能对二维数组a进行正确初始化的语句是（）。

A:inta[2][3]={{1,2,3},{2,3,4},{5,6}};B:inta[2][3]={0};C:inta[][3]={1,2,3,4,5,6,7,8,9};D:inta[][3]={{1,2,3},{0}};

答案:inta[2][3]={{1,2,3},{2,3,4},{5,6}};若有定义语句：inta[3][6];按在内存中的存放顺序，a数组的第10个元素是（）。

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

答案:a[1][3]下述对C语言字符数组的描述中错误的是（）。

A:字符数组中的字符串可以整体输入、输出B:可以在赋值语句中通过赋值运算符＂=＂对字符数组整体赋值C:不可以用关系运算符对字符组中的字符串进行比较D:字符数组可以存放字符串

答案:可以在赋值语句中通过赋值运算符＂=＂对字符数组整体赋值不正确的赋值或赋初值的方式是（）。

A:charc[10]；c="hello"；B:charc[6]={'h','e','l','l','o'}；C:charc[6]={'h','e','l','l','o','\0'}；D:charc[]="string";

答案:charc[10]；c="hello"；若有说明：inta[10];则以下对数组a的使用，不正确的是（）。

A:a+1B:a++C:a[10-10]D:a[9]

答案:a++若有说明：inta[3][4]；则对a数组元素的正确引用是（）。

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

答案:a[1][0]定义如下变量和数组：

intj;

intx[3][3]=｛1,2,3,4,5,6,7,8,9｝;

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

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

printf(''%d'',x[i][2-i]);

A:159B:147C:357D:369

答案:357关于数组和指针，以下说法错误的是（）。

A:可以让一个指针指向一个同类型的数组B:指针可以指向同类型的数组中的任意一个元素C:既可以读入数据到数组中，也可以读入数据到初始值为NULL的指针所指的存储单元中D:数组名本身就是一个指针，指向数组内存的起始位置

答案:既可以读入数据到数组中，也可以读入数据到初始值为NULL的指针所指的存储单元中若有定义语句:inta[10]={0,1,2,3,4,5,6,7,8,9},*p=a;，以下选项中错误的是（）。

A:p++B:a++C:p+1D:a+1

答案:a++若定义:inta=256,*b=&a;，则printf(”%d\n”,*b);的输出结果为（）。

A:无确定值B:256C:变量a的地址D:255

答案:256若在定义语句：inta,b,c,*p=&c;之后，接着执行以下选项中的语句，则能正确执行的语句是（）。

A:scanf("%d",&p);B:scanf("%d",p);C:scanf("%d%d%d",a,b,c);D:scanf("%d",a,b,c);

答案:scanf("%d",p);对于C语言语句int*p,a[4];p=a;以下描述不正确的是（）。

A:a[3]表示数组的第4个元素的值B:p是一个指向int型的指针变量C:a++是合法的语句D:p的存储空间中保存的是数组a存储空间的首地址

答案:a++是合法的语句已知：int*p,a;则语句p=&a中的运算符&的含义是（）。

A:取变量存储单元的地址B:位与运算C:逻辑与运算D:取指针变量的内容

答案:取变量存储单元的地址若有说明语句:int*ptr[10];以下叙述正确的是（）。

A:ptr是一个具有10个指针元素的一维数组B:ptr是一个指向10个整型变量的函数指针C:ptr是一个指向具有10个整型元素的一维数组的指针D:ptr是指向整型变量的指针

答案:ptr是一个具有10个指针元素的一维数组以下关于指针的说法错误的是（）。

A:可以向指针中写入任意数据B:指针可以指向与其基类型相同的普通变量C:通过加一个正整数，可以使指针指向其他内存单元D:可以向指针所指内存单元中写入类型与指针基类型相同的数据

答案:可以向指针中写入任意数据以下判断正确的是（）。

A:char*s="string"；等价于char*s；*s="string"；B:charstr[10]={"string"}；等价于：charstr[10]；str={"string"}；C:char*s="string"；等价于char*s；s="string"；D:charstr[10]={"string"}；等价：charstr[10]；*str={"string"}；

答案:char*s="string"；等价于char*s；s="string"；关于地址和指针，以下说法正确的是（）。

A:可以取一个常数的地址赋值给同类型的指针变量B:可以取一个表达式的地址赋值给同类型的指针变量C:通过强制类型转换可以将一种类型指针变量的值赋给另一种类型的指针变量D:可以取一个指针变量的地址赋值给基类型相同的指针变量

答案:通过强制类型转换可以将一种类型指针变量的值赋给另一种类型的指针变量以下关于指针的叙述，错误的是（）。

A:在关系表达式中可以对两个基类型相同的指针变量进行比较B:两个基类型相同的指针变量不能指向同一个对象C:一个指针变量可以通过正确的赋值获得一个确定的地址值D:可以通过对指针变量加上或减去一个整数来移动指针

答案:两个基类型相同的指针变量不能指向同一个对象

第一章单元测试

C语言程序从（）开始执行。

A:程序中第一条可执行语句B:包含文件中的第一个函数C:程序中第一个函数D:程序中的main函数

答案:程序中的main函数以下不正确的C语言标识符是（）。

A:abcB:ab.cC:a_bcD:ABC

答案:ab.c下列关于C语言的说法正确的是（）。

A:C程序从main函数开始执行B:C语言不区分大小写C:C程序的三种基本结构是顺序、选择、循环D:C程序的工作过程是编辑、编译、连接、运行

答案:C程序从main函数开始执行；C程序的三种基本结构是顺序、选择、循环；C程序的工作过程是编辑、编译、连接、运行（）是构成C语言程序的基本单位。

A:函数B:子例C:子程序D:过程

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

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

答案:1下列数据中属于“字符串常量”的是（）。

A:“a”B:‘abc\0’C:‘a’D:{ABC}

答案:“a”下列for循环的次数为（）。

for(i=0,x=0;!x&&i<=5;i++)

A:1B:6C:无限D:5

答案:6C语言程序的模块化是通过以下哪个选项实现的（）。

A:语句B:程序行C:变量D:函数

答案:函数以下选项中叙述错误的是（）。

A:C语言的标识符可分为运算符、用户标识符和关键字三类B:C语言的标识符可分为语句、变量和关键字三类C:C语言的标识符可分为函数名、变量和预定义标识符三类D:C语言的标识符可分为关键字、预定义标识符和用户标识符三类

答案:C语言的标识符可分为运算符、用户标识符和关键字三类；C语言的标识符可分为语句、变量和关键字三类；C语言的标识符可分为函数名、变量和预定义标识符三类以下选项中叙述正确的是（）。

A:C程序必须由main语句开始B:C程序中的注释可以嵌套C:C程序中的注释必须在一行完成D:函数体必须由{开始

答案:函数体必须由{开始以下选项中叙述错误的是（）。

A:结构化程序的三种基本结构是循环结构、选择结构、顺序结构B:使用N－S流程图不能描述复杂算法C:计算机能够直接运行C语言源程序，不必进行任何转换D:C语言源程序不编译也能直接运行

答案:使用N－S流程图不能描述复杂算法；计算机能够直接运行C语言源程序，不必进行任何转换；C语言源程序不编译也能直接运行以下选项中叙述正确的是（）。

A:使用三种基本结构就可以实现任何复杂算法B:可运行C语言程序不需要包含main()函数C:程序语法错误要在运行时才能发现D:只要程序包含了三种基本结构中的任意一种，就是结构化程序

答案:使用三种基本结构就可以实现任何复杂算法以下选项中叙述正确的是（）。

A:算法需要包含所有三种基本结构B:有些算法不能用三种基本结构来表达C:C程序中的语句要经过编译才能转换成二进制机器指令D:简单算法的操作步骤不能超过20步

答案:C程序中的语句要经过编译才能转换成二进制机器指令以下选项中叙述错误的是（）。

A:全部三种基本结构都包含的才是结构化程序B:C语言程序可以定义多个不同内容的main函数C:复杂任务可以分解成简单子任务D:C语言程序中的所有函数必须保存在同一个源文件中

答案:全部三种基本结构都包含的才是结构化程序；C语言程序可以定义多个不同内容的main函数；C语言程序中的所有函数必须保存在同一个源文件中以下叙述中错误的是（）。

A:书写风格良好的程序执行效率高B:C程序可以在一行上写多条语句C:C程序允许将一条语句分写在多行上D:书写风格良好的程序易读性好

答案:书写风格良好的程序执行效率高

绪论单元测试

C语言属于一门_____的语言（）。

A:面向过程;B:面向对象;C:机器语言;D:汇编语言;

答案:面向过程;

第六章单元测试

变量a所占的内存字节数是（）。

structstu

{charname[20];

longintn;

intscore[4];

}a;

A:32B:30C:36D:28

答案:32structperson{charname[9];intage;};

structpersoncalss[4]={"Johu",17,

"Paul",19,

"Mary",18,

"Adam",16,};

根据这些定义,能输出字母M的语句是（）。

A:printf("%c\n",class[2].name[1]);B:printf("%c\n",class[2].name[0]);C:printf("%c\n",class[3].name);D:printf("%c\n",class[3].name[1]);

答案:printf("%c\n",class[2].name[0]);以下程序的输出是（）。

structst

{intx;int*y;}*p;

intdt[4]={10,20,30,40};

structstaa[4]={50,&dt[0],60,&dt[0],60,&dt[0],60,dt[0],};

main()

{p=aa;

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

}

A:11B:10C:60D:51

答案:51以下程序的输出结果是（）。

structHAR

{intx,y;structHAR*p;}h[2];

main()

{inth[0].x=1;h[0].y=2;

h[1].x=3;h[1].y=4;

h[0].p=&h[1];h[1].p=h;

printf("%d%d\n",(h[0].p)->x,(h[1].p）->y);}

A:12B:14C:23D:32

答案:32设有变量定义

structstu

{intage；

intnum；

}std，*p=&std；

能正确引用结构体变量std中成员age的表达式是（）。

A:*p.ageB:*std->ageC:(*p).ageD:std->age

答案:(*p).age若有以下说明语句：

structstudent

{intnum;

charname[];

floatscore;

}stu;

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

A:num,score都是结构体成员名B:structstudent是用户定义的结构体类型C:stu是用户定义的结构体类型名D:struct是结构体类型的关键字

答案:stu是用户定义的结构体类型名若有以下说明语句：

structdate

{intyear;

intmonth;

intday;

}brithday;

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

A:structdate是用户定义的结构体类型名B:brithday是用户定义的结构体类型名C:struct是声明结构体类型时用的关键字D:year,day都是结构体成员名

答案:brithday是用户定义的结构体类型名已知：(设整型2字节，字符型1字节，浮点型4字节)

struct

{inti；

charc；

floata；

}test；

则sizeof(test)的值是（）。

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

答案:7存放100个学生的数据、包括学号、姓名、成绩。在如下的定义中，不正确的是（）。

A:structstudent{intsno;charname[20];floatscore；};structstudentstu[100];B:struct{intsno;charname[20];floatscore;}stu[100];C:structstudent{intsno;charname[20];floatscore；}stu[100];D:structstudentstu[100]{intsno;charname[20];floatscore};

答案:structstudentstu[100]{intsno;charname[20];floatscore};以下对结构变量stul中成员age的非法引用是（）。

structstudent

{intage；

intnum；

}stu1,*p；

p=&stu1；

A:stu1.ageB:p->ageC:(*p).ageD:student.age

答案:student.age设有如下定义：

structsk

{inta;

floatb;

}data;

int*p;

若要使P指向data中的a域，正确的赋值语句是（）。

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

答案:p=&data.a;

第七章单元测试

若有以下定义和语句:chars[10]:s="abcd";printf("%s\n",s);则结果是(以下u代表空格)。（）

A:编译不通过B:输出abcdC:输出abcduuuuuD:输出a

答案:编译不通过若变量已正确说明为float类型,要通过语句scanf("%f%f%f",&a,&b,&c);给a赋于10.0，b赋予22.0，c赋予33.0，不正确的输入形式是。（）

A:1022<回车>33<回车>B:10<回车>22<回车>33<回车>C:10.0,22.0,33.0<回车>D:10.0<回车>22.033.0<回车>

答案:10.0,22.0,33.0<回车>'若有定义:intx,y;chara,b,c;并有以下输入数据(此处<CR>代表换行符，/u代表空格):1u2<CR>AuBuC则能给x赋整数1,给y赋整数2,给a赋字符A,给b赋字符B,给c赋字符C的正确程序段是。（）

A:scanf("%d%d%c%c%c%c%c%c",&x,&y,&a,&a,&b,&b,&c,&c);B:scanf("%d%d%c%c%c",&x,&y,&a,&b,&c);C:scanf("%d%d",&x,&y);a=getchar();b=getchar();c=getchar();D:scanf("x=%dy+%d",&x,&y);a=getchar();b=getchar();c=getchar();

答案:scanf("%d%d%c%c%c%c%c%c",&x,&y,&a,&a,&b,&b,&c,&c);若有以下定义和语句charc1='b',c2='e';printf("%d,%c\n",c2-c1,c2-'a'+"A");则输出结果是。（）

A:2,EB:输出项与对应的格式控制不-致，输出结果不确定C:3,ED:2,M

答案:3,E下面程序的输出结果是。（）

main()

{inta=1,b=2;

printf("%d\n",a=a+1,a+6,b+2);}

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

答案:2下列程序执行后的输出结果是。（）

main()

{intx='f';printf("%c\n",'A'+(x-'a'+1));}

A:HB:IC:JD:G

答案:G下列程序执行后的输出结果是(小数点后只写-位)。（）

main()

{doubled;floatf;longl;inti;

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

printf("%d%ld%f%f\n",i,l,f,d);}

A:666.76.7B:666.06.0C:666.06.7D:666.76.0

答案:666.06.0printf函数中用到格式符%5s,其中数字5表示输出的字符串占用5列。如果字符串长度大于5,则输出按方式.（）

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

答案:按原字符长从左向右全部输出printf函数中用到格式符%5s,其中数字5表示输出的字符串占用5列。如果字符串长度小于5,则输出按方式。（）

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

答案:输出错误信息已有定义inta=-2;和输出语句:printf("%8lx",a);以下正确的叙述是。（）

A:%8lx不是错误的格式符,其中数字8规定了输出字段的宽度B:%x是格式符的-种,其变量的值按+六进制输出,但%8lx是错误的C:整型变量的输出格式符只有%d-种D:%x是格式符的-种,它可以适用于任何-种类型的数据

答案:%8lx不是错误的格式符,其中数字8规定了输出字段的宽度若x,y均定义为int型,z定义为double型,以下不合法的scanf函数调用语句是。（）

A:scanf("%x%o%6.2f",&x,&y,&z);B:scanf("%2d*%d%lf",&x,&y,&z);C:scanf("%d%lx,%le",&x,&y,&z);D:scanf("%x%*d%o",&x,&y);

答案:scanf("%x%o%6.2f",&x,&y,&z);已有如下定义和输入语句,若要求a1,a2,c1,c2值分别为10,20,A和B,当从第1列开始输入数据时,正确的数据输入方式是。（）

inta1,a2;charc1,c2;

scanf("%d%c%d%c",&a1,&c1,&a2,&c2);

A:10A20B<CR>B:10A20<CR>C:10A20B<cR>D:10A20B<CR>

答案:10A20B<CR>已有定义intx;f1oaty;且执行scanf("%3d%f",&x,&y);语句,若从第1列开始输入数据12345678(回车),则x的值为。（）

A:12345B:345C:45D:123

答案:123已有定义intx;f1oaty;且执行scanf("%3d%f",&x,&y);语句,若从第1列开始输入数据12345678(回车),则y的值。（）

A:无定值B:678.000000C:123.00000D:45.0000

答案:45.0000已有程序段和输入数据的形式如下,程序中输入语句的正确形式应当为。（）

main()

{inta;floatf;

printf("\nInputnumber:");

(输入语句)

printf("\nf=%f,a=%d\n,f,a);}

Inputnumber:4.52<CR>

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

答案:scanf("%f%d",&f,&a);根据定义和数据的输入方式,输入语句的正确形式为:

已有定义:floatfl,f2;

数据的输入方式:4.52<CR>3.5（）

A:scanf("%f,%f",&f1,&f2);B:scanf("%f%f",&f1,&f2);C:scanf("%3.2f%2.1f",&f1,&f2);D:scanf("%3.2f%2.1f",&f1,&f);

答案:scanf("%f%f",&f1,&f2);阅读下程序,若运行结果为如下形式,输入输出语句的正确内容是。（）

main()

{intx;floaty;printf("enterx,y:")

(输入语句)(输出语句)}

输入形式enterx,y:23.4

输出形式x+y=5.40

A:scanf("%d%f",&x,&y);printf("\nx+y=%6.lf",x+y);B:scanf("%d%f",&x,&y);printf("\nx+y=%4.2f",x+y);C:scanf("%d%3.1f",&x,&y);printf("\nx+y=%4.2f",x+y);D:scanf("%d,%f",&x,&y);printf("\nx+y=%4.2f",x+y);

答案:scanf("%d%f",&x,&y);printf("\nx+y=%4.2f",x+y);下面程序的输出是。（）

#include<stdio.h>

voidmain()

{intk=11;

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

}

A:k=11,k=13,k=bB:k=11,k=013,k=0xbC:k=11,k=13,k=13D:k=11,k=12,k=11

答案:k=11,k=13,k=b执行下面程序中的输出语句后,输出结果是。（）

#include<stdio.h>

voidmain()

{inta;

printf("%d\n",(a=3*5,a*4,a+5));

}

A:20B:65C:10D:15

答案:20下面程序的输出是。（）

#include<stdio.h>

voidmain()

{intx=023;

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

}

A:24B:18C:17D:23

答案:18下面程序的输出的是。（）

#include<stdio.h>

voidmain()

{intx=10,y=3;

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

}

A:0B:1C:3D:不确定的值

答案:3以下程序的输出结果是。（）

#include<stdio.h>

voidmain()

{intx=10,y=10;

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

}

A:109B:99C:1010D:910

答案:109设有如下定义:intx=10,y=3,z;

则语句printf("%d\n",z=(x%y,x/y));

的输出结果是。（）

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

答案:3若x和y都是int型变量,x=100,y=200,且有下面的程序片段:

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

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

A:输出格式符不够,输出不确定的值B:200C:100D:100200

答案:200阅读下面的程序

#include<stdio.h>

voidmain()

{

charch;

scanf("%3c3c",&ch);

printf("%c",ch);

}

如果从键盘上输入

abc<回车>

则程序的运行结果是。（）

A:bB:cC:aD:程序语法出错

答案:a阅读下面的程序

#include<stdio.h>

voidmain()

{

inti,j;

i=010;

j=9;

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

}

则程序的运行结果是。（）

A:-1,17B:-1,19C:1,19D:1,17

答案:-1,17阅读下面的程序

#include<stdio.h>

voidmain()

{

inti,j,m,n;

i=8;j=10;

m=++i;

n=j++;

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

}

程序的运行结果是。（）

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

答案:9,11,9,10阅读下面的程序

#include<stdio.h>

voidmain()

{

inti,j;

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

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

}

如果从键盘上输入1234567<回车>,则程序的运行结果是。（）

A:i=123,j=45B:i=1234,j=567C:i=123,j=4567D:i=1,j=2

答案:i=123,j=45下面程序的输出结果是。（）

#include<stdio.h>

voidmain()

{

inta=-1,b=4,k;

k=(++a<=0)&&(b--<=0);

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

}

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

答案:0,0,3下面程序的输出结果是。（）

#include<stdio.h>

voidmain()

{

inta=5,b=3;

floatx=3.14,y=6.5;

printf("%d,%d\n",a+b!=a-b,x<=(y-=6.1));

}

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

答案:1,0执