C语言程序设计（青岛职业技术学院）知到智慧树章节测试课后答案2024年秋青岛职业技术学院

C语言程序设计（青岛职业技术学院）知到智慧树章节测试课后答案2024年秋青岛职业技术学院项目一单元测试

C语言是一种(

)

A:机器语言B:高级语言C:低级语言D:汇编语言

答案:高级语言下列各项中，不是C语言的特点是()。

A:语言简洁、紧凑，使用方便B:能实现汇编语言的大部分功能C:有较强的网络操作功能D:数据类型丰富，可移植性好

答案:有较强的网络操作功能下列叙述错误的是（

）。

A:C程序中的每条命令都用一个分号作为结束符B:C语言以小写字母作为基本书写形式，并且C语言要区分字母的大小写C:C程序中的每条语句都用一个分号作为结束符D:C程序中的变量必须先定义，后使用

答案:C程序中的每条命令都用一个分号作为结束符一个C程序的执行是从（

）。

A:本程序的main函数开始，到main函数结束B:本程序文件的第一个函数开始，到本程序main函数结束C:本程序文件的第一个函数开始，到本程序文件的最后一个函数结束D:本程序的main函数开始，到本程序文件的最后一个函数结束

答案:本程序的main函数开始，到main函数结束以下叙述不正确的是（

）。

A:在C程序中，注释说明只能位于一条语句的后面B:一个C源程序必须包含一个main函数C:一个C源程序可由一个或多个函数组成D:C程序的基本组成单位是函数

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

项目二单元测试

已知定义整形变量a,b,c的值分别是2、3、4，运算表达式a*=16+(b++)-(++c)以后，a值为(

)

A:30B:31C:29D:28

答案:28在C语言中，要求参加运算的数必须是整数的运算符是(

)。

A:&&B:++C:%D:!

答案:%合法的c标识符是(

)。

A:$sB:h1C:a>bD:5dm

答案:h1执行下列程序后，显示的结果是()

main()

{inta;

printf(“%d”,(a=3*5,a*4,a+5));}

A:15

B:10C:65D:20

答案:20sizeof(float)的结果是（）

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

答案:4赋值运算符有右结合性，因此表达式x=y=z等价于x=(y=z)()

A:对B:错

答案:对下列转义字符不正确的是（）。

A:\t

B:\+

C:\’’

D:\”

答案:\+

对于int

n=3;执行n+=n-=n*n；后n的值是9。

A:错B:对

答案:错在C语言中8.9e1.2是不正确的实型常量。

A:对B:错

答案:对对任一变量一旦被指定为某一确定类型后，该变量在程序运行时所占存储空间的多少和所能参加的运算类型便已确定了。

A:错B:对

答案:对若x为整型变量、j为实型变量，当执行语句：x=（int）j;后，j也变为整型变量。

A:错B:对

答案:错“!”的优先级可以比“/”高。

A:错B:对

答案:对两个char

型数据相加,其结果为char型。

A:错B:对

答案:错若有inti=10,j=2;则执行完i*=j+8;后ⅰ的值为28。

A:对B:错

答案:错执行floatf=9.8;intI;i=(int)f;语句后，变量f被转换成整型变量。

A:错B:对

答案:错以下各数均不是合法的八进制数:256、03A2、-0127。

A:错B:对

答案:错C语言程序中，任何英语单词均可以作标识符。

A:错B:对

答案:错赋值运算符有右结合性，表达式x=y=z等价于z=x=y()

A:错B:对

答案:错C语言中不区分大小写英文字母。

A:对B:错

答案:错当运算符两边数据类型不一致，运算会出现错误

A:错B:对

答案:对0x173是正确的十六进制常数。

A:对B:错

答案:对将一个整型数据赋值给一个字符型变量的时候，可能丢失数据（）

A:错B:对

答案:对下面程序的输出是________#include<stdio.h>int

main(){intk=11;

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

return1;}

A:k=11,k=013,k=0xbB:k=11,k=13,k=13C:k=11,k=13,k=bD:k=11,k=12,k=11

答案:k=11,k=13,k=b在下列选项中,不正确的赋值语句是_______.

A:k=i=j;B:a=a+b=1;C:++t;D:n1=(n2=(n3=0));

答案:a=a+b=1;下面程序的输出的是_________.

#include<stdio.h>

voidmain()

{intx=10,y=3;

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

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

答案:3已知字母A的ASCII码为十进制的65,下面程序的输出是_________.

#include<stdio.h>

voidmain()

{charch1,ch2;

ch1='A'+'5'-'3';

ch2='A'+'6'-'3';

printf("%d,%c",ch1,ch2);

}

A:B,CB:67,DC:不确定的值D:C,D

答案:67,Dsizeof(char)的结果是()

A:2

B:1

C:8

D:4

答案:1

sizeof(int)的结果是

A:4

B:1

C:8

D:2

答案:4

若有以下定义和语句:

inta=010,b=0x10,c=10;

printf("%d,%d,%d",a,b,c);则输出结果是________.

A:10,10,10B:8,16,10C:8,8,10D:8,10,10

答案:8,16,10已知有double型变量x=2.5,y=4.7,整型变量a=7,则表达式

x+a%3*(int)(x+y)%2/4的值是________.

A:2.5B:2.4C:2.75D:0

答案:2.5假定w、x、y、z、m均为int型变量，有如下程序段：

w=1;x=2;y=3;z=4;

m=(w<x)?w:x;

m=(m<y)?m:y;

m=(m<z)?m:z;则该程序段执行后，m的值是_______.

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

答案:1有以下程序，其中k的初值为八进制数#include<stdio.h>main(){intk=011;printf("%d"，k++);｝程序运行后的输出结果是________

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

答案:9sizeof(‘a’）的值是()

A:2

B:8

C:1D:4

答案:1有以下定义语句，编译时会出现编译错误的是_______

A:chara=’aa’;B:chara=’a’;C:chara=’’;D:chara=’-’

答案:chara=’aa’;以下选项中，不正确的C语言浮点型常量是_______

A:2e4.2B:160.C:0.0D:0.12

答案:2e4.2如果a是一个三位数，则以下可以求出其十位数的表达式是()

A:a/10%10

B:a%10/10

C:a/10

D:a%10

答案:a/10%10

以下合法的标识符是_______。

A:_a12B:intC:3ceD:stu#

答案:_a12已知int

x=023，表达式++x的值是_______。

A:20B:18C:19D:17

答案:20已知int

x=10,表达式x+=x-=x-x的值是_______。

A:30B:20C:10D:40

答案:20在C语言中，字符型数据在计算机内存中，以字符的_______形式存储。

A:反码B:BCD码C:原码D:ASCII码

答案:ASCII码如果a是一个三位数，则以下可以求出其个位数的表达式是（）

A:a/10%10

B:a/10

C:a%10

D:a%10/10

答案:a%10

如果a是一个三位数，则以下可以求出其百位数的表达式是（）

A:a%100

B:a/10C:a%10/10D:a/100

答案:a/100

A:3*a*e/b*cB:a*e/c/b*3C:a/b/c*e*3D:3*a*e/b/c

答案:3*a*e/b*c要为字符型变量a赋初值，下列语句中哪一个是正确的_______。

A:chara=*;B:chara=%;C:chara="3";D:chara=‘3’;

答案:chara=‘3’;字符串"ABC"在内存占用的字节数是_______。

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

答案:4若有说明语句：charc=':'；则变量c在内存占用的字节数是_______。

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

答案:1下列运算符优先级最高的是（）

A:单目运算符-

B:加+C:乘*D:减-

答案:单目运算符-

若已定义x和y为double类型，则表达式x=1，y=x+3/2的值是_______。

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

答案:2.0sizeof(double)的结果值是_______。

A:4B:2C:8D:出错

答案:8以下用户标识符中，合法的是_______。

A:123B:intC:a+bD:nit

答案:nit表达式18/4*sqrt(4.0)/8值的数据类型是_______。

A:intB:floatC:doubleD:不确定

答案:double一下运算符，运算优先级别最低的是（）

A:算术运算符B:逗号运算符C:逻辑运算符D:关系运算符

答案:逗号运算符在C语言中，赋值运算的说法错误的是（

）

A:数据类型不同无法进行赋值运算B:整型数据赋值给字符型数据时，只赋值低八位C:整型数据赋值给实型数据时，添加小数部分0D:实型数据赋值给整型数据时，舍去小数部分

答案:数据类型不同无法进行赋值运算下列哪一项不属于字符型变量可以存放的数据（

）

A:65B:‘？’C:12.5D:‘a’

答案:12.5以下说法错误的是（）。

A:圆括号必须成对出现B:C语言算术表达式和数学上的书写是一致的C:C语言算数表达式中，不用方括号和花括号D:圆括号可以嵌套使用

答案:C语言算术表达式和数学上的书写是一致的表达式1/4+2.75的值是3。（

）

A:错B:对

答案:错下列转义字符不正确的是（）。

A:’\053’B:’\\’C:’\’D:’\0’

答案:’\053’

项目三单元测试

以下选项中（

）是正确的复合语句。

A:{a=1,b=2}B:[a=1,b=2;]C:{a=1,b=2}；D:{a=1,b=2;}

答案:{a=1,b=2;}

以下语句的输出结果是（

）

printf("%2d",25876);

A:25

B:2587

C:25876

D:258

答案:25876

若变量已正确说明为float型，要通过语句scanf("%f%f%f",&a,&b,&c);给a赋予10.0，b赋予22.0,c赋予33.0，下列不正确的输入形式是（

）

A:10.0<回车>22.0

33.0<回车>B:10<回车>22<回车>33<回车>C:10

22<回车>33<回车>D:10.0,22.0,33.0<回车>

答案:10.0,22.0,33.0<回车>调用getchar和putchar函数时，必须包含的头文件是（

）。

A:以上都不对B:stdlib.h

C:stdio.h

D:define

答案:stdio.h

printf（）函数中常用的格式字符，不包括（

）

A:dB:zC:cD:f

答案:z“putchar(98);”这一C语句输出的结果为（）

A:98

B:C

C:b

D:B

答案:b

C语言标准格式输入函数scanf()的参数表中要使用变量的地址值。

A:错B:对

答案:对表达式语句和表达式没有什么区别。

A:错B:对

答案:错C语言标准输入操作中,gets()函数一次只可读取一个字符。

A:错B:对

答案:错C语言程序中可以有多个函数,但只能有一个主函数。

A:对B:错

答案:对C语言标准输出操作中,putchar()函数可以输出显示一个字符串。

A:错B:对

答案:错C语言标准格式输出函数printf()的参数表是由若干个表达式组成。

A:对B:错

答案:对putchar（）函数用于向终端输出一个字符。

A:对B:错

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

A:用C程序实现的算法可以没有输出但必须要有输入B:用C程序实现的算法必须要有输入和输出操作C:用C程序实现的算法可以没有输入但必须要有输出D:用C程序实现的算法可以既没有输入也没有输出

答案:用C程序实现的算法可以没有输入但必须要有输出在C语言中，执行下面两个语句后，输出的结果为(

)。

charc1=97,c2=98;printf("%d%c",c1,c2);

A:a

bB:97

bC:a

98D:97

98

答案:97

b下列语句中符合C语言语法的赋值语句是

A:a=7+b,c=a+7;B:a=7+b++=a+7;C:a=7+b,b++,a+7D:a=7+b+c=a+7;

答案:a=7+b,c=a+7;在C语言语言中，退格符是(

)

A:＼fB:＼tC:＼bD:＼n

答案:＼bputchar()函数可以向终端输出一个

A:字符串B:实型变量值C:字符或字符型变量值D:整型变量表达式值

答案:字符或字符型变量值以下选项中不是C语句的是（

）。

A:;B:k=i=j;C:{a/=b=1;b=a%2;}D:++t

答案:++t有定义语句：int

a=5,b，不能给b赋2的赋值语句是（

）。

A:b=5;b=2;B:b=a/2;C:b=b+2;D:b=2%a;

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

）。

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

答案:%x是格式符的一种，其变量的值按十六进制输出，但%8lx是错误的字符串”helloworld”的存储长度是()

A:12

B:10

C:11

D:13

答案:11

若变量已正确说明为char类型，scanf("%c%c",&a,&b);若要使a=‘h’,b=’c’，则正确的输入是（

）。

A:h,cB:h

c

C:hcD:hc

答案:hc使用scanf("a=%d,b=%d",&a,&b)为变量a,b赋值。要使a,b均为50，正确的输入是（

）。

A:a=50,b=50B:50

50C:a=50

b=50D:50,50

答案:a=50,b=50调用putchar（）函数时，以下说法正确的是（

）

A:putchar（）函数可以接收用户输入B:putchar（）函数能够输出字符串C:使用putchar（）函数时不需要包含”stdio.h”文件D:putchar（）函数只能输出单个字符

答案:putchar（）函数只能输出单个字符

以下叙述中不正确的是()。

A:调用printf函数时，必须要有输出项B:使用putchar函数时，必须在之前包含头文件stdio.hC:在C语言中，整数可以以十进制、八进制或十六进制的形式输出D:使用putchar函数可以不要输出项

答案:调用printf函数时，必须要有输出项如果有scanf("%d%d",&a,&b),为a、b赋值错误的输入是（）

A:2（tab键）3B:2（换行）3C:2（空格）

3D:2，3

答案:2，3用getchar()函数可以从键盘读入一个（

）。

A:字符串B:整型变量表达式值C:字符或字符型变量D:实型变量值

答案:字符或字符型变量

项目四单元测试

若要求在if后的圆括号中表示a不等于0的关系，能正确表示这一关系的表达式是（）。

A:a=0B:a<>0C:!aD:a

答案:!a以下程序段，运行后的输出结果是（）charm='b';

if(m++>'b')

printf("%c",m);

elseprintf("%c",m--);

A:dB:cC:aD:b

答案:c设a=1,b=2,c=3,d=4,则表达式a<b?b:c<d?a:b的结果为（）。

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

答案:2

下列叙述中正确的是()。

A:break语句必须与switch语句中的case配对使用B:在switch语句中，不一定使用break语句C:在switch语句中必须使用defaultD:break语句只能用于switch语句

答案:在switch语句中，不一定使用break语句以下程序段的输出结果是（）。

inta=13,b=21,m=0;

switch(a%3)

{

case0:m++;break;

case1:m++;

switch(b%2)

{

default:m++;

case0:m++;break;

}

}

printf("%d",m);

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

答案:3逻辑表达式的值只能为1或0。

A:对B:错

答案:对在switch语句中，每一个的case常量表达式的值可以相同。

A:错B:对

答案:错在switch语句中，多个case可以共用一组执行语句。

A:对B:错

答案:对下列关于运算符优先顺序的描述中正确的是()。

A:关系运算符<算术运算符<赋值运算符<逻辑与运算符B:算术运算符<关系运算符<赋值运算符<逻辑与运算符C:逻辑运算符<关系运算符<算术运算符<赋值运算符D:赋值运算符<逻辑与运算符<关系运算符<算术运算符

答案:赋值运算符<逻辑与运算符<关系运算符<算术运算符能正确表示“当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）||(x<＝10)||(x>＝200)||(x<＝210)

答案:（x>＝1）&&(x<＝10)||(x>＝200)&&(x<＝210)在C语言中，设有如下定义:

int

a=1,b=2,c=3,d=4,m=2,n=2;

则执行表达式:(m=a>b)&&(n=c>d)后,n的值为(

)。

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

答案:2设有如下定义:

int

a＝2,b;

则执行b＝a&&1;语句后，b的结果是(

)。

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

答案:1设a=3，b=4，c=5,则表达式!(a>b)&&!c||1的结果是(

)。

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

答案:1能正确表示a和b同时为正或同时为负的逻辑表达式是(

)。

A:a*b>0B:(a>=0||b>=0)&&(a<0||b<0)C:(a+b>0)&&(a+b<=0)D:(a>=0&&b>=0)&&(a<0&&b<0)

答案:a*b>0以下程序段的输出结果是(

)。

inta=10,b=50,c=30；

if(a>b)

a=b；

b=c；

c=a；

printf("a=%db=%dc=%d",a,b,c)；

A:a=50b=30c=50B:a=50b=30c=10C:a=10b=50c=10D:a=10b=30c=10

答案:a=10b=30c=10有如下程序

intmain()

{floatx=2.0,y;

if(x<0)y=0.0;

elseif(x<10.0)y=1.0/x;

elsey=1.0;

printf(“%f”,y);

return0;

}

该程序的输出结果是（）。

A:0.250000B:1.000000C:0.000000D:0.500000

答案:0.500000以下不可以用在switch语句的括号中作为表达式的选项是（

）

A:字符常量B:实型常量C:整型常量D:整型表达式

答案:实型常量有如下程序段:

intx=1,y=1;

intm,n;

m=n=1;

switch(m)

{case0:x=x*2;

case1:

{

switch(n)

{case1:x=x*2;

case2:y=y*2;break;

case3:x++;

}

}

case2:x++;y++;

case3:x*=2;y*=2;break;

default:x++;y++;

}

执行完成后，x和y的值分别为（）。

A:x=7y=7B:x=2y=2C:x=2y=1D:x=6y=6

答案:x=6y=6以下程序的输出结果是（）

intmain()

{inta＝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;

elsex＝3;

elsex＝6;

elsex＝7;

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

return0;

}

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

答案:2在C语言中，设x=1,y=2,执行表达式

(x>y)?x++:++y以后x和y的值分别为()。

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

答案:1和3以下不属于C语言逻辑运算符的是（

）。

A:&&B:||C:？D:！

答案:？

项目五单元测试

若i为整型变量，则以下循环执行的次数是（）。(单选）for（i=0;i<=5;i++）

printf（"%d",i++）;

A:3次B:6次C:2次

D:5次

答案:3次下面的程序对输入的每一个数字出现的次数进行计数，下划线处应填入的正确语句为#include"stdio.h"intmain(){inti,ch,n[10];

for(i=0;i<10;++i)n[i]=0;

while((ch=getchar())!='\n')

if(ch>='0'&&ch<='9')

________;

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

printf("数字%d出现的次数是:%d",i,n[i]);}

A:n[i]++B:n[ch-‘0’]++C:n[ch]++D:i++

答案:n[ch-‘0’]++下列程序段的输出结果是()。intx=3；

do{printf（“%3d”，x-=2）；}

while（！（--x））；

A:0B:1

C:1-2

D:-2

答案:1-2

若x是int型变量，且有下面的程序片段：

for（x=5;x<8;x++）

printf（（x/2）？（“**%d”）：（“##%d”）,x）;该程序片段的输出结果是（）。

A:**5##6**7##8B:**5**6**7

C:**5##6**7D:##5**6##7**8

答案:**5**6**7

C语言中（

）。

A:do-while语句构成的循环，当while语句中的表达式值为零时结束循环B:不能使用do-while语句构成的循环

C:do-while语句构成的循环，当while语句中的表达式值为非零时结束循环D:do-while语句构成的循环必须用break语句才能退出

答案:do-while语句构成的循环，当while语句中的表达式值为零时结束循环break语句只能用于循环语句中。

A:对B:错

答案:错continue语句可以用于switch结构中。

A:对B:错

答案:错在C语言中,为了结束由do-while语句构成的循环,while后一对圆括号中表达式的值应该能够为0

A:错B:对

答案:对三种循环(while语句、for语句、do-while语句)都可以用来处理同一个问题,一般它们可以相互代替。

A:错B:对

答案:对for(i=0,k=-1;k=1;k++,i++)printf("*");循环体一次也不执行。

A:对B:错

答案:错for(i=4;i>1;i--)for(j=1;j<i;j++)putchar('#');输出为；；。

A:对B:错

答案:对对下面程序段描述正确的是______.

intx=0,s=0;

while(!x!=0)s+=++x;

printf("%d",s);

A:程序段循环无数次B:程序段中的控制表达式是非法的C:运行程序段后输出0D:运行程序段后输出1

答案:运行程序段后输出1下面程序段的输出结果是______.

x=3;

do{y=x--;

if(!y){printf("*");continue;}

printf("#");

}while(x=2);

A:输出错误信息B:##*C:死循环D:##

答案:死循环下面程序的输出结果是_______.

#include<stdio.h>

void

main()

{intn=4;

while(n--)printf("%d",n--);

}

A:20B:210C:31D:321

答案:31以下程序运行后的输出结果是________.

#include<stdio.h>

voidmain()

{inti=10,j=0;

do

{j=j+1;

i--;

}while(i>2);

printf("%d",j);

}

A:8B:52C:50D:51

答案:8下面程序的输出结果是________.

main()

{

inti,k=0,a=0,b=0;

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

k++;

if(k%2==0){a=a+k;continue;}

b=b+k;

a=a+k;

}

printf("k=%da=%db=%d",k,a,b);

}

A:k=4a=10b=3B:k=3a=6b=4C:k=5a=10b=4D:k=4a=10b=4

答案:k=4a=10b=4下面程序的输出结果是_______.

#include<stdio.h>

voidmain()

{inty=9;

for(;y>0;y--)

{if(y%3==0)

{printf("%d",--y);

continue;}

}

}

A:875421B:852C:741D:963

答案:852有以下程序#include<stdio.h>main(){inti,j,m=1;for(i=1;i<3;i++){for(j=3;j>0;j--)

{if(i*j>3)break;

m=i*j;

}}printf("m=%d",m);}程序运行后的输出结果是_______.

A:m=4B:m=1C:m=2D:m=5

答案:m=1有以下程序

#include<stdio.h>

main()

{intc=0,k;

for(k=1;k<3;k++)

switch(k)

{default:c+=k;

case2:c++;break;

case4:c+=2;break;

}

printf(“%d”,c);

}

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

A:9B:7C:5D:3

答案:3for(i=1;i<9;i+=1);该循环共执行了_______次。

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

答案:8inta=2;while(a=0)a--;该循环共执行了_______次。

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

答案:0执行完循环

for(i=1;i<100;i++);后，i的值为_______。

A:102B:100C:101D:99

答案:100以下

for语句中，书写错误的是_______。

A:i=1;for(;i<5;i++);B:for(i=1;i<5;i++);C:for(i=1;i<5;i++)D:for(i=1;i<5;)i++;

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

_______语句，在循环条件初次判断为假，还会执行一次循环体。

A:以上都不是B:forC:do-whileD:while

答案:do-while有以下程序段，其运行结果是_______inti=5;do{if(i%3==1)if(i%5==2){printf("*%d",i);break;}i++;}while(i!=0);

A:*3*5B:*2*6C:*7D:*5

答案:*7i、j已定义为int类型，则以下程序段中内循环体的执行次数是_______。for(i=5;i;i--)

for(j=0;j<4;j++){…}

A:25B:30C:20D:24

答案:20以下不构成无限循环的语句或语句组是_______。

A:n=0;

do{++n;}while(n<=0);B:n=0;

while(1){n++;}C:for(n=0,i=1;;i++)n+=i;D:n=10;

while(n);{n--;}

答案:n=0;

do{++n;}while(n<=0);若有定义“intA[3][4]”,则能表示数组元素A[1][1]的是（

）

A:*(A+1)[1]

B:*(A+5)C:（A[1]+1）D:*(&A[1][1])

答案:*(&A[1][1])

有以下程序段，其运行结果是_______。inti,j;for(i=3;i>=1;i--){for(j=1;j<=2;j++)printf("%d",i+j);printf("\n");}

A:2

3

43

4

5B:4

53

42

3C:4

3

25

4

3D:2

33

44

5

答案:4

53

42

3

项目六单元测试

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

A:inta[10]={0,0,0,0,0};B:inta[10]={10*1};C:inta[10]={};D:inta[]={0};

答案:inta[10]={};在C语言中，引用数组元素时，其数组下标的数据类型允许是（）

A:整型常量B:整型常量或整型表达式C:整型表达式D:任何类型的表达式

答案:整型常量或整型表达式对以下说明语句，理解正确的是（

）。

inta[10]={6,7,8,9,10};

A:将5个初值依次赋给a[6]到a[10]B:因为数组长度与初值的个数不相同，所以此语句不正确C:将5个初值依次赋给a[0]到a[4]D:将5个初值依次赋给a[1]到a[5]

答案:将5个初值依次赋给a[0]到a[4]以下说法错误的是（）

A:数组名的命名规则应符合标识符的命名规则B:定义数组的时候，不能用变量作为数组下标C:同一段程序中，数组名可以和其他变量名相同D:同一个数组的元素，其数据类型必须相同

答案:同一段程序中，数组名可以和其他变量名相同strcmp（）函数比较两个字符串的大小，以下错误的是（）

A:字符串1==字符串2，返回值为0B:

以上说法都不对C:字符串1<字符串2，返回值<0D:字符串1>字符串2，返回值大于0

答案:

以上说法都不对以下函数不可以处理字符串是（

）。

A:strcmp()B:sqrt()C:strcat()D:strcpy()

答案:sqrt()关于strcpy（参数2，参数2）函数，以下说法错误的是（

）

A:参数2必须写成数组名称B:参数1必须是字符数组，而且必须定义得够大，能容纳参数2C:参数2可以是字符串常量D:参数1必须写成数组名称

答案:参数2必须写成数组名称数组名的命名规则与标识符命名规则相同，不能用数字开头。()

A:错B:对

答案:对在对数组全部元素赋初值时，可以省略行数，但不能省略列数

A:错B:对

答案:对数组元素通常也称为下标变量。必须先定义数组，才能使用下标变量。

A:错B:对

答案:对C语言中,字符串常量存放在字符数组中要有一个结束符,该结束符是0。

A:对B:错

答案:错C语言允许用字符串的方式对数组作初始化赋值。

A:对B:错

答案:对在对数组全部元素赋初值时，不可以省略行数，但能省略列数

A:错B:对

答案:错对二维数组的正确说明是

A:inta[][3]={1,2,3,4,5,6}；B:inta[2,3]={1,2,3,4,5,6}；C:inta[2][]={1,2,3,4,5,6}；D:inta[][]={1,2,3,4,5,6}；

答案:inta[][3]={1,2,3,4,5,6}；以下关于数组的描述正确的是

A:数组的大小是固定的，但可以有不同的类型的数组元素；B:数组的大小是固定的，但所有数组元素的类型必须相同；C:数组的大小是可变的，但所有数组元素的类型必须相同；D:数组的大小是可变的，但可以有不同的类型的数组元素；

答案:数组的大小是固定的，但所有数组元素的类型必须相同；在定义inta[5];之后，对a的引用不正确的是（)

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

答案:a[5]以下对一维数组a进行不正确初始化的是

A:inta[10]＝{10*2};B:inta[10]＝{};C:inta[]＝{0};

D:inta[10]＝(0,0,0,0);

答案:inta[10]＝(0,0,0,0);以下能对一维数组a[3]全部赋值为2的语句正确的是（）

A:a[2]=2；B:a[0]=2；a[1]=2;C:a[3]={2}D:a[3]={2，2，2}

答案:a[3]={2，2，2}以下说法错误的是（）

A:数组初始化可以只给部分元素赋初值B:赋值语句不能给数组整体赋值C:可以给数组整体赋值D:可以给数组元素逐个赋值

答案:可以给数组整体赋值如果有定义int

a[5];则以下正确的赋值语句是（

）。

A:a=10；B:a[5]=10;C:scanf("%d",&a);D:a[0]=10;

答案:a[0]=10;若有说明：inta[][2]={{0,0},{1}};则下面正确的叙述是（

）。

A:只有元素a[0][0]和a[0][1]可得到初值，其余元素均得不到确定的初值B:数组a共有3个数组元素C:数组a的每个元素都可得到初值0D:二维数组a的第一维大小为2

答案:二维数组a的第一维大小为2若有说明inta[3][4]；则a数组元素的非法引用是（）。

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

答案:a[0][4]以下能对二维数组a进行正确初始化的语句是（

）。

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

答案:inta[][3]={{1,2,3},{4,5,6}};设有数组定义：chararr[]="China";则数组arr所占空间为（）。

A:6个字节B:5个字节C:4个字节D:7个字节

答案:6个字节若有以下语句，则正确的描述是（）。

chara[]="toyou";

charb[]={'t','o','y','o','u'};

A:a数组长度小于b数组长度B:a数组和b数组的长度相同C:a数组长度大于b数组长度D:a数组等价于b数组

答案:a数组长度大于b数组长度下面叙述正确的是（

）。

A:字符串”STOP”与”STOP”相等B:字符个数多的字符串比字符个数少的字符串大C:字符串”That”小于字符串”The”D:两个字符串所包含的字符个数相同时，才能比较字符串

答案:字符串”That”小于字符串”The”在定义inta[5][4];之后，对数组元素的引用正确的是

A:a[0，0]B:a[2][4]C:a[0][0]D:a[5][0]

答案:a[0][0]在执行inta[][3]＝{1,2,3,4,5,6};语句后，a[1][0]的值是

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

答案:4在定义inta[3][4][2];后，第10个元素是（）

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

答案:a[1][0][1]在C语言中，strlen函数的功能以下说法正确的是（）

A:比较字符串大小B:复制字符串C:求字符串长度（不包含'\0')D:求字符串长度（包含'\0')

答案:求字符串长度（不包含'\0')有字符数组a[80],b[80],则正确的输出语句是

A:puts(a);puts(b）;B:printf(“%s,%s”,a[],b[]);C:putchar(a,b);D:puts(a,b);

答案:puts(a);puts(b）;以下不能正确进行字符串赋初值的语句是

A:charstr[5]="good!";B:charstr[5]={''g'',''o'',''o'',''d''};C:charstr[]="good!";D:char*str="good!";

答案:charstr[5]="good!";已有定义：chara[]="xyz",b[]={''x'',''y'',''z''};,以下叙述中正确的是（）。

A:上述说法都不对B:a数组长度小于b数组长度C:a数组长度大于b数组长度D:数组a和b的长度相同

答案:a数组长度大于b数组长度在C语言中，能实现字符串连接的函数是（

）

A:strcmp()B:strcpy()

C:strlen()D:strcat()

答案:strcat()在C语言中,有:charstr[]="abcd";printf(%d",strlen(str));上面程序片段的输出结果是(

)

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

答案:4在C语言中，不能把字符串"Hello!"赋给数组b的语句是(

)。

A:charb[10]={''H'',''e'',''l'',''l'',''o'',''!''};B:charb[10];b="Hello!";C:charb[10];strcpy(b,"Hello!");D:charb[10]="Hello!";

答案:charb[10];b="Hello!";函数调用:strcat(strcpy(str1,str2),str3)的功能是

A:将串str2连接到串str1之后再将串str1复制到串str3中B:将串str1复制到串str2中后再连接到串str3之后C:将串str1连接到串str2之后再复制到串str3之后D:将串str2复制到串str1中后再将串str3连接到串str1之后

答案:将串str2复制到串str1中后再将串str3连接到串str1之后不能把字符串:Hello!赋给数组b的语句是

A:charb[10]={'H','e','l','l','o','!',0};B:charb[10];b="Hello!";C:charb[10]="Hello!";D:charb[10];strcpy(b,"Hello!");

答案:charb[10];b="Hello!";

项目七单元测试

以下叙述中错误的是（）

A:函数的参数可以是数据的地址B:函数的参数可以是数组C:函数的参数是数组时，必须指定数组大小D:函数的参数可以是任意数据类型

答案:函数的参数是数组时，必须指定数组大小以下关于函数的说法，错误的是（）。

A:使用“include”指令将库函数所在的头文件包含到程序中，然后才能调用库函数。B:库函数因为是编译器提供的，直接调用即可C:C程序的运行从main（）函数开始D:C程序必须有一个main（）函数

答案:库函数因为是编译器提供的，直接调用即可以下程序的输出结果是（）。#include"stdio.h"intf(intx){

inty;

if(x==0||x==1)

return(3);

y=x*x-f(x-2);

return

y;}

intmain(){

intz;

z=f(3);

printf("%d",z);

return0;}

A:0B:6C:9D:8

答案:6以下程序的输出结果是（）。#include<stdio.h>intfun(int

x){

int

p;

if(x==0||x==1)

return(3);

p=x-fun(x-2);

returnp;}

intmain(){

printf("%d",fun(7));

return0;}

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

答案:2以下属于函数定义的组成部分的是（）

A:形式参数列表B:其他选项全都是C:函数体D:返回类型E:函数名

答案:其他选项全都是函数的实参传递到形参有两种方式值传递和地址传递。

A:错B:对

答案:对如果函数定义出现在函数调用之前，可以不必加函数声明。

A:错B:对

答案:对函数的实参可以是常量，变量或表达式。

A:对B:错

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

A:用户自己定义的函数只能调用库函数B:C语言源程序总是由一个或多个函数组成C:不同函数的形式参数不能使用相同名称的标识符D:在C语言的函数内部，可以定义局部嵌套函数

答案:C语言源程序总是由一个或多个函数组成若已定义的函数有返回值，则以下关于该函数调用的叙述中错误的是（

）。

A:函数调用可以出现在表达式中B:函数调用可以作为一个函数的形参C:函数调用可以作为一个函数的实参D:函数调用可以作为独立的语句存在

答案:函数调用可以作为一个函数的形参以下程序的输出结果是（）。

#include

<stdio.h>

void

funA(int

n)

{n++;}

intmain()

{

int

a=1;

funA(a);

printf("%d

",a);

funA(a);

printf("%d",a);

return0;

}

A:2

1B:1

1C:1

2D:2

2

答案:1

1有以下程序,程序运行后的输出结果是（

）。#include

<stdio.h>intnew_div(double

a,double

b){

returna/b+0.5;

}intmain(){

printf("%d",new_div(7.8,3.1));

return0;

}

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

答案:3在一个C语言程序中，下列说法正确的是(

)。

A:main函数必须出现在所有函数之后B:main函数可以出现在其它函数之外的任何位置C:main函数必须出在固定位置D:main函数必须出现在所有函数之前

答案:main函数可以出现在其它函数之外的任何位置以下叙述中正确的是(

)。

A:函数名允许用数字开头B:函数调用时，不必区分函数名称的大小写C:调用函数时，函数名必须与被调用的函数名完全一致D:在函数体中只能出现一次return语句

答案:调用函数时，函数名必须与被调用的函数名完全一致以下说法错误的是（）。

A:如果函数没有返回值，返回类型空着。B:如果函数没有返回值，返回类型为void。C:用户可以根据需要自定义函数。D:库函数由编译器提供，无需用户定义。

答案:如果函数没有返回值，返回类型空着。有以下程序

#include<stdio.h>

intmain()

{

intfindmax(int,int,int),m;

┋

m=findmax(a,b,c);

┋

}

intfindmax(intx,inty,intz)

{

…

}则以下叙述正确的是（

）。

A:在main函数内、外重复定义了findmax函数B:在main函数中声明了findmax函数C:在main函数中定义了findmax函数D:在main函数中两次调用了findmax函数

答案:在main函数中声明了findmax函数设有函数定义：voidsub(intk,charch){…

}则以下对函数sub的调用语句中，正确的是（

）。

A:sub(2,'97');B:sub(4,"a");C:sub(1,97);D:n=sub(3,'a');

答案:sub(1,97);下列叙述中错误的是（

）。

A:主函数中定义的变量在整个程序中都是有效的。B:在其它函数中定义的变量在主函数中也不能使用。C:复合语句中定义的变量只在该复合语句中有效。D:形式参数也是局部变量。

答案:主函数中定义的变量在整个程序中都是有效的。凡是函数中未指定存储类别的局部变量，其隐含的存储类型是（

）。

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

答案:自动（auto）下面程序的输出结果是（

）。

#include<stdio.h>

intmain()

{intx=10；

{intx=20；

printf("%d，",x)；

}

printf("%d",x)；return0;

}

A:20，10B:20，20C:10，20D:10，10

答案:20，10以下程序的输出结果是（）。#include<stdio.h>intfun(inta,intb){

staticintm=0,i=2;

i+=m+1;

m=i+a+b;

return

m;}

intmain(){

int

k=4,m=1,p;

p=fun(k,m);

printf("%d,",p);

p=fun(k,m);

printf("%d",p);

return0;}

A:8,20B:8,16C:8,17D:8,8

答案:8,17下面程序的输出结果是（

）。

intmain()

{inta=2,i；

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

printf("%4d",f(a))；

return0;

}

f(inta)

{intb=0；

staticintc=3；

b++；

c++；

return(a+b+c)；

}

A:71013B:789C:7911D:777

答案:789函数返回值的类型是由（

）决定的。

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

答案:定义函数时，所指定的函数类型若函数调用时的实参为变量时，以下关于函数形参和实参的叙述中正确的是(

)。

A:函数的实参和其对应的形参共占同一存储单元B:形参只是形式上的存在，不占用具体存储单元C:函数的形参和实参分别占用不同的存储单元D:同名的实参和形参占同一存储单元

答案:函数的形参和实参分别占用不同的存储单元有如下函数定义：#include

<stdio.h>int

fun(int

k){if(k<1)

return

0；else

if(k＝＝1)

return

1；else

return

fun(k－1)＋1；}若执行调用语句：n＝fun(3)；，则函数fun总共被调用的次数是(

)。

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

答案:3

项目八单元测试

下列程序的输出结果是（）。main（）{intk=4,m=5,n=7;int*pk=&k,*pm=&m,*p;*（p=&n）=*pk*（*pm）;printf（“%d”,n）;}

A:21B:20C:5D:7

答案:20对于类型相同的指针变量，不能进行的运算是（）。

A:=B:==C:+D:-

答案:+以下程序的输出结果是（）#include<stdio.h>intmain(){

charstr[100]="ABCDEFG",*p=str;

inti;

for(i=0;*p!='\0';p++,i++);

printf("%d",i);return0;}

A:99B:100C:7

D:8

答案:7

已知有以下的说明，

inta[]={8,1,2,5,0,4,7,6,3,9};那么a[*（a+a[3]）]的值为（）。

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

答案:0有以下程序：main（）{charstr[][10]={“China”，“Beijing”}，*p=str；

printf（“%s”，p+10）；}该程序运行后的输出结果是（）。

A:BeijingB:ngC:ingD:China

答案:Beijing下列关于指针定义的描述正确的有（）。

A:在定义指针时，”*”号表示指针变量的指向B:指针变量的类型与它所指向的变量类型一致C:指针变量是一种变量，该变量是用来存放某个变量的地址值的D:指针变量的命名规则与标识符相同

答案:在定义指针时，”*”号表示指针变量的指向；指针变量的类型与它所指向的变量类型一致；指针变量是一种变量，该变量是用来存放某个变量的地址值的；指针变量的命名规则与标识符相同设有定义语句：intx[6]={2,4,6,8,5,7}，*p=x，i;要求依次输出x数组中6个元素中的值，下列选项中能完成此操作的语句有（）。

A:for（i=0;i<6;i++）printf（“%2d”,*（p+i））;B:for（i=0;i<6;i++）printf（“%2d”,（*p）++）;C:for（i=0;i<6;i++）printf（“%2d”,*p++）;D:for（i=0;i<6;i++）printf（“%2d”,*（p++））;

答案:for（i=0;i<6;i++）printf（“%2d”,*（p+i））;；for（i=0;i<6;i++）printf（“%2d”,*p++）;；for（i=0;i<6;i++）printf（“%2d”,*（p++））;inti=3,*p;p=&i;printf("%d",*p);是正确的。

A:错B:对

答案:对C程序中，函数调用时用数组名作为函数的实参，则传递给形参的是数组的首地址值。

A:对B:错

答案:对在C程序中，函数的形式参数是指针类型时，调用时对应的实参也必须是地址量。

A:错B:对

答案:对对同一类型的两个指针变量而言，一个变量向另外一个变量赋值的结果是使得两个指针指向同一个对象。

A:错B:对

答案:对将一维数组a的第i个元素的地址赋给指针变量p的语句是p=&a[i-1];

A:错B:对

答案:对char*p="girl";的含义是定义字符型指针变量p,p的值是字符串"girl"。

A:错B:对

答案:错inta[10]={0,1,2,3,4,5,6,7,8,9},*p=a;则p+5相当于a[5]

。

A:错B:对

答案:错有如下说明:int

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

A:错B:对

答案:对若有inta[3][4];*(a+1)+2表示a[1][2]元素的地址。

A:错B:对

答案:对指针变量作为函数形参，仍然遵循单向值传递的传送规则，传递的值是地址值()

A:对B:错

答案:对若有定义：inta[5],*p;，则操作p=a;是合法的操作。

A:错B:对

答案:对若有定义：inta[5],*p;，则操作p=&a[2];是合法的操作。

A:错B:对

答案:对若有定义：inta[5][5],*p;，则操作p=a;是合法操作。

A:对B:错

答案:错如果有inta[5];int*p=a;则p可以被赋值，但a不可以。

A:错B:对

答案:对若有定义：inta[5][5],(*p)[5];，则操作p=a[0];是合法操作。

A:错B:对

答案:错凡是整型变量可以参加的运算，指针变量都可以参加。

A:错B:对

答案:错对于指向同一个数组的两个变量而言，两个指针变量相减的操作是有意义的。

A:对B:错

答案:对对数组各元素的存取完全可以不用下标变量而用指针来代替。

A:错B:对

答案:对下列关于指针概念的描述中，错误的是（

）

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

答案:指针的类型是它所存放的数值的类型已知：inta[5]，*p=a；则与++*p相同的是（

）。

A:*p++B:a[0]C:*++pD:++a[0]

答案:++a[0]已知：inta[]={1,2,3,4,5}，*p=a；在下列数组元素地址的表示中，正确的是（

）。

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

答案:&p[2]若有语句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))下列语句组中，正确的是（

）

A:char*s;s="Olympic";B:chars[7];s={"Olympic"｝;C:chars[7];s="Olympic";D:char*s;s={"Olympic"｝;

答案:char*s;s="Olympic";若有定义int(*pt)[3];，则下列说法正确的是（

）

A:定义了基类型为int的三个指针变量B:定义了一个名为pt的指针变量，它可以指向每行有三个整数元素的二维数组C:定义了基类型为int的具有三个元素的指针数组ptD:定义了一个名为*pt、具有三个元素的整型数组

答案:定义了一个名为pt的指针变量，它可以指向每行有三个整数元素的二维数组有以下程序#include<stdio.h>intf(intt[],intn);main(){inta[4]={1,2,3,4},s;s=f(a,4);printf("%d",s);}intf(intt[],intn){if(n>0)returnt[n-1]+f(t,n-1);

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

)

A:4B:10C:6D:14

答案:10有以下程序

#include<stdio.h>

main()

{intm=1,n=2,*p=&m,*q=&n,*r;

r=p;p=q;q=r;

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

}

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

)

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

答案:1,2,2,1若有定义语句：inta[4][10],*p,*q[4];且0≤i<4，则错误的赋值是(

)

A:p=aB:p=a[i]C:q[i]=a[i]D:p=&a[2][1]

答案:p=a有以下程序

#include<stdio.h>

#include<string.h>

main()

{charstr[][20]={“One*World”,“One*Dream!”},*p=str[1];

printf(“%d,”,strlen(p));printf(“%s”,p);

}

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

)

A:10,One*DreamB:9,One*DreamC:10,One*WorldD:9,One*World

答案:10,One*Dream下列函数的功能是(

)

fun(char*a,char*b)

{while((*b=*a)!=’\0’){a++,b++;}}

A:使指针b指向a所指字符串B:检查a和b所指字符串中是否有’’C:将a所指字符串赋给b所指空间D:将a所指字符串和b所指字符串进行比较

答案:将a所指字符串赋给b所指空间设有定义：char

*c;，以下选项中能够使字符型指针c正确指向一个字符串的是(

)

A:*c=”string”;B:c=getchar();C:scanf(“%s”,c);D:charstr[]=”string”;c=str;

答案:charstr[]=”string”;c=str;有以下程序

#include<stdio.h>voidfun(int*a,int*b){int*c;c=a;a=b;b=c;}main(){intx=3,y=5,*p=&x,*q=&y;fun(p,q);printf("%d,%d,",*p,*q);fun(&x,&y);printf("%d,%d",*p,*q);}

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

)

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

答案:3,5,3,5已知chars[10],*p=s;,则在下列语句中，错误的语句是（

）。

A:p=s+5;B:*p=s[0]C:s=p+s;D:s[2]=p[4]

答案:s=p+s;已知charb[5],*p=b；，则正确的赋值语句是（

）。

A:b=””;B:*b=”abcd”;C:*p=”abcd”;D:p=”abcd”;

答案:p=”abcd”;已知chars[20]=”programming”,*ps=s;则不能引用字母o的表达式是（

）。

A:s[2]B:ps+2C:ps+=2,*psD:ps[2]

答案:ps+2下列选项中，正确的语句组是（

）。

A:chars[8];s={"Beijing"};B:char*s;s="Beijing";C:char*s;s={"Beijing"};D:chars[8];s="Beijing";

答案:char*s;s="Beijing";已知char*p，*q；下面语句正确的是（

）。

A:p+=q;B:p/=q;C:p+=3;D:p*=3;

答案:p+=3;若说明int*p，n；则通过语句scanf能够正确读入数据n的程序段是（

）。

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

答案:p=&n;scanf("%d",p);若有定义：intx,*pb；则以下正确的表达式是（

）

A:pb=xB:*pb=&xC:pb=&xD:*pb=*x

答案:pb=&x以下程序的输出结果是（

）#include<stdio.h>voidmain(){printf(“%d”,NULL);}

A:1B:-1C:0D:因变量无定义输出不定值

答案:0如果有语句

intx,*px;

px=&x;

以下表达式，哪一项和其他项含义不同（）

A:*pxB:&(*px)C:pxD:&x

答案:*px已知指针p的指向如图所示的a[1]，则表达式*++p的值是（

）。

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

答案:30已知指针p的指向如图所示的a[1]，则表达式++*p的值是（

）。

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

答案:21若有语句int*point,a=4;和point=&a;下面均代表地址的一组选项是（

）。

A:&*a,&a,*pointB:a,point,*&aC:*&point,*point,&aD:&a,&*point,point

答案:&a,&*point,point若有下面的程序段：chars[]="china";char*p;p=s;则下列叙述正确的是（

）。

A:s和p完全相同B:*p与s[0]相等C:数组s中的内容和指针变量p中的内容相等D:s数组长度和p所指向的字符串长度相等

答案:*p与s[0]相等已定义以下函数fun(char*p2,char*p1){while((*p2=*p1)!=’\0’){p1++;p2++;}}函数的功能是（

）。

A:对p1和p2两个指针所指字符串进行比较B:将p1所指字符串复制到p2所指内存空间C:将p1所指字符串的地址赋给指针p2D:检查p1和p2两个指针所指字符串中是否有’’

答案:将p1所指字符串复制到p2所指内存空间下面程序段中，输出*的个数是（

）。char*s="a8bc";for(;*s!='\0';s++)printf("*");

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

答案:5阅读下列程序，则执行后的结果为（

）。#include"stdio.h"intmain(){intc[][4]={1,2,3,4,5,6,7,34,213,56,62,3,23,12,34,56};printf("%x,%x",c[2][2],*(*(c+1)+1));}

A:56,5B:62,5C:3e,6D:3E,6

答案:3e,6现有inta,*b;,b=&a;，则下列运算错误的是（

）。

A:*&aB:*&bC:&*bD:&*a

答案:&*a现有如下定义语句，表示数组元素s[i]的表达式不正确的是（

）。int*p,s[20],i;p=s;

A:*(p=p+i)B:*(s=s+i)C:*(s+i)D:*(p+i)

答案:*(s=s+i)

项目九单元测试

若有以下语句

typedef

struct

S

{

int

g;

char

h;

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

A:S是struct类型的变量B:可用S定义结构体变量C:T是structS类型的变量D:可用T定义结构体变量

答案:可用T定义结构体变量下列说法不正确的是（）。

A:一个结构体中数据成员的类型必须相同。B:使用结构体类型定义变量前，需要先定义这个类型。C:定义结构体类型时，末尾的分号不能省略。D:一个结构体中可以有多个不同类型的数据成员。

答案:一个结构体中数据成员的类型必须相同。有以下程序#include<stdio.h>struct

ball{

char

color[10];

int

dim;};intmain(){

structballlist[2]={{"white",2},{"yellow",3}};

printf("%s:%d",(list+1)->color,list->dim);

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

A:yellow:3B:white:2C:yellow:2D:white:3

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

A:结构体中可以含有指向本结构体的指针成员B:结构体数组名不能作为实参传给函数C:结构体变量的地址不能作