C语言编程新思路智慧树知到答案章节测试2023年山东理工大学

第一章测试

关于一个C语言程序执行的起点和终点，以下选项正确的是

()。

A:

main

main

B:

main

任意

C:

main

最后一个

D:

第一个

最后一个

答案:A

C语句的程序一行写不下时，可以

(

)。

A:

用逗号换行

B:

用回车换行

C:

用分号换行

D:

用任意空格换行

答案:B

以下叙述不正确的是

()。

A:

C程序中，可以不必包含主函数

B:

一个C程序，可以由多个函数组成

C:

C程序中，语句之间必须用分号分隔

D:

C程序中，多行语句可以写在一行上

答案:A

C语言规定，在一个源程序中，main函数的位置

()。

A:

必须在最开始

B:

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

C:

可以任意

D:

必须在最后

答案:C

以下叙述正确的是

(

)。

A:

在对C语言进行编译的过程中，不能发现注释中的错误

B:

在C程序中，注释说明只能位于一条语句的后面。

C:

C程序的每行中只能写一个语句

D:

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

答案:A

函数的主体部分需要用一对

(

)括起来。

A:

{}

B:

()

C:

[]

D:

<>

答案:A

以下叙述错误的是

(

)。

A:

C程序编译后生成.obj文件

B:

一个C程序只有在编译、连接成.exe程序之后才能执行

C:

只有一个分号的语句不是合法的C语句

D:

C程序的每一条语句都必须用分号结束

答案:C

计算机能够直接识别和执行的计算机语言

(

)。

A:

机器语言

B:

汇编语言

C:

C语言

D:

高级语言

答案:A

以下叙述错误的是

(

)。

A:

一个C程序编译成功后在连接时发现错误，需要编辑修改，然后不必重新编译和连接即可直接运行。

B:

机器语言和汇编语言都是低级语言

C:

C语言是一种函数型语言，每个C语言程序都是由若干个函数组成

D:

对于计算机而言，程序是指完成某一特定任务的一组指令序列

答案:A

对C程序的注释说明信息必须写在

()之间。

A:

’和’

B:

C:

/和/

D:

{和}

答案:C

用C语言编写的源程序，必须翻译成用二进制指令表示的目标程序，才能被计算机识别，这个过程称为

(

)。

A:

编辑

B:

编译

C:

解释

D:

汇编

答案:B

关于C语言的特点，以下叙述错误的是

()。

A:

C语言共有34种运算符，表达式类型多样化

B:

C语言不能直接对硬件进行操作

C:

C语言程序可以方便的在不同的计算机间和各种操作系统中实现程序的移植

D:

C语言一共只有32个关键字，9种控制语句，程序书写自由

答案:B

C语言程序的基本构成单位是

(

)。

A:

表达式

B:

函数

C:

运算符

D:

语句

答案:B

能够在编译过程中被检查出来，并给出提示信息的是

(

)。

A:逻辑错误

B:

注释错误

C:

语法错误

D:

运行错误

答案:C

以下叙述错误的是

(

)。

A:

C语言属于汇编语言

B:

高级语言比低级语言更贴近人类使用的语言，易于理解和使用

C:

计算机语言大致可以分为三大类：机器语言、汇编语言和高级语言

D:

C语言是一种通用的、过程式编程语言，具有高效、灵活、可移植等优点

答案:A

C语言源程序文件的后缀名是

(

)。

A:

.vbp

B:

.obj

C:

.exe

D:

.c

答案:D

C语言编译程序是

(

)。

A:

厂家提供的应用软件

B:

C程序的机器语言版本

C:

将C源程序编译成目标程序

D:

一组机器语言指令

答案:C

以下叙述错误的是

(

)。

A:

C语言的注释语句不影响编译结果

B:

C语言的注释有两种类型：单行注释和多行注释

C:

C语言程序中只要出现在“/”和“/”之间的就一定是注释内容

D:

C程序的单行注释语句以“//”开始

答案:C

C语言源程序文件经过编译后的目标文件后缀名是

(

)。

A:

.vbp

B:

.exe

C:

.c

D:

.obj

答案:D

C语言源程序编译、连接后的可执行文件后缀名是

(

)。

A:.obj

B:

.c

C:.exe

D:

.bak

答案:C第二章测试

下面4个选项中，均是不合法的用户标识符的选项的是（）。

A:

_abc

Temp

Int

B:

char

pao

_123

C:

Date

sum

do

D:

b+a

if

float

答案:D

下面4个选项中均是合法常量的选项是（）。

A:

058

12e−3

3.6

‘d’

B:

4.45

076

5.33E1.5

“how”

C:−12.8

0x98

43.56e2

’‘

D:

“w”

034

0xa3

’m’

答案:C

以下叙述不正确的是（）。

A:

在C语言中，可以使用二进制整数

B:

在C语言中，area和AREA是两个不同的变量名

C:

若a和b类型相同，在计算了赋值表达式a=b后，a得到b的值，而b的值不变

D:

在C语言中，％运算符的优先级高于/运算符

答案:A

在C语言中，要求运算对象必须是整型的运算符是

（）。

A:

%

B:

+

C:

/

D:

*

答案:A

若有说明语句：charch=‘\0x41’;则变量ch包含（）个字符。

A:

1

B:

说明不合法，ch的值不确定

C:

2

D:

3

答案:A

若有定义：inta=7;floatx=2.5,y=4.5;则表达式x+a%3*(x+y)/2的值是

（）。

A:

6.000000

B:

0.000000

C:

5.500000

D:

2.500000

答案:A

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

A:

不确定

B:

float

C:

int

D:

double

答案:D

以下叙述正确的是

（）。

A:

若a是实型变量，则在C语言中不允许用其他类型的数据对其赋值

B:

在C语言中，一行只能写一条语句

C:

在C语言中，无论是整数还是实数，都能被准确无误地表示

D:

在C语言中，%是只能用于整数运算的运算符

答案:D

在C语言中，int型数据在内存中的存储形式是（）。

A:

补码

B:

原码

C:

ASCII码

D:

反码

答案:A

下列选项中可作为C语言的合法整数的是

（）。

A:

0x4b5

B:

03845

C:

a2

D:

101011B

答案:A

字符型数据在内存中是以

（）形式存储的。

A:

ASCII码

B:

BCD码

C:补码

D:

原码

答案:A

下列叙述正确的是（）。

A:

C语言不允许混合类型数据间进行运算

B:

C语言中，任何类型的数据都可进行％运算

C:在C语言中，’b’和”b”的含义是不同的

D:

在C语言中，整型常量有二进制、八进制、十六进制和十进制4种表示形式

答案:C

#include<stdio.h>intmain(){

charch;

inti;

i=65;

ch=“a”;

printf(“%c,%c,%d,%d”,i,ch,i,ch);

return0;}这段程序的运行结果是（）。

A:

A,a,65,97

B:

a,A,97,65

C:

编译错误，无法运行

D:

a,A,65,97

答案:C

设整型变量a=2，则执行下列语句后，实型变量b的值不是0.5的是（）。

A:

b=1/(a*1.0)

B:

b=1.0/a

C:

b=1/(float)a

D:

b=(float)(1/a)

答案:D

下列叙述正确的是（）。

A:

字符串常量”China!“在存储时，系统为其分配6个字节的空间

B:

赋值表达式的左边只能是变量名

C:

C语言中，变量可以不经定义而直接使用

D:

不同类型的变量所占内存单元是相同的

答案:B

#include<stdio.h>intmain(){

inta=b=5,c;

c=a+b;

printf(“c=%d”,c);}这段程序的运行结果是（）。

A:

10

B:

0

C:

不确定

D:

编译错误，无法运行

答案:D

C语言的标识符只能由字母、数字和下划线三种字符组成，且第一个字符（）。

A:

必须为字母或者下划线

B:

必须是下划线

C:

可以是这三种字符中的任一种

D:

必须是字母

答案:A

如果在一个C语言表达式中有多个运算符，则运算时应该（）。

A:

只考虑结合性

B:

先考虑结合性，然后考虑优先级

C:

先考虑优先级，然后考虑结合性

D:

只考虑优先级

答案:C

已知字符A的ASCII值是65，若定义int

i;则执行语句i=’A’+3;后，正确的叙述是

（）。

A:

i的值是字符E

B:

语句不合法

C:

i的值是字符A的ASCII值加上3，即68

D:

语句可以执行，但没有计算结果

答案:C

在C语言中常量’’和常量”ABC”在内存中占用的字节数分别是（）。

A:

2

4

B:

1

3

C:

2

3

D:

1

4

答案:D第三章测试

若a、b、c、d都是int类型变量且初值为0，以下选项中不正确的赋值语句是

(

)。

A:

a*b；

B:

d=d-1；

C:

d=(c=30)+b；

D:

a=b=c=d=100；

答案:A

以下选项中不是C语句的是

(

)。

A:

{;}

B:

a=5,c=10

C:

{inti；printf(“%d”,i);}

D:

;

答案:B

以下程序的输出结果是

(

)。#include

“stdio.h”intmain(){

intx=100,y=30;printf(“%d”,y=x/y);return(0);}

A:

3

B:

不确定的值

C:

1

D:

0

答案:A

若变量已正确说明为int类型，要给a、b、c输入数据，以下正确的输入语句是

(

)。

A:

scanf(“%d%d%d”,&a,&b,&c);

B:

read(a,b,c);

C:

get(“%d%d%d”,a,b,c);

D:

scanf(“%d%d%d”,a,b,c);

答案:A

以下程序段的输出结果是（

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

inti;

floatx;

doubley;

y=x=i=10/4;

printf(“y=%.2f,x=%.2f,i=%d”,y,x,i);

return(0);}

A:

y=2.00,x=2.00,i=2

B:

y=2.50,x=2.50,i=2

C:

y=2.00,x=2.50,i=2

D:

y=2.50,x=2.00,i=2

答案:A

若变量已正确定义，要将a和b中的数进行交换，下面不正确的语句组是

(

)。

A:

a=a+b,b=a-b,a=a-b;

B:

t=b;b=a;a=t;

C:

t=a,a=b,b=t;

D:

a=t;t=b;b=a;

答案:D

以下程序的输出结果是

(

)。

#include<stdio.h>

intmain(void){

int

a=4,b=8;printf(“a=%%d,b=%%d”,a,b);

/*注意转义字符的作用*/return(0);}

A:

a=2,b=5

B:

a=%%d,b=%%d

C:

a=%2,b=%5

D:a=%d,b=%d

答案:D

已知字母A的ASCII值为十进制数65，下面程序的输出是

(

)。#include“stdio.h”intmain(void){

charch1,ch2;ch1=‘A’+‘5’−‘3’;ch2=‘A’+‘6’−‘3’;printf(“%d,%c”,ch1,ch2);return(0);

}

A:67,C

B:

B,C

C:

C,D

D:

67,D

答案:D

若从终端输入以下数据，要给变量c赋以340.25，则正确的输入语句是(

)。

A:

scanf(%4f”,&c);

B:

scanf(%.2f”,&c);

C:

scanf(%f”,&c)

D:

scanf(%6.2f”,&c);

答案:C

以下程序运行时输入:25，执行后输出的结果是

(

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

charch1,ch2;intn1;ch1=getchar();ch2=getchar();n1=ch2-ch1;printf(“%d”,n1);return(0);}

A:

3

B:

编译错误

C:

-3

D:

25

答案:A

有以下程序#include<stdio.h>intmain(void){

charc1,c2,c3,c4,c5,c6;

scanf(“%c%c%c%c”,&c1,&c2,&c3,&c4);

c5=getchar();

c6=getchar();

putchar(c1);

putchar(c2);

printf(“%c%c”,c5,c6);

return(0);}程序运行后，若从键盘输入(从第一列开始)abcdef则输出结果是(

)。

A:

abde

B:

abcd

C:

cdef

D:

abef

答案:A

以下程序段的输出结果是（

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

charc1=‘a’,c2=‘c’;printf(“%d,%c”,c2-c1,c2-c1+‘B’);return(0);}

A:

2,D

B:

类型不一致，出错

C:

2,b

D:

3,B

答案:A

若变量已正确定义为float类型，要通过语句scanf(“%f%f%f”,&a,&b,&c);给a赋值10.0，b赋值20.0，c赋值30.0，不正确的输入形式是(

)。

A:

10.0

20.030.0

B:

10

20

30

C:

10,20,30

D:

10，20

30

答案:C

以下程序的输出结果是（）。#include<stdio.h>intmain(void){

inta,b;

a=10;

b=20;

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

return(0);}

A:

10,20

B:

a=10,b=20

C:

10

20

D:

a=10b=20

答案:D

若变量已正确说明，要求用以下语句给a赋值2.0，给c1赋值字符#，给b赋值4.0，则不正确的输入形式是(

)。scanf(“%f%c%f”,&a,&c1,&b);

A:

2#

4

B:

2.0#4.0

，

C:

2.0#4.0

‘

D:

2.0

#

4.0

’

答案:D

以下说法错误的是

(

)。

A:

长整型（longint）变量，使用scanf函数输入时，需使用%ld格式符。

B:

若floatx=5;可以对变量x进行%操作，如x%2的值是1。

C:

复合语句是用一对花括号括起来的若干条语句，从语法作用上讲一条复合语句视为一条语句。

D:

赋值表达式的功能是将赋值运算符右侧的值赋给其左侧的变量。

答案:B结构化程序设计由三种基本结构组成，下面哪个选项不属于三种基本结构

(

)。

A:选择

B:顺序

C:回溯

D:循环

答案:C下面程序段功能是先输入一个整数，然后将输入的整数输出，请指出哪部分有错(

)。

#include

<stdio.h>

//1intmain(void){

inti;

//2

scanf(“%d”,i);//3

printf(“i=%d”,i);//4

return(0);}

A:

3

B:

2

C:

1

D:

4

答案:A

设inta=10,b;，执行下列语句后，b的值不是2的是(

)。

A:

b=a/4

B:

b=a%4

C:

b=a-8

D:

b=a/4.0

答案:D

putchar()函数可以向终端输出一个(

)。

A:

整型

B:

字符串

C:

字符

D:

实数

答案:C第四章测试

表示关系x≤y≤z的c语言表达式为(

)。

A:

(x<=y<=z)

B:

(x<=y)&&(y<=z)

C:

(x<=y)AND(y<=z)

D:

(x<=y)&(y<=z)

答案:B

若a=5；b=6；c=7；d=8；m=2；n=2；则执行(m=a>b)&&(n=c>d)后，m和n的值分别为()。

A:

2,2

B:

0,2

C:

0,0

D:

2.0

答案:B

在以下一组运算符中,优先级最高的运算符是(

)。

A:

&&

B:

=

C:

%

D:

<=

答案:C

若有intx,a,b;则下面if语句中，(

)是错误的。

A:

if(a<>b)

x=x+1;

B:

if(a=b)

x=x+1;

C:

if(a-b)

x=x+1;

D:

if(x)

x=x+1;

答案:A

下列表达式中，(

)不满足“当x的值为偶数时值为真，为奇数时值为假”的要求。

A:

x%2==0

B:

!(x%2)

C:

(x/2*2-x)==0

D:

!x%2!=0

答案:D

关于以下程序，正确的说法是(

)。#include<stdio.h>intmain(void){intx=0,y=0,z=0;

if(x=y+z)

printf(““);

else

printf(”###“);return(0);}

A:

可以编译，但不能通过连接，所以不能运行

B:

有语法错误，不能通过编译

C:

输出：

D:

输出：###

答案:D

下列程序的输出结果是(

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

floatx=4,y=1;

if(x<0)y=0;

elseif(x<10)y=1/x;

elsey=10;

printf(“%f”,y);

return(0);}

A:

10.000000

B:

0.250000

C:

1.000000

D:

0.000000

答案:B

执行以下程序时，若输入3和4，则输出结果是(

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

int

a,b,s;

scanf(“%d%d”,&a,&b);

s=a;

if(a<b)s=b;

s=s*s;

printf(“%d”,s);

return(0);}

A:

16

B:

20

C:

14

D:

18

答案:A

下列程序的输出结果是(

)。#include<stdio.h>intmain(void){intx=1,a=0,b=0;switch(x){case0:b=b+1;case1:a=a+1;case2:a=a+1;b=b+1;}printf(“a=%d,b=%d”,a,b);return(0);}

A:

a=1,b=0

B:

a=2,b=1

C:

a=2,b=2

D:

a=1,b=1

答案:B若有定义：inta=3,b=2,c=1;并有表达式：①a%b、②a>b>c、③b&&c+1、④c+=1，则表达式值相等的是(

)。

A:①和②

B:②和③

C:③和④

D:①和③

答案:D当a=1,b=3,c=5,d=4时，执行完下面一段程序后x的值是(

)。

if(a<b)

if(c<d)

x=1;

else

if(a<c)

if(b<d)

x=2;

else

x=3;

else

x=6;

else

x=7;

A:3

B:2

C:4

D:1

答案:B在下面的条件语句中（其中S1和S2表示C语言语句），只有一个在功能上与其他3个语句不等价(

)。

A:

if(a==0)

S1;

else

S2;

B:

if(a==0)

S2;

else

S1;

C:

if(a)

S1;else

S2;

D:

if(a!=0)S1;

else

S2;

答案:A若有inta=3,b;则执行下面程序段后b的值是(

)

if(a>0)

b=1;

else

b=-1;

b=b+1;

A:-1

B:1

C:2

D:0

答案:C假定所有变量均已正确定义，下面程序段执行后的x的值是(

)。

a=b=0;

x=35;

if(!a)x=x-1;

if(b)x=3;

elsex=4;

A:4

B:3

C:35

D:34

答案:A若有说明语句inti=4,j=5,k=6;floatf;则执行f=(i>k)?i:(j<k)?j:k;语句后，f的值为(

)。

A:4.0

B:6.0

C:5.0

D:7.0

答案:C下述程序的输出结果是(

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

inta=0,b=0,c=0;

if((a+1)>0||(b>0))

c=c+1;

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

return(0);

}

A:0,0,0

B:0,0,1

C:1,1,1

D:1,0,1

答案:B若x=0，则执行下面程序段后，屏幕上会显示(

)。

if(x=0)printf(““);

else

printf(”&&&“);

A:&&&

B:***

C:&&&***

D:*&&&

答案:A**若有inta=10,b=20,c=30;，执行下面程序段后a、b、c的值分别是()。

if(a>b)

c=a;

a=b;

b=c;

A:10、20、30

B:20、10、10

C:20、10、30

D:20、30、30

答案:D下列程序的输出结果是(

)。

#include<stdio.h>

intmain(void)

{intk=8;

switch(k)

{

case7:k+=1;

case8:k+=1;

case9:k+=1;break;

default:k+=1;

}

printf(“%d”,k);

return(0);

}

A:11

B:9

C:10

D:8

答案:C若有float

x;

int

a,b;，下面四条switch语句中正确的有(

)条。switch(x){

case

x=1.0:printf(“Y”);

case

x=2.0:printf(“N”);

}switch(a)

{

case

a=1:printf(“Y”);

case

a=2:printf(“N”);

}switch(b)

{

case

b==1:printf(“Y”);

case

b==2:printf(“N”);

}switch(x){

case

1.0:printf(“Y”);

case

2.0:printf(“N”);

}

A:4

B:1

C:3

D:2

答案:B第五章测试

以下程序段中while循环执行的次数是(

)。

intk=0;

while(k=1)k++;

A:

一次也不执行

B:

执行一次

C:

无限次

D:

有语法错不能执行

答案:C以下描述中正确的是(

)。

A:do-while循环中，根据情况可以省略while

B:do-while循环中由do开始，用while结束，在while(表达式)后面不能写分号

C:在do-while循环中，循环体至少执行一次

D:由于do-while循环中循环体语句只能是一条可执行语句，所以循环体内不能使用复合语句

答案:C在C语言中有关for循环，以下正确的说法是(

)。

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

B:在for循环不能break跳出循环体

C:for循环是先执行循环体语句，后判断表达式

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

答案:A以下下面程序的运行结果是(

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

inta=1,b=2,c=2,t;while(a<b<c){t=a;a=b;b=t;

c–;}printf(“%d,%d,%d”,a,b,c);}

A:2,1,1

B:2,1,0

C:1,2,0

D:1,2,1

答案:C若i,j已定义为int类型,则以下程序段中内循环体的总的执行次数是(

)。for(i=5;i;i–)for(j=0;j<4;j++){…}

A:20

B:24

C:30

D:25

答案:A下面程序的输出结果是(

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

int

i,j;

for(i=0,j=10;i<j;i+=2,j–)

;printf(“%d%d”,i,j);}

A:8

6

B:4

8

C:6

7

D:10

5

答案:A下面关于switch语句和break语句的结论中，说法正确的是(

)。

A:在switch语句中，可以根据需要使用或者不使用break语句

B:break语句是for语句的一部分

C:break语句是switch语句的一部分

D:在switch语句中，必须使用break语句

答案:A以下不是死循环的语句是(

)。

A:for(;(c=getchar())!=’’;)printf(“%c”,c);

B:for（；；x+=i）

C:while(1){x++;}

D:for(i=10;;i–)sum+=i;

答案:A与语句头while(!x)等价的语句头是(

)。

A:while(x!=1)

B:while（x==0）

C:while(~x)

D:while(x!=0)

答案:B在while(x)语句中的x与下列条件表达式等价的是(

)。

A:x!=0

B:x=1

C:x==0

D:x!=1

答案:A下面程序的功能是：在输入的一批正数中求最大者，输入0结束循环，选择(

)填空。#include<stdio.h>intmain(){

inta,max=0;

scanf(“%d”,&a);

while(

)

{

if(max<a)max=a;

scanf(“%d”,&a);

}

printf(“%d”,max);}

A:a

B:!a

C:!a==1

D:a==0

答案:A

下面程序的功能是从键盘输入一行字符，从中统计大写字母和小写字母的个数，选择(

)填空。#include<stdio.h>intmain(){

intm=0,n=0;

charc;

while((

)!=‘’)

{

if(c>=‘A’&&c<=‘Z’)m++;

if(c>=‘a’&&c<=‘z’)n++;

}

printf(“m=%d,n=%d”,m,n);}

A:c=getchar()

B:c==getchar()

C:scanf(“%c”,&c)

D:getchar()

答案:A下面程序的输出结果是(

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

intk=0,m=0,i,j;

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

{

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

k++;

k-=j;

}

m=i+j;

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

A:k=1,m=5

B:k=0,m=5

C:k=0,m=3

D:k=1,m=3

答案:B下面程序的输出结果是(

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

charc=‘A’;

intk=0;

do

{switch(c++)

{case‘A’:k++;break;

case‘B’:k–;

case‘C’:k+=2;break;

case‘D’:k%=2;continue;

case‘E’:k*=10;break;

default:k/=3;

}

k++;

}while(c<‘G’);

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

A:k=0

B:k=4

C:k=2

D:k=3

答案:B下面程序的运行结果是(

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

inti;

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

if(i%2)printf(“”);

else

continue;printf(“#”);}

printf(“$\n”);}A:***$

B:##$

C:##$

D:##*#$

答案:D下面程序段的运行结果是(

)。intx=3;do{printf(”%d“,x-=2);}while(!(–x));

A:输出的是1

B:输出的是1和-2

C:输出的是3和0

D:是死循环

答案:B下面程序段的运行结果是(

)。x=y=0;while(x<15)y++,x+=++y;printf(“%d,%d”,y,x);

A:20,7

B:6,12

C:8,20

D:20,8

答案:D下面程序的功能是将从键盘输入的一对数,由小到大排序输出。当输入一对相等数时结束循环,请选择(

)填空:#indude<Stdio.h>intmain(){inta,b,t;scanf(“%d%d”,&a,&b);while(【1】){if(a>b){t=a;a=b;b=t;}printf(“%d,%d”,a,b);scahf(“%d%d”,&a,&b);人}

A:a=b

B:a==b

C:a!=b

D:!a=b

答案:C对for(表达式1;;表达式3)可理解为(

)。

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

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

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

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

答案:D若i为整型变量,则以下循环执行次数是(

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

A:1次

B:无限次

C:2次

D:0次

答案:D第六章测试

在C语言中，引用数组元素时，其数组下标的数据类型允许是（

）。

A:

任何类型的表达式

B:

整型常量或整型表达式

C:

整型表达式

D:

整型常量

答案:B

以下程序的输出结果是（

）。intmain(){inta[5]={1,2,3};printf(“%d”,a[3]);}

A:

随机值

B:

0

C:

1

D:

3

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

）。int

main(

){

int

i,

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

for

(i=0,k=0;

i<10;

i++)

if(a[k]<a[i])

k=i;

printf(“%d”,k);}

A:7

B:6

C:8

D:5

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

）。int

main(

){int

i,j,s=0,a[2][3]={1,2,3,4,5,6};for

(i=0;

i<2;

i++)

for

(j=0;

j<3;

j++)

s=s+a[i][j];printf(“%d”,s);}

A:20

B:10

C:21

D:15

答案:C有以下程序运行后的输出结果是（

）。int

main(

){int

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

int

i,s=0；for(i=0;i<4;i++)s+=aa[i][1];printf(“%d

”,s);}

A:19

B:20

C:13

D:11

答案:A数组定义为inta[3][2]={1,3,4,6,8,10}，数组元素(

)的值为6。

A:a[2][1]

B:

a[2][2]

C:a[3][2]

D:a[1][1]

答案:D定义inta[10][11]，则数组a有(

)个元素。

A:110

B:11

C:132

D:90

答案:A以下不能对二维数组a进行正确初始化的语句是(

)。

A:inta[2][3]={0};

B:inta[2][3]={{1,2},{3,4},{5,6}};

C:inta[][3]={1,2,3,4,5,6};

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

答案:B若有定义语句：inta[3][5];，按在内存中的存放顺序，a数组的第8个元素是(

)。

A:a[0][4]

B:a[1][2]

C:a[1][4]

D:a[0][3]

答案:B若有定义

int

a[10];则对a数组元素的正确应用是

(

)。

A:a[10.0]

B:a(10)

C:a[10]

D:a[1+2]

答案:D以下能对一维数组a进行正确初始化的语句是（）。

A:inta[10]=(0,0,0,0,0)

B:

inta[10]=10*1;

C:inta[]={0};

D:inta[10]={}

答案:C以下对二维数组a的正确说明是（）。

A:floatfa(3,4);

B:floata(3)(4);

C:doublea[1][4];

D:inta[3][];

答案:C若有说明:inta[3][4]={0};则下面正确的叙述是(

)。

A:数组a中各元素都可得到初值，但其值不一定为0。

B:此说明语句不正确。

C:数组a中每个元素均可得到初值0

D:只有元素a[0][0]可得到初值0

答案:C若有定义:ints[3][4]={{1,2},{0},{3,4,5}};则s[2][1]的值为(

)。

A:0

B:3

C:4

D:1

答案:C若有定义inta[2][3];则合法引用数组元素的是(

)。

A:a[0][1/2]

B:a[2][3]

C:a[1][3]

D:a[1][2]

答案:D在以下数组定义中，错误的是(

)。

A:inta[2][2]={{1,2},{3}}

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

C:inta[][2]={{0},{1}};

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

答案:B以下程序段执行后p的值是(

)。int

a[3][3]={3,2,1,3,2,1,3,2,1};

int

j,k,p=1;for(j=0;j<2;j++)for(k=j;k<3;k++)p*=a[j][k];

A:12

B:2

C:18

D:108

答案:A以下程序段执行后p的值是(

)。

int

a[3][3]={3,2,1,3,2,1,3,2,1};

int

j,k,p=1;for(j=0;j<2;j++)for(k=j;k<4;k++)p*=a[j][k];

A:2

B:12

C:18

D:108

答案:D以下程序段运行后s的值是(

)。

int

a[3][3]={1,2,3,4,5,1,2,3,4};int

i,j,s=1;for(i=0;i<3;i++)for(j=i+1;j<3;j++)s+=a[i][j];

A:6

B:7

C:240

D:120

答案:B下面程序段的运行结果是(

)。

int

m[]={5,8,7,6,9,2},i=1;for(i=0;i<6;i++)

{if(i

%

2

!=0)

m[i]+=10;

}for(i=0;i<6;i++)

printf(“%d

”,m[i]);

A:158176192

B:151817161912

C:518716912

D:587692

答案:C第七章测试

变量的指针，其含义是指变量的（

）。

A:

名称

B:

另一个名称

C:

地址

D:

值

答案:C

以下叙述错误的是（

）。

A:

多个同类型的指针变量可以指向同一个普通变量。

B:指针变量不占用存储空间

C:

指针变量中存放的是地址值

D:

指针变量可以与整数进行加、减算术运算

答案:B已知指针变量P的指向如图1所示，则表达式*P++的值是（

）。

A:20

B:30

C:21

D:31

答案:A已知指针变量P的指向如图1所示,则表达式*++P的值是（

）。

A:31

B:20

C:21

D:30

答案:D已知指针变量P的指向如图1所示,则表达式++(*P)的值（

）。

A:30

B:20

C:31

D:21

答案:D假设整型变量a的值为12，变量a的地址为2000，若欲使p为指向a的指针变量，则以下赋值正确的是（

）。

A:p=12;

B:p=&a;

C:p=2000

D:&a=p;

答案:B若有定义:intb,pb;则下面正确的赋值表达式是（

）。

A:pb=&b

B:pb=b

C:pb=&b

D:pb=b

答案:A设inta[10],p=a;，则下面（

）不是对a[3]的正确引用。

A:(p+3)

B:p+3

C:p[3]

D:*(a+3)

答案:B若有如下定义：inta[10]={10,20,30,40,50,60,70,80,90,100},p=a;，则执行p=p+5后，p的值是（

）。

A:100

B:10

C:50

D:60

答案:D若intp,i;执行i=100;p=&i;i=p+10;后，*p的值是（

）。

A:10

B:0

C:110

D:100

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

）。#include<stdio.h>intmain(){

inta[]={2,4,6,8,10},y=0,i,p;

p=a;

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

y+=(p+i);

printf(“%d”,y);}

A:17

B:19

C:20

D:12

答案:D

以下程序的输出结果是（

）。#include<stdio.h>intmain()

{inta=1,b=2,c=3,p1,p2,p3;

p1=&a;p2=&b;

p3=&c;

p3=p1;

p1=p2;

p2=*p3;

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

}

A:a=2,b=1,c=1

B:a=3,b=2,c=1

C:a=1,b=2,c=3

D:a=2,b=1,c=3

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

（

）。#include<stdio.h>intmain(){intk=2,m=4,n=6;intpk=&k,pm=&m,p;(p=&n)=pk(*pm);printf(“%d”,n);return0;}

A:10

B:4

C:8

D:6

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

）。#include<stdio.h>intmain(){int**k,*a,b=100;a=&b;k=&a;printf(“%d”,k);return0;}

A:a的地址

B:100

C:b的地址

D:编译出错

答案:B**对于基类型相同的两个指针变量之间，不能进行的运算时（

）。

A:<

B:=

C:–

D:+

答案:D若有inta[3][4]={1,2,3,4,5,6,7,8,9,10,11,12};

int(p)[3]=a;，则能正确表示数组元素a[1][2]的是（

）。

A:(p+1)[2]

B:p[1]+2

C:(p+1)+2

D:((p+1)+2)

答案:D对于语句int*p[5];的正确描述是（

）。

A:p是一个具有5个元素的指针数组，每个元素都是一个指向int型对象的指针变量。

B:p是一个指向数组中第5个元素的指针，该元素是int型。

C:定义不合法

D:p是一个指向数组的指针，所指向的数组含有5个int型元素。

答案:A若有inta[10],p=a;，下列不能表示a数组首元素地址的是（

）。

A:&a[0]

B:a

C:p

D:p

答案:D下列程序的运行结果是（

）。#include<stdio.h>intmain(){inta[5]={1,2,3,4,5},*p,**pp;

p=a;

pp=&p;

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

printf(“%d”,pp);

return0;}

A:4

4

B:3

4

C:4

1

D:3

1

答案:C**若有inta[10],*p;，则下列语句中正确的是（

）。

A:for(p=a;p<a+10;p++)

B:for(p=a;p<p+10;p++)

C:for(p=a;a<p+10;a++)

D:for(p=a;p<a+10;a++)

答案:A第八章测试函数strcmp(“ABCDDCBA”,“ABCDE”)的返回值是（

）。

A:随机值

B:正数

C:0

D:负数

答案:D以下程序运行后的输出结果是（

）。intmain(){inti,j;chara[]={‘a’,‘b’,‘c’,‘d’,‘e’,‘f’,‘g’,‘h’,‘\0’};i=sizeof(a);//sizeof返回数组a在内存分配字节数j=strlen(a);printf(“%d,%d”,i,j);}

A:8，9

B:1，8

C:9，8

D:9，9

答案:C下列选项中，不正确的赋值方式是(

)。

A:charstr1[]＝“string”,str2[]＝“12345678”;

B:charstr[]＝{‘s’,‘t’,‘r’,‘i’,‘n’,‘g’,‘’};

C:charstr[7]＝{‘s’,‘t’,‘r’,‘i’,‘n’,‘g’};

D:charstr1[10];str1＝“string”;

答案:D若有以下的说明和语句,则它与(

)中的说明是等价的。chars[3][5]＝{“aaaa”,“bbbb”,“cccc”};

A:chars4[][4]＝{“aaaa”,“bbbb”,“cccc”};

B:chars1[][]＝{“aaaa”,“bbbb”,“cccc”};

C:chars2[3][]＝{“aaaa”,“bbbb”,“cccc”};

D:chars3[][5]＝{“aaaa”,“bbbb”,“cccc”};

答案:D有以下程序：#include“stdio.h”#include“string.h”intmain()

{

inti,j;

chart[10],p[5][10]={“abc”,“aabdfg”,“abbd”,“dcdbe”,“cd”};

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

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

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

{

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

strcpy(p[j],t);

}

printf(“%d”,strlen(p[0]));}程序运行后的输出结果是(

)。

A:5

B:4

C:6

D:3

答案:C

下列选项正确的语句组是（

）。

A:chars;s={“China”};

B:chars[8];s=“China”;

C:chars;s=“China”;

D:chars[8];s={“China”};

答案:C下面程序的运行结果是（

）。charc[6]={‘a’,‘b’,‘\0’,‘c’,‘d’,‘\0’};printf(“%s”,c);

A:abc

B:ab

C:abcd

D:‘a’‘b’

答案:B有两个字符数组a、b，则以下正确的输入语句是（

）。

A:gets(“a”);gets(“b”);

B:scanf(“%s%s”,&a,&b);

C:gets(a,b);

D:scanf(“%s%s”,a,b);

答案:D下面程序段的运行结果是（

）。chara[7]=“abcdef”;charb[4]=“ABC”;strcpy(a,b);printf(“%c”,a[5]);

A:空格

B:f

C:

c

D:e

答案:B下面程序段的输出结果是（

）。#include

<stdio.h>int

main(){

char

str[]=“I

like

swimming!

”,*p=str;

p=p+7;

printf(“%s”,p);}

A:Ilikeswimming!

B:程序有错误

C:likeswimming!

D:swimming!

答案:D下面哪个选项不能将”hello”字符串存入字符数组str中（

）。

A:charstr[]=“hello”

;

B:charstr[30];strcpy(str,“hello”);

C:charstr[30],*ps=str;strcpy(ps,“hello”);

D:charstr[30]；str=“hello”;

答案:D有以下定义，不能表示字符

‘C’

的表达式是（

）。char

str[]=“ABCDEFG”,p=str;

A:(p+2)

B:str[2]

C:(str+2)

D:p+2

答案:D程序段char

c[]=“abcdefg

”;

printf(“%s”,c+4);的运行结果是（

）。

A:abcdefg

B:defg

C:efg

D:abcd

答案:C有如下定义，不能给数组a输入字符串的是（

）。char

a[20],*p=a;

A:gets(a[0])

B:gets(p)

C:gets(a)

D:gets(&a[0])

答案:A下面说法正确的是（

）。

A:函数strcpy(str1,str2);的功能是将str2中字符串复制到str1中。

B:定义char

a[30],b[]=“China”;后，可执行a=b;将数组b中的字符串赋值给数组a。

C:若定义chars[]=“well”;chart[]={‘w’,‘e’,‘l’,‘l’};，则数组s与数组t中内容相同。

D:当两个字符串所包含的字符个数相同时，才能比较两个字符串的大小。

答案:A接受用户输入含有空格的字符串时，应使用（

）。

A:getchar()

B:gets()

C:printf()

D:scanf()

答案:B列描述中错误的是

（

）。

A:不能对字符数组存储的字符串进行更改。

B:可以对字符数组进行整体输入、输出。

C:字符串可以存储在字符数组中。

D:不能使用赋值运算符“=”，直接对字符数组名进行赋值。

答案:A执行以下程序段后，输出结果是（

）。

char

str[20]=“door”,t;

int

i,j;

i=0;

j=strlen(str)-1;

t=str[i];

str[i]=str[j];

str[j]=t;

puts(str);

A:dood

B:

roor

C:

rood

D:

door

答案:C若有如下定义chara[30],b[30]，则以下正确的输入语句是（

）

A:gets(a,b);

B:scanf(“%s%s”&a,&b);

C:scanf(“%s”,a,b);

D:gets(a);gets(b);

答案:D执行以下程序段后，输出结果是（

）。chars[20]=“Good”,t[]=“Moring!”;strcat(s,t);puts(s);

A:Moring!Good

B:Moring!

C:Good

D:GoodMoring!

答案:D第九章测试在c语言中以下不正确的说法是(

)。

A:形参应与其对应的实参类型一致

B:实参可以为任意类型

C:实参可以是常量、变量、或表达式 

D:形参可以是常量、变量或表达式

答案:D以下程序有语法性错误，有关错误原因的正确说法是(

)。 #include<stdio.h>int main(void)    {  int G=5,k; void  prt_char(); 

……   k=prt_char(G);   ……return0;} 

A:变量名不能使用大写字母

B:语句void prt_char();有错，它是函数调用语句不能用void说明

C:函数名不能使用下划线

D:函数说明和函数调用语句之间有矛盾

答案:D下述函数定义形式正确的是(

)。

A:int

f(intx,inty)

B:int

f(intx;inty)

C:int

f(x,y:int)

D:int

f(intx,y)

答案:A以下所列的各函数首部中，正确的是(

)。

A:void play(int a,b)

B:void play(var :Integer,var b:Integer)

C:Sub play(a as integer,b as integer)

D:void play(int a,int b)

答案:D若已定义的函数有返回值，则以下关于该函数调用的叙述中错误的是(

)。

A:函数调用可以作为一个函数的形参

B:函数调用可以出现在表达式中

C:函数调用可以作为一个函数的实参

D:函数调用可以作为独立的语句存在

答案:A在调用函数时，如果实参是简单变量，它与对应形参之间的数据传递方式是(

)。

A:单向值传递

B:传递方式由用户指定

C:地址传递

D:由实参传给形参，再由形参传回实参

答案:A有以下程序：#include<stdio.h>voidfun(inta,intb,intc){a=11;b=22;c=33;}intmain(void){

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

fun(x,y,z);printf(“%d,%d,%d”,x,y,z);

return0;}该程序输出结果是(

)。

A:11，22，33

B:33，22，11

C:10，20，30

D:30，20，10

答案:C关于函数参数，说法正确的是(

)。

A:实参与其对应的形参共同占用一个内存单元

B:只有当实参和形参同名时才占用同一个内存单元

C:实参与其对应的形参各自占用独立的内存单元

D:形参是虚拟的，不占用内存单元

答案:C一个函数的返回值由(

)确定。

A:被调用函数的类型

B:return语句中的表达式

C:调用函数的类型

D:系统默认的类型

答案:A下列程序的输出结果是(

)。fun(inta,intb,intc){c=a+b;}intmain(void){

intc;

fun(2,3,c);

printf(“%d”,c);

return0;}

A:2

B:3

C:5

D:不定

答案:D有以下程序：#include<stdio.h>intfun(intx){

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

fun(12+5);

return0;}程序的输出结果是(

)。

A:x=13

B:x=18

C:x=17

D:x=12

答案:B有如下程序：#include<stdio.h>inti=1;intmain(){

inti=i;printf(“%d”,i);return0;}程序的输出结果是(

)。

A:0

B:不确定

C:i

D:1

答案:B有如下程序：#include<stdio.h>intf(intx){returnx+3;}intmain(void){

inta=1;

while(f(a)<10)a++;

return0;}程序执行后，变量a的值是(

)。

A:10

B:9

C:7

D:11

答案:C以下说法中正确的是(

)。

A:形参是全局变量，其作用范围仅限于函数内部

B:形参是局部变量，其作用范围仅限于函数内部

C:形参是全局变量，其作用范围从定义之处到文件结束

D:形参是局部变量，其作用范围从定义之处到文件结束

答案:B定义为void类型的函数，其含义是(

)。

A:调用函数后，被调用的函数没有返回值

B:其余选项都不对

C:调用函数后，被调用的函数不返回

D:调用函数后，被调用的函数的返回值为任意类型

答案:A当全局变量和函数内部的局部变量同名时，在函数内部(

)。

A:全局变量和局部变量都无效

B:全局变量和局部变量都有效

C:局部变量有效

D:全局变量有效

答案:C有如下程序：#include<stdio.h>fun(inta){autointb=0;

staticintc=3;

b=b+1;c=c+1;

return(a+b+c);}intmain(void){

inta=2,i;

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

printf(“%d“,fun(a));

return0;}它的输出结果是(

)。

A:7

8

9

B:9

9

9

C:8

9

10

D:7

7

7

答案:A有如下程序：#include<stdio.h>voidfun(intx,inty){intt;

if(x>y){t=x;x=y;y=t;}}intmain(void){inta=4,b=7,c=5;

fun(a,b);fun(a,c);fun(b,c);

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

return0;}它的输出结果是(

)。

A:4,5,7

B:7,4,5

C:7,5,4

D:4,7,5

答案:D有如下程序：#include<stdio.h>f(inta){intb=0;

staticintc=3;

a=c++;b++;

return(a);}intmain(void){inta=2,i,k;

for(i=0;i<2;i++)k=f(a++);

printf(“%d”,k);

return0;}该程序的输出结果是(

)。

A:5

B:6

C:4

D:3

答案:C凡是未指明存储类别的局部变量，其隐含的存储类别是(

)。

A:

register

B:

auto

C:

static

D:

extern

答案:B第十章测试若有数组名作为函数调用的实参，传递给形参的是（

）。

A:数组中全部元素的值

B:数组的首地址

C:数组元素的个数

D:数组第一个元素的值

答案:B若使用一维数组名作为函数实参，则以下描述中正确的是（

）。

A:实参数组名与形参数组名必须一致

B:实参数组类型与形参数组类型可以不匹配

C:必须在调用函数中说明此数组的大小

D:在被调用函数中，不需要考虑形参数组的大小

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

）

A:C语言中各函数（除主函数外）之间既不允许直接递归调用也不允许间接递归调用

B:C语言中各函数（除主函数外）之间既允许直接递归调用也允许间接递归调用

C:C语言中各函数（除主函数外）之间允许直接递归调用不允许间接递归调用

D:C语言中各函数（除主函数外）之间不允许直接递归调用允许间接递归调用

答案:B下列程序的输出结果是（

）。#include<stdio.h>voidsub(intx,inty,intz){z=y-x;}intmain(){

inta,b,c;sub(10,5,&a);sub(7,a,&b);sub(a,b,&c);printf(“%d,%d,%d”,a,b,c);return0;}

A:-5,-12,-7

B:5,2,3

C:5,-2,-7

D:-5,-12,7

答案:A下列程序的输出结果是（

）。#include<stdio.h>voidprtv(intx){printf(“%d”,++x);}intmain(){

inta=25;prtv(&a);return0;}

A:23

B:26

C:25

D:24

答案:B下列程序的输出结果是（

）。

#include

<stdio.h>void

fun(int

a,int

b){int

w;

a=a+a;

w=a;

a=b;

b=w;}int

main(){

int

x=2,

y=3,px=&x,*py=&y;;fun(px,py);printf(“%d,%d”,x,y);return

0;}

A:3,2

B:4,3

C:3,4

D:2,3

答案:C以下程序运行时，若输入5103，则输出结果是（

）。#include<stdio.h>voidswap(intp1,intp2){intt;

t=p1;

p1=p2;

p2=t;

return;}intmain(){inta,b,c;

scanf(“%d%d%d”,&a,&b,&c);

if(a>b)swap(&a,&b);

if(a>c)swap(&a,&c);

if(b>c)swap(&b,&c);

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

return0;}

A:5,10,3

B:10,5,3

C:3,5,10

D:3,10,5

答案:C以下程序运行时，若输入5，则输出结果是（

）。#include<stdio.h>intfac(intn){staticintk=1;

k=k*n;

returnk;}intmain(){intm,i,f;

scanf(“%d”,&m);

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

{f=fac(i);

printf(“%d”,f);

}}

A:120

B:5

C:12624120

D:12345

答案:C下列程序的输出结果是（

）。#include<stdio.h>intfun(inta){intb;

if(a==0||a==1)

return3;

b=a*a-fun(a-2);

returnb;}intmain(){intx,y;

x=fun(3);

y=fun(4);

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

return0;}

A:3,4

B:9,16

C:6,16

D:6,15

答案:D下列程序的输出结果是（

）。#include<stdio.h>intfun(int(*p)[3]){inti,j,n;

n=p[0][0];

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

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

if(p[i][j]>n)

n=p[i][j];

returnn;}intmain(){inta[2][3]={11,32,13,44,5,6},m;

m=fun(a);

printf(“%d”,m);

return0;}

A:32

B:44

C:11

D:6

答案:B下列程序的运行结果是（

）。#include<stdio.h>voidfun(intx,inty,intcp,intdp){cp=x+y;dp=x-y;}intmain(){inta,b,c,d;a=4;b=3;fun(a,b,&c,&d);printf(“%d,%d”,c,d);return0;}

A:4,3

B:1,7

C:7,1

D:3,4

答案:C下列程序的运行结果是（

）。#include<stdio.h>voidop(int(*p)[3]){inti,j;

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

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

if(p[i][j]%3==0)

printf(“%d”,p[i][j]);}intmain(){ints[3][3]={1,2,3,4,5,6,7,8,9};

op(s);

return0;}

A:369

B:123

C:147

D:789

答案:A以下程序运行时，若输入5，则程序的输出结果是（

）。#include<stdio.h>intfun(intn){if(n==1)

return1;

else

returnn+fun(n-1);}intmain(){intm;

scanf(“%d”,&m);

m=fun(m);

printf(“%d”,m);}

A:5

B:6

C:9

D:15

答案:D以下程序运行时，若输入ab012kd99pk8,则程序的输出结果是（

）。#include<stdio.h>voidfun(chars[]){inti,j;

for(i=0,j=0;s[i]!=‘\0’;i++)

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

s[j++]=s[i];

s[j]=‘\0’;}intmain(){charstr[80];

gets(str);

fun(str);

puts(str);

return0;}

A:012998

B:012

C:99

D:8

答案:A若有以下程序：#include<stdio.h>voidf(intq,intn){inti;

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

(q)++;

return;}intmain(void){inta[5]={1,2,3,4,5},i;

f(a,5);

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

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

return0;}则程序的输出结果是（

）。

A:2,3,4,5,6,

B:2,2,3,4,5,

C:6,2,3,4,5,

D:1,2,3,4,5,

答案:C形参数组与实参数组，在内存空间中是（

）的。

A:相互独立

B:部分重叠

C:随机存储

D:完全重叠

答案:D若有以下程序：#include<stdio.h>intfun(ints,intt){if(s<t)

s=t;

returns;}intmain(void){inta=3,b=6,p=&a,q=&b,r;

r=fun(p,q);

printf(“%d,%d,%d”,p,q,*r);

return0;}则程序的输出结果是（

）。

A:6,3,3

B:3,6,6

C:3,3,6

D:6,6,3

答案:B若有以下程序：#include<stdio.h>intfun(intx){

if(x>10)

{printf(“%d-”,x%10);

fun(x/10);

}

else

printf(“%d”,x);

return;}intmain(void){

intz=123456;

fun(z);

return0;}则程序的输出结果是（

）。

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

答案:A第十一章测试以下叙述不正确的是(

)。

A:在程序中凡是以#号开始的语句都是预处理命令行

B:C程序在执行过程中对预处理命令行进行处理

C:预处理命令行必须以#号开始

D:以下宏定义是正确的：#defineIBM_PC

答案:B在宏定义#define