全国计算机等级考试二级C语言（山东联盟）知到智慧树章节测试课后答案2024年秋烟台大学

全国计算机等级考试二级C语言（山东联盟）知到智慧树章节测试课后答案2024年秋烟台大学绪论单元测试

十进制的10对应的二进制表示是以下哪个选项？

A:

1000B:

10C:

1010D:

0010

答案:

1010

二进制数1000对应的十进制数是多少？

A:

8B:

10C:

1000D:

1

答案:

8

计算机中数据存储的最小单位是什么？

A:

地址B:

位C:

字节

答案:

位

计算机中数据存储的基本单位是什么？

A:

地址B:

字节C:

位

答案:

字节

计算机的存储空间中一个字节是由多少个连续的位组成？

A:

8B:

1C:

4D:

10

答案:

8

第一章单元测试

C语言主要是借助以下哪种手段来实现程序模块化（

）

A:使用三种基本结构语句B:定义函数C:定义常量和外部变量D:使用丰富的数据类型

答案:定义函数以下叙述错误的是（

）

A:程序"模块化"有利于任务的分解B:在一个任务中，单独编写的每个模块均可以独立运行C:允许对函数单独进行编译，是C语言实现"模块化"的基础D:采用模块化结构，可以提高程序编制的效率

答案:在一个任务中，单独编写的每个模块均可以独立运行以下叙述中错误的是(

)

A:计算机不能直接执行C语言程序B:C程序在运行过程中所有计算都以二进制方式进行C:所有C程序都需要编译链接无误后才能运行

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

答案:C程序在运行过程中所有计算都以十进制方式进行流程图是描述算法的很好的工具，一般的流程图中由几种基本图形组成，其中条件判断的图形是（

）

A:菱形B:椭圆型C:平行四边形D:长方形

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

A:循环结构、选择结构、顺序结构是结构化程序的三种基本结构B:计算机能直接运行未经编译的C语言程序C:计算机能够直接处理不超过20行源码的简单C语言程序D:复杂算法不能使用N－S流程图来描述

答案:循环结构、选择结构、顺序结构是结构化程序的三种基本结构

第二章单元测试

对于一个正常运行的C程序，以下叙述中正确的是（

）

A:程序的执行总是从main函数开始B:程序的执行总是从main函数开始，在程序的最后一个函数中结束C:程序的执行总是从程序的第一个函数开始，在程序的最后一个函数中结束D:程序的执行总是从程序的第一个函数开始,

在main函数结束

答案:程序的执行总是从main函数开始以下叙述中正确的是（

）

A:main的各种大小写拼写形式都可以作为主函数名，如：MAIN，Main等B:可以在程序中由用户指定任意一个函数作为主函数，程序将从此开始执行C:C语言规定必须用main作为主函数名，程序将从此开始执行D:C语言程序将从源程序中第一个函数开始执行

答案:C语言规定必须用main作为主函数名，程序将从此开始执行C语言源程序名的后缀是(

)

A:exe

B:.cpC:obj

D:.C

答案:.C以下关于注释的叙述中错误的是（）。

A:注释的内容仅用于阅读，对程序的运行不起作用B:C语言允许注释出现在程序中任意合适的地方C:注释的边界符号“/*”和“*/”必须成对出现且可以嵌套D:注释的边界符号“/”和“*”之间不允许加入空格

答案:注释的边界符号“/*”和“*/”必须成对出现且可以嵌套关于程序中的注释，以下叙述正确的是（）。

A:

注释的内容必须放在一对/*

和

*/之间

B:/*

和

*/多行注释中间不可以嵌套另一个注释

C:注释必须置于所说明的语句前或语句后

D:注释内容错误会导致编译出错

答案:/*

和

*/多行注释中间不可以嵌套另一个注释

第三章单元测试

若有定义语句：char

c='A';

则变量c在内存中占(

)

A:1个字节B:2个字节C:3个字节D:4个字节

答案:1个字节以下选项中，合法的C语言实数是（

）

A:

.2e0

B:3.1e0.4C:7.12ED:E13

答案:

.2e0

以下选项中合法的标识符是（

）

A:1_

_B:1－1C:1_1D:_11

答案:_11以下选项中叙述正确的是（

）

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

答案:C语言的标识符可分为关键字、预定义标识符和用户标识符三类C语言程序中，运算对象必须是整型数的运算符是（

）

A:

/

B:&&C:%D:*

答案:%若有定义语句：int

a=12;，则执行语句：a+=

a-=

a*a;后，a的值是（

）

A:552B:144C:-264D:264

答案:-264有以下程序

#include

<stdio.h>

intmain()

{

int

x=010,

y=10;

printf("%d,%d",

++x,

y--);

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

）

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

答案:9,10有以下程序

#include

<stdio.h>

main()

{

int

a;

a

=

(int)(-1.53*3);

printf("%d",

a);

}

程序的运行结果是(

)

A:结果不确定B:-5C:-3D:-4

答案:-4

若有定义：int

a=3;double

b=0.1263;

char

ch='a';，则以下选项中,叙述有错的是（

）。

A:逗号表达式的计算结果是最后一个逗号之后的表达式的运算结果B:语句ch=(unsignedint)a+b;是对a与b之和进行强制类型转换，结果赋值给变量chC:运算符%只能对整数类型的变量进行运算D:复合运算：a*=b+ch是将变量b、ch之和与a相乘，结果再给a赋值

答案:语句ch=(unsignedint)a+b;是对a与b之和进行强制类型转换，结果赋值给变量ch以下选项中，合法的数值型常量是（

）

A:0xDHB:092C:"A"D:3.1415

答案:3.1415

第四章单元测试

若变量已正确定义并赋值，以下不能构成C语句的选项是(

)

A:A?a:b;B:B++;C:A=a+b;D:a=a+b

答案:a=a+b若想给已定义为int型的变量a,b,c,d赋值为1，以下选项中错误的语句是（

）。

A:a=b=c=d=1;B:d=1,

c=d,

b=c,

a=b;C:a=b,

b=c,

c=d,

d=1;D:a=1,

b=a,

c=b,

d=c;

答案:a=b,

b=c,

c=d,

d=1;有以下程序

#include

<stdio.h>

main()

{

int

a=0,b=0;

/*

给a赋值

a=10;

b=20;

给b赋值

*/

printf("a+b=%d",a+b);

/*

输出计算结果

*/

}

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

)

A:出错B:a+b=0C:a+b=10D:a+b=30

答案:a+b=0有以下程序

#include

<stdio.h>

main()

{

char

c1='A',

c2='Y';

printf(

"%d,

%d",

c1,c2

);

}

程序的输出结果是(

)

A:65,89B:65,90C:A,YD:输出格式不合法，输出出错信息

答案:65,89设有定义：

int

n

=

1234;

double

x

=

3.1411;

则语句

printf("%3d,%1.3f",

n,

x);

的输出结果是(

)

A:1234,3.141B:1234,3.142C:123,3.142D:123,3.141

答案:1234,3.141有如下程序

#include

<stdio.h>

main()

{

int

x

=

0x13;

printf("%d",

x+1);

}

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

)

A:14B:20C:13D:12

答案:20若有定义

int

a;

float

b;

double

c;

程序运行时输入：

3

4

5<回车>

能把值3输入给变量a、4输入给变量b、5输入给变量c的语句是(

)

A:scanf("%lf%lf%lf",

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

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

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

&a,&b,&c);

答案:scanf("%d%f%lf",

&a,&b,&c);以下叙述中正确的是(

)

A:在使用scanf函数输入整数或实数时，输入数据之间只能用空格来分隔B:使用printf函数无法输出百分号%C:在printf函数中，各个输出项只能是变量D:在scanf函数中的格式控制字符串是为了输入数据用的，不会输出到屏幕上

答案:在scanf函数中的格式控制字符串是为了输入数据用的，不会输出到屏幕上若有定义：char

c;int

d;

，程序运行时输入：

1,2

<回车>，能把值1输入给变量c、值2输入给变量d的输入语句是(

)

A:scanf("%d,%f",

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

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

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

&c,&d);

答案:scanf("%c,%d",

&c,&d);

以下能正确输出字符a

的语句是（）

A:printf("%s",

'a');B:printf("%s",

"a");C:printf("%d",

'a');D:printf("%c",

"a");

答案:printf("%s",

"a");

第五章单元测试

表示关系式x≤y≤z的C语言表达式的是（

）

A:(x<=y<=z)B:(x<=y)!(y<=z)C:(x<=y)||(y<=z)D:(x<=y)&&(y<=z)

答案:(x<=y)&&(y<=z)已知a=5,b=6,c=7,d=8,m=2,n=2，执行(m=a>b)&&(n=c<d)后n的值为（

）

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

答案:2以下叙述中正确的是（

）

A:逻辑"或"（即运算符||）的运算级别比算术运算要高B:逻辑"非"（即运算符!）的运算级别是最低的C:由&&构成的逻辑表达式与由||构成的逻辑表达式都有"短路"现象D:C语言的关系表达式：0<x<10完全等价于:

(0<x)

&&

(x<10)

答案:由&&构成的逻辑表达式与由||构成的逻辑表达式都有"短路"现象有以下程序

#include

<stdio.h>

main()

{

int

a=0,b=0,c=0,d=0;

(++a

||

++b)

?

++c

:

++d;

printf("%d,%d,%d,%d",

a,b,c,d);

}

程序的运行结果是（

）

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

D:1,1,0,1

答案:1,0,1,0以下程序段中，不能实现条件"如果a<b则x=10，否则x=-10"的是（）

A:x=(a>=b)?

-10:10;B:x=-10;

if(a<b)

x=10;C:if(a<b)

x=10;

if(b<a)

x=-10;D:if(a<b)

x=10;

else

x=-10;

答案:if(a<b)

x=10;

if(b<a)

x=-10;有以下程序段

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

if(a>b)

a=b;

if(a>c)

a=c;

printf("%d",a);

该程序段的功能是（）

A:输出a的原始值B:输出a、b、c中值相等的数值C:输出a、b、c中的最小值D:输出a、b、c中的最大值

答案:输出a、b、c中的最小值有如下程序

#include

<stdio.h>

main()

{

int

a

=

0,

b

=

1;

if

(++a

==

b++)

printf("T");

else

printf("F");

printf("a=%d,b=%d",

a,

b);

printf("");

}

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

）

A:Ta=0,b=1

B:Fa=1,b=2

C:Ta=1,b=2D:Fa=0,b=2

答案:Ta=1,b=2下列条件语句中，输出结果与其他语句不同的是()

A:

if

(

a

)

printf("%d",

x);

else

printf("%d",

y);B:if

(

a==0

)

printf("%d",

y);

else

printf("%d",

x);C:if

(

a==0

)

printf("%d",

x);

else

printf("%d",

y);D:

if

(

a!=0

)

printf("%d",

x);

else

printf("%d",

y);

答案:if

(

a==0

)

printf("%d",

x);

else

printf("%d",

y);有以下程序

#include

<stdio.h>

main()

{

int

x=1,

y=0,a=0,b=0;

switch(

x

)

{

case

1:

switch

(

y

)

{

case

0:

a++;

break;

case

1:

b++;

break;

}

case

2:

a++;

b++;

break;

}

printf("a=%d,b=%d",a,b

);

}

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

A:a=1,b=1B:a=1,b=0C:a=2,b=1D:a=2,b=2

答案:a=2,b=1若以下选项中的变量a,

b,

y均已正确定义并赋值，则语法正确的switch语句是（）

A:switch(

a+b

)

{

case1

:

case3

:

y=a+b;

break;

case0

:

case4

:

y=a-b;}

B:switch(

a*a+b*b

)

{

default

:

break;

case

3

:

y=a+b;

break;

case

2

:

y=a-b;

break;

}

C:switch

a*b

{

case

10

:

y=a+b;

default

:

y=a-b;

}

D:switch

(a+9)

{

case

a

:

y=a-b;

case

b

:

y=a+b;}

答案:switch(

a*a+b*b

)

{

default

:

break;

case

3

:

y=a+b;

break;

case

2

:

y=a-b;

break;

}

第六章单元测试

有以下程序

#include

<stdio.h>

main()

{

int

i,

sum;

for(

i=1;

i<6;

i++

)

sum+=i;

printf("%d",

sum);

}

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

）

A:0B:随机值C:15D:16

答案:随机值有以下程序

#include

<stdio.h>

main(

)

{

int

a=-2,

b=2;

for(;

++a

&&

--b;)

printf("%d,%d,",

a,b);

}

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

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

答案:-1,1,要求通过while循环不断读入字符，当读入字母N时结束循环。若变量已正确定义，以下正确的程序段是(

)

A:while((ch=getchar())=='N')

printf("%c

",ch);B:while(ch=getchar()

='N')

printf("%c

",ch);

C:while(ch=getchar()=='N')

printf("%c

",ch);D:while((ch=getchar())!='N')

printf("%c

",ch);

答案:while((ch=getchar())!='N')

printf("%c

",ch);有以下程序

#include

<stdio.h>

main()

{

int

a

=

-2,

b

=

0;

while

(a++

&&

++b)

;

printf("%d,%d",

a,

b

);

}

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

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

答案:1,2以下叙述正确的是（

）

A:do-while语句构成的循环，当while语句中的表达式值为0时结束循环B:do-while语句和while-do构成的循环功能相同C:while-do语句构成的循环，当while语句中的表达式值为非0时结束循环D:do-while语句构成的循环，必须用break语句退出循环

答案:do-while语句构成的循环，当while语句中的表达式值为0时结束循环有以下程序

#include

<stdio.h>

main()

{

char

c;

do

{

c=getchar();

putchar(c);

}while(c

!=

'#');

printf("");

}

执行时如输入：abcdefg##<回车>

,

则输出结果是（

）

A:abcdefgB:abcdefg#C:abcdefg##D:##

答案:abcdefg#以下叙述中正确的是(

)

A:break语句只能用于switch语句体中B:break语句只能用在循环体内和switch语句体内C:continue语句的作用是：使程序的执行流程跳出包含它的所有循环D:在循环体内使用break语句和continue语句的作用相同

答案:break语句只能用在循环体内和switch语句体内有以下程序

#include

<stdio.h>

main()

{

int

a=1,

b=0;

for(;a<5;

a++)

{

if

(a%2==0)

break;

b

+=

a;

}

printf("%d

",

b);

}

程序的运行结果是（

）

A:4B:0

C:1D:10

答案:1有如下程序

#include

<stdio.h>

main(

)

{

int

i,

data;

scanf("%d",

&data);

for

(i=0;

i<5;

i++)

{

if

(i

<

data)

continue;

printf("%d-",

i);

}

}

程序运行时，从键盘输入：3<回车>后，程序输出结果为（

）

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

答案:3-4-若有以下程序

#include

<stdio.h>

main()

{

int

s=0,

n;

for

(n=0;

n<4;

n++)

{

switch(n)

{

default:

s+=4;

case

1:

s+=1;

break;

case

2:

s+=2;

break;

case

3:

s+=3;

}

}

printf("%d",

s);

}

则程序的输出结果是（

）

A:15B:11C:13D:10

答案:11

第七章单元测试

有以下程序

#include

<stdio.h>

main()

{

int

i,

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

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

printf("%d

",t[2-i][i]);

}

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

A:7

5

1B:3

5

7C:3

6

9D:7

5

3

答案:3

5

7以下错误的定义语句是（）。

A:int

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

x[4][]=

{{1,2,3},{1,2,3},{1,2,3},{1,2,3}};C:int

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

x[][3]={{0},{1},{1,2,3}};

答案:int

x[4][]=

{{1,2,3},{1,2,3},{1,2,3},{1,2,3}};以下叙述中正确的是（）。

A:两个字符串可以用关系运算符进行大小比较B:函数调用strlen(s);会返回字符串s实际占用内存的大小（以字节为单位)C:当拼接两个字符串时，结果字符串占用的内存空间是两个原串占用空间的和D:C语言本身没有提供对字符串进行整体操作的运算符

答案:C语言本身没有提供对字符串进行整体操作的运算符以下叙述中正确的是（）。

A:有定义语句：

char

str1[]

=

"str1";

，数组str1将包含4个元素B:下面的语句用赋初值方式来定义字符串，其中'

'是必须的char

str1[]

=

{'s',

't',

'r',

'1',

};C:字符数组的每个元素可存放一个字符，并且最后一个元素必须是字符D:字符串常量"str1"的类型是:字符串数据类型

答案:下面的语句用赋初值方式来定义字符串，其中'

'是必须的char

str1[]

=

{'s',

't',

'r',

'1',

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

A:语句

int

a[]

=

{0};是不合法的，遗漏了数组的大小B:语句

char

a[2]

=

{"A",

"B"};

是合法的，定义了一个包含两个字符的数组C:语句

char

a[3];

a

=

"AB";

是合法的，因为数组有三个字符空间的容量，可以保存两个字符D:语句int

a[8]

=

{0};

是合法的

答案:语句int

a[8]

=

{0};

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

A:语句

char

str[10]

=

"string!";

和

char

str[10]

=

{"string!"};

并不等价B:在语句char

str[]

=

"string!";中，数组str的大小等于字符串的长度C:对于字符串常量

"string!"，系统已自动在最后加入了'\0'字符，表示串结尾D:对于一维字符数组，不能使用字符串常量来赋初值

答案:对于字符串常量

"string!"，系统已自动在最后加入了'\0'字符，表示串结尾以下选项中，没有编译错误的是（）。

A:char

str4[];

str4

=

"hello

world";B:char

name[10];

name

=

"china";C:char

str3[]

=

{'d',

'e',

'b',

'u',

'g',

''};D:char

str1[5]

=

"pass",

str2[6];

str2

=

str1;

答案:char

str3[]

=

{'d',

'e',

'b',

'u',

'g',

''};有以下程序

#include

<stdio.h>

#include

<string.h>

main()

{

char

s[]="Beijing";

printf("%d",

strlen(strcpy(

s,"China")

));

}

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

A:7B:14C:12D:5

答案:5有以下程序

#include

<stdio.h>

main()

{

char

b[4][10];

int

i;

for

(i=0;

i<4;

i++)

scanf("%s",

b[i]);

printf("%s%s%s%s",

b[0],b[1],b[2],b[3]);

}

执行时若输入:

Fig

flower

is

red.

<回车>

则输出结果是（）。

A:Fig

flower

is

red.B:Figfloweris

red.C:Figflowerisred.D:Figflower

is

red.

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

A:在逻辑上，可以把二维数组看成是一个具有行和列的表格或矩阵B:语句

int

a[4][3]

=

{1,2,4,5};

是错误的初始化形式C:语句

int

a[4][3]

=

{{1,2},

{4,5}};

是错误的初始化形式D:语句

int

a[][3]

=

{1,2,4,5};

是错误的初始化形式

答案:在逻辑上，可以把二维数组看成是一个具有行和列的表格或矩阵

第八章单元测试

以下关于函数的叙述中正确的是（

）。

A:函数调用必须传递实参B:函数必须要有返回值

C:函数形参的类型与返回值的类型无关D:函数必须要有形参

答案:函数形参的类型与返回值的类型无关关于C语言函数声明的位置，以下叙述正确的是（

）。

A:在函数声明之后对该函数进行调用，编译时不会出现错误信息B:函数声明只是为了美观和编译时检查参数类型是否一致，可以写也可以不写C:函数声明可以出现在源程序的任意位置，在程序的所有位置对该函数的调用，编译时都不会出现错误信息D:函数声明只能出现在源程序的开头位置，否则编译时会出现错误信息

答案:在函数声明之后对该函数进行调用，编译时不会出现错误信息有以下程序

#include

<stdio.h>

int

fun(

int

a,

intB)

{

return

a+b;

}

main()

{

int

x=6,

y=7,

z=8,

r

;

r

=

fun

(

fun(x,y),

z--

);

printf

("

%d"

,

r

);

}

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

）。

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

答案:21有以下程序

#include

<stdio.h>

int

a=1,

b=2;

void

fun1(

int

a,

int

b

)

{

printf(

"%d

%d

"

,a,

b

);

}

void

fun2()

{

a=3;

b=4;

}

main()

{

fun1(5,6);

fun2(

);

printf(

"%d

%d",a,

b

);

}

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

）。

A:1

2

5

6

B:5

6

3

4

C:3

4

5

6

D:5

6

1

2

答案:5

6

3

4

以下叙述中错误的是（

）。

A:在函数内部定义的变量只能在本函数范围内使用B:在函数外部定义的变量在所有函数中都有效C:在不同的函数中可以使用相同名字的变量D:函数中的形参属于局部变量

答案:在函数外部定义的变量在所有函数中都有效有以下程序

#include

<stdio.h>

void

fun(

int

a,

int

b,

int

c

)

{

a=b;

b=c;

c=a;

}

main()

{

int

a=10

,

b=20,

c=30;

fun(

a,

b,

c

);

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

}

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

）。

A:10,20,30

B:20,30,10

C:0,0,0

D:30,20,10

答案:30,20,10

有如下程序

#include

<stdio.h>

int

sum(int

data)

{

static

int

init

=

0;

return

init

+=

data;

}

main()

{

int

i;

for

(i=1;

i<=5;

i++)

printf("%d,",

sum(i));

printf("");

}

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

A:0,0,0,0,0,B:1,1,1,1,1,C:1,2,3,4,5,D:1,3,6,10,15,

答案:1,3,6,10,15,若有以下程序

#include

<stdio.h>

void

f(int

x)

{

if

(x

>=

10)

{

printf("%d-",

x%10);

f(x/10);

}

else

printf("%d",

x);

}

main()

{

int

z

=

123456;

f(z);

}

则程序的输出结果是（

）。

A:6-5-4-3-2-1-

B:1-2-3-4-5-6

C:6-5-4-3-2-1

D:1-2-3-4-5-6-

答案:6-5-4-3-2-1

有如下程序

#include

<stdio.h>

int

sub(double

a,

double

b)

{

return

(int)(a

-

b);

}

main()

{

printf("%d",

sub(3.8,

2.1));

}

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

）。

A:2

B:1.7

C:1

D:2.0

答案:1

有以下程序

#include

<stdio.h>

#define

N

4

void

fun(int

a[][N])

{

int

b[N][N],i,j;

for(i=0;

i<N;

i++)

for(j=0;

j<N;

j++)

b[i][j]

=

a[N-1-j][i];

for(i=0;

i<N;

i++)

for(j=0;

j<N;

j++)

a[i][j]

=

b[i][j];

}

main()

{

int

x[N][N]={

{1,

2,

3,

4},{5,

6,

7,

8},

{9,10,11,12},{13,14,15,16}

},i;

fun(x);

fun(x);

for

(i=0;i<N;

i++)

printf("%d,",

x[i][i]);

printf("");

}

程序的运行结果是（

）。

A:4,7,10,13,

B:1,6,11,16,

C:16,11,6,1,

D:

13,10,7,4,

答案:16,11,6,1,

第九章单元测试

以下叙述中正确的是（）

A:#include命令行不能出现在程序文件的中间B:虽然包含文件被修改了，包含该文件的源程序也可以不重新进行编译和连接C:在一个程序中，允许使用任意数量的#include命令行D:在包含文件中，不得再包含其他文件

答案:在一个程序中，允许使用任意数量的#include命令行以下叙述正确的是（）。

A:一个#include行可以包含多个文件，且最后一个文件起作用B:一个#include行可以包含多个文件，文件名用逗号分开C:#include<stdio.h>是C程序的一条语句D:一个源文件中可以包含多个文件，每个文件的包含单独写一个#include行

答案:一个源文件中可以包含多个文件，每个文件的包含单独写一个#include行有以下程序

#include

<stdio.h>

#define

S(x)

x*x

main()

{

int

k=5,

j=2;

printf("%d,%d",

S(k+j+2),S(j+k+2));

}

程序的运行结果是（）

A:21,18

B:81,81C:21,21D:18,18

答案:21,18

有如下程序

#include

<stdio.h>

#define

D(x)

4*x+1

main()

{

int

i

=

2,

j

=

4;

printf("%d",

D(i+j));

}

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

A:25B:9C:12D:13

答案:13有以下宏定义及调用

#define

HA

2

#define

HB(a)

(HA+1)*a

...

x=HA*(HA+HB(2));

则以下判断正确的是（）。

A:宏定义不允许嵌套B:x的值是6

C:宏调用不允许嵌套D:x的值是16

答案:x的值是16

第十章单元测试

有如下程序段

int

*p,

a=1;

p=&a;

*p=10;

则变量a的值为________。

A:1B:11C:10D:不能确定

答案:10变量的指针，其含义是指该变量的_________

A:值

B:名

C:地址

D:一个标志

答案:地址

关于数组和指针，以下说法错误的是_______.

A:指针可以指向同类型的数组中的任意一个元素

B:既可以读入数据到数组中，也可以读入数据到未赋初值的指针中

C:可以让一个指针指向一个同类型的数组

D:数组名本身就是一个指针，指向数组内存的起始位置

答案:既可以读入数据到数组中，也可以读入数据到未赋初值的指针中

若有以下定义，则对a数组元素的正确引用是_________.

inta[5],*p=a;

A:*&a[5]

B:*(a+2)C:

a+2

D:*(p+5)

答案:*(a+2)有如下程序

#include

<stdio.h>

intmain()

{

int

i,

*ptr;

int

array[3]

=

{8,2,4};

for

(ptr=array,

i=0;

i<2;

i++)

printf("%d,",

*ptr++);

printf("");return0;

}

程序运行后的输出结果是_______.

A:8,8,

B:4,8,

C:8,2,

D:2,4,

答案:8,2,

指向一个包含４个整型元素的一维数组的行指针变量的定义形式为_______.

A:

int(*p)[]

B:int*(p[])

C:

int(*p)[4]D:int*p[4]

答案:

int(*p)[4]若有定义：inta[2][3];则对a数组的第i行第j列元素值的正确引用是______.

A:*(a+i+j)

B:*(a+i)+jC:*(*(a+i)+j)D:(a+i)[j]

答案:*(*(a+i)+j)下面程序段的运行结果是_______.chara[]="language",*p;p=a;

while(*p!='u'){printf("%c",*p-32);p++;}

A:language

B:LANG

C:LANGUAGE

D:langUAGE

答案:LANG

设有定义：char*cc[2]={"1234","5678"};则正确的叙述是_______.

A:cc数组的两个元素分别存放的是含有4个字符的一维字符数组的首地址

B:cc元素的值分别为"1234"和"5678"

C:cc数组的两个元素中各自存放了字符串"1234"和"5678"的首地址

D:cc是指针变量，它指向含有两个数组元素的字符型一维数组

答案:cc数组的两个元素中各自存放了字符串"1234"和"5678"的首地址

已有函数max(a,b)，为了让函数指针变量p指向函数max，正确的赋值方法是_______.

A:*p=max;

B:p=max(a,b);

C:p=max;

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

答案:p=max;

第十一章单元测试

有以下程序

#include

<stdio.h>

#include

<string.h>

struct

A

{

int

a;

char

b[10];

double

c;};

void

f(struct

A

t);

main()

{

struct

A

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

f(a);

printf("%d,%s,%6.1f",

a.a,a.b,a.c);

}

void

f(struct

A

t)

{

t.a=1002;

strcpy(t.b,"ChangRong");

t.c=1202.0;}

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

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

答案:1001,ZhangDa,1098.0设有定义：

struct

{char

mark[12];

int

num1;

double

num2;}

t1,t2;

若变量均已正确赋初值，则以下语句中错误的是（）

A:t2.mark=t1.mark;B:t1=t2;C:t2.num2=t1.num2;D:t2.num1=t1.num1;

答案:t2.mark=t1.mark;以下叙述中正确的是（）

A:即使是同类型的结构体变量，也不能进行整体赋值B:结构体数组名不能作为实参传给函数C:结构体变量的地址不能作为实参传给函数D:结构体中可以含有指向本结构体的指针成员

答案:结构体中可以含有指向本结构体的指针成员设有以下程序段

struct

person

{

float

weight;

char

sex;

char

name[10];

}

rec,

*ptr;

ptr

=

&rec;

从键盘读入字符串给结构体变量rec的name成员，错误的输入语句是（）

A:scanf("%s",

ptr->name);B:scanf("%s",

(*ptr).name);C:scanf("%s",

rec->name);D:scanf("%s",

);

答案:scanf("%s",

rec->name);以下叙述中错误的是（）

A:typedef的作用是用一个新的标识符来代表已存在的类型名B:typedef说明的新类型名必须使用大写字母，否则会出编译错误C:用typedef可以说明一种新的类型名D:可以用typedef说明的新类型名来定义变量

答案:typedef说明的新类型名必须使用大写字母，否则会出编译错误有如下程序

#include

<stdio.h>

struct

person

{

char

name[10];

int

age;

}

main()

{

struct

person

room[4]

=

{{"Zhang",

19},

{"Li",

20},

{"Wang",

17},

{"Zhao",

18}};

printf("%s:%d",

(room+2)->name,

room->age);

}

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

A:Wang:19B:Li:20C:Wang:17

D:Li:19

答案:Wang:19有以下程序

#include

<stdio.h>

typedef

struct

stu

{

char

name[10];

char

gender;

int

score;

}

STU;

void

f(STU

*a,

STU

*b)

{

*b

=

*a;

printf("%s,%c,%d,",

b->name,

b->gender,

b->score);

}

main()

{

STU

a={"Zhao",

'm',

290},

b={"Qian",

'f',

350};

f(&a,&b);

printf("%s,%c,%d",

,

b.gender,

b.score);

}

程序的运行结果是（）

A:Zhao,m,290,Zhao,m,290B:Qian,f,350,Zhao,m,290C:Qian,f,350,Qian,f,350D:Zhao,m,290,Qian,f,350

答案:Zhao,m,290,Zhao,m,290

第十二章单元测试

若有以下程序

#include

<stdio.h>

main()

{

int

c;

c=

10^5;

printf("%d",

c);

}

则程序的输出结果是（

）。

A:15

B:105

C:10000

D:5

答案:15

下面选项中关于位运算的叙述正确的是（

）。

A:位运算符都需要两个操作数B:右移运算时，高位总是补0C:左移运算的结果总是原操作数据2倍D:位运算的对象只能是整型或字符型数据

答案:位运算的对象只能是整型或字符型数据下面关于位运算符的叙述，正确的是（

）。

A:

||表示"按位或"的运算

B:~表示"按位异或"的运算

C:#表示"按位异或"的运算

D:&表示"按位与"的运算

答案:&表示"按位与"的运算

有以下程序

#include

<stdio.h>

main()

{

int

a=3

,b=3;

printf("%d

",a&b);

}

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

）。

A:6

B:3

C:0

D:1

答案:3

有以下程序

#include

<stdio.h>

main()

{

int

c,d;

c

=

10

|

5;

d

=

10

+

5;

printf("%d,%d",

c,

d);

}

程序的运行结果是（

）。

A:15,15B:10,15

C:105,15D:5,15

答案:15,15

第十三章单元测试

以下关于fclose(fp)函数的叙述正确的是（

）。

A:只有对文件进行输入操作之后，才需要调用fclose(fp)函数关闭文件B:只有对文件进行输出操作之后，才能调用fclose(fp)函数关闭文件C:当程序中对文件的所有写操作完成之后，不一定要调用fclose(fp)函数关闭文件D:当程序中对文件的所有写操作完成之后，必须调用fclose(fp)函数关闭文件

答案:当程序中对文件的所有写操作完成之后，必须调用fclose(fp)函数关闭文件以下叙述正确的是（

）。

A:在C语言中调用fopen函数就可把程序中要读、写的文件与磁盘上实际的数据文件联系起来B: