c语言基础知识

判断题

1.函数若无返回值，则它一定无形参。X

2.在C程序中，函数既可以嵌套定义，也可以嵌套调用。X

3.C程序总是从main()函数的第一条语句开始执行的。V

4.同一函数内可以有多个return语句。V

5.main函数中的变量名不可以与其它函数相同。义

6.C程序可由多个函数组成，但必须有并且只有一个主函数main。V

7.在C语言中的每个函数必须要有一个明确的return语句才能返回调用程序。X

8.主函数中定义的变量的作用域仅限于主函数内。V

9.传值调用的形参只有在被调用时，才被创建(分配存储单元)。V

10.C程序执行总是从第一个函数开始。X

11.一个C程序的执行总是从该程序的main函数开始，在main函数最后结束.X

12.被main函数调用的函数只能是库函数。X

13.函数说明指的是在程序中设定一个函数模块。X

14.在C程序中，若对函数类型未加说明，则函数的隐含类型为void。X

15.形参可以是常量、变量或表达式。X

16.函数调用可以作为一个函数的形参。X

17.C语言规定，实参应与其对应的形参类型一致。V

18.定义函数时，形参的类型说明可以放在函数体内。X

19.一个函数可以带回一个整型值、字符值、实型值等，也可以带回指针型的数据。V

20.全局变量可以被任何一个函数中的任何一个表达式使用。X

21.函数的隐含存储类型是extern。V

22.定义在main函数后的任何函数都需在main中进行函数声明。X

23.a是一维数组名,数组元素a[l]还可以写作“*(a++)”°X

24.C语言中数组名是指针常量。J

25.构成数组的各个元素必须具有相同的类型。J

26.数组元素的下标可以选用正整数或正实数。X

27.数组名可以作为参数进行传递。V

28.若有定义“i又a[4][5]；",则在数组元素a[3][3]前有12个元素。X

29.若有定义inta[3][4];则共有12个元素，最后一个元素是a[3][4]。X

30.字符数组中字符串可以整体输入输出。J

31.若有定义语句“charsl[]="abc",s2[]=「"，b,'c'}：",则蛆si和数组s2均有3个

元素。X

32.若a为一维数组名，则*(a+i)与a[i]等价。V

33.函数原型为“voidsort(floata[],intn)”，调用该函数时，形参数组a被创建，实参数组各

元素的值被复制到a数组各元素中。X

34.C允许对数组的大小作动态定义，即可用变量定义数组的大小。X

35.数组定义inta[10];也可以写成inta(10);。X

36.在对全部数组元素赋初值时，可以不指定数组长度。V

37.定义s为5X6(5行6歹I」)的数组可写成floata[5,6];X

38.数组定义inta[10];表示数组名为a,此数组有10个元素，第10个元素为a[10]。X

39.staticcharc[]={'a','','b','o','o','k',、0'};与staticcharc[]={'a'等价。X

40.设已有说明：staticcharcl[10],c2[10];下面程序片段是合法的。cl={"book"};c2=cl;X

41.调用函数时，实参为数组名，则向数组传递的是数组的首地址。V

42.puts。函数的作用是接收从键盘输入的字符串。X

43.两个字符串所包含的字符个数相同时，才能进行字符串的比较。X

44.若有说明：拾12m3]={1,2,3,4,5,6,7};则数组2第一维大小是3。V

45.在C语言中，数组下标从1开始。X

46.若有说明：inta口[4]={{0},{0}}；则二维数组a的第一维大小为1。X

47.在C语言中，数组名是一个不可改变的地址常量，不能对它进行赋值运算。V

48.若有说明：inta[3][4]={0},则只有元素a⑼⑼可得到初值0。X

49.字符串作为一维数组存放在内存中。V

50.若有形参定义：inta[10]；则a++是合法的表达式。X

51.定义数组可以采取以下形式:inta[5];a[l]=l;a[2]=3;a[3]=6;a[4]=7;a[5]=9;X

52.设charx[]="1234”，y[]={T2'3'4'\0'};那么x数组的长度等于y

数组的长度。V

53.'a'和"a”在内存中所占字节相同。X

54.C语言的编译系统对宏命令的处理是在C源程序编译阶段完成的。X

55.预处理命令如：#include<stdio.h>不属于c语言的一部分。X

56.若有宏定义：#defineM(x,y,z)x*y+z则宏引用M(2+3,4+5,6+7)

通过宏展开后的表达式应为(2+3)*(4+5)+(6+7)。X

57.C语言中的宏定义允许嵌套定义，也允许带参数。V

58.宏替换时先求出实参表达式的值，然后代入形参运算求值。X

59.使用带参数的宏时，参数的类型应与宏定义时的一致。X

60.若有宏定义：#definePI3.14i5926,则系统预编译时会报错。V

61.已知宏定义#defineSQ(x)x*x,执行语句printf(u10/SQ(3)=%d",10/SQ(3))；后的输出

结果是10/3*3=1。X

62.形参为指针变量时，实参必须是数组名。X

63.若有定义：inta[5],*p;,使p指向最后一个数组元素a⑷的语句是p=a+4;。V

64.已有定义：inta[5]={1,2,3,4,5},*s=a;,则表达式*(s+3)的值是3。X

65.若有定义：inta[5]={l0,20,30,40,50},*p=%*s=a+2;,表达式s-p的值是2。J

66.在int*p;和语句printf("%d",*p);中的*p含义相同。X

67.设有说明int(*ptr)(int);,则ptr是一个函数名。X

68.位运算赋值有6个，但位运算组成复合的赋值运算符只有5个。V

69.说明：chars[]="world",*p;,执行语句p=s后,*(p+5)的值是‘d'。X

70.结构体类型中各成员项的数据类型可以不同。V

71.在程序中定义了一个结构体类型，将为此类型分配存储空间。X

72.在说明一个结构体变量时系统分配给它的存储空间是该结构体中所有成员所需存储空

间的总和。V

73.若打开文件的方式为“w”而该文件已经存在，则文件中原有数据被清空。V

74.若用fopen()函数打开一个已存在的文本文件，保留该文件原有数据且可以读也可以写，

则文件的打开模式是“r+”。V

75.C文件使用前需要打开，使用后需要关闭。J

76.对文件进行操作的一般步骤包括：打开/建立要操作的文件；对文件进行读写等操作；

关闭被操作的文件。V

77.若fp已正确定义并指向某文件，当未遇到该文件结束标志时函数feof(fp)的值为1。X

78.文件由二进制数据序列组成，C语言只能读写二进制文件。X

79.feof函数只能对二进制文件进行判定。X

80.利用fclose函数关闭己打开的文件。4

选择题

1.下列叙述中，正确的叙述项是(B

A.定义函数时，必须要有形参

B.函数中可以没有return语句，也可以有多条return语句

C.函数f可以用f(f(x))形式调用，这种调用形式是递归调用

D.函数必须有返回值

2.下列叙述中，不正确的叙述项是(D)o

A.函数调用时，形参变量只有在被调用时才被创建(分配存储单元)

B.函数调用时，实参可以是常量、变量或表达式

C.定义变量时，省略对变量的存储类别定义，则变量是自动型变量

D.语句retum(a,b)；则函数可以返回两个值

3.传值调用的特点是(B)。

A.实参传给形参变量的数据是地址

B.在函数中形参变量值改变后，不改变实参变量的值

C.在函数中形参变量值改变后，实参变量的值随之也改变

D.实参必须是变量

4.如果在函数中定义一个变量,有关该变量作用域正确的是(A)。

A.只在该函数中有效B.在该文件中有效

C.在本程序中有效D.为非法变量

5.根据下面函数print的定义，选出调用函数print(5378)的值是(A)

voidprint(longn)

{if(n==0)return;

else{

print(n/10);

printf(M%d”，n%10);

return;}

)

A.5378B.8735

C.3578D.8753

6.根据下面函数f,选出f(f(3))的值是(C)。

intf(intx)

{staticintk=0;

x=x+k;

k-;

returnx;

)

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

7.以下说法中正确的是(C)o

A.C程序总是从第一个函数开始执行

B.C程序中，函数最多不能超过2个

C.C程序总是从main()函数开始执行

D.C程序的main()函数必须放在程序的最前面

8.以下函数调用语句中实参的个数为(D)。

aver((v1,v2),(v3,v4,v5),v6);

A.6B.5C.4D.3

9.下列程序的输出结果是(D

fun(inta,intb,intc)

{c=a*b;}

main()

{intc;

fun(2,3,c);

printf(n%d\n';c);

)

A.0B.1C.6D.无法确定

10.执行下列程序后的输出结果是(A)。

#include<stdio.h>

charf(chars[],intn)

{return(s[nj);}

main()

{chara[]="ABCDH;

printf(H%c,',f(a,2)+1);

)

A.DB.CC.BD.A

11.对于以下递归函数f(),调用f(4),其返回值为(A)o

intf(intn)

{if(n)returnf(n-l)+n;

elsereturnn;

)

A.10B.4C.0D.以上均不是

12.下列能正确定义一维数组a的语句是(D)。

A.inta(10);B.intn=I0,a[n]；

C.intn；scanf("％d”,&n)；D.#definen10

inta[n]；inta[n]；

13.若有定义语句则下列对a中数组元素正确引用的是(A)。

A.a[10/2-5]B.a[10]C.a[4.5]D.a(1)

14.能对一维数组正确初始化的语句是(A)o

A.inta[6]={6*l)B.inta[6]={1,„3}

C.inta[6]={}D.inta[6]=(0,0,0)

15.以下能正确定义二维数组的语句为(D)o

A.inta[][]；B.inta[][4]；C.inta[3][]；D.inta[3][4]；

16.若有数组定义语句“inta[4][5]；"，则对a中数组元素的正确引用是(D)。

A.a[4][l]B.a[2,1]C,a[4][5]D.a[4-l][5-5]

17.下列各语句定义数组，其中不正确的是(C)。

A.chara[3][10]={"China1',"American''/^sia"}；B.intx⑵⑵={1,2};

C.floatx[2][]={1,2,4,6,8,10};D.intm[][3]={1,2,34,5,6};

18.数组定义为inta[3][2]={1,2,3,4,5,6},下列表述中正确的是(D)。

A.a[3]⑵的值为6B.a[6]的值为6

C.a[0]的值为1D.a[2][l]的值为6

19.以下能对二维数组a进行正确初始化的语句为（D）o

A.inta[2][]={{1},{4,5}}；B.inta[2][3]={l,2,3,4,5,6,7}；

C.inta[][]={l,2,3,4,5,6}；D.inta[][3]={l,2,3,4,5}；

20.下列对字符数组s的初始化不正确的是(C)o

A.chars[5]="abcn；B.chars[5]={'a,,'b','c\d,'e"}；

C.chars[5]=(,abcdeM；D.chars[]=,,abcdeH；

21.下列程序段的运行结果为(B)o

chars[]=,'ab\0cdn;printf("%sM,s);

A.abOB.abC.AbedD.abcd

22.下列数组s中所存放字符串的长度为(C)o

chars[]=Ha\128b\\\tcd\xdg\n";

A.9B.10C.11D.18

23.有数组定义语句“chara[20]；”，则正确的输入语句为(D)。

A.scanf("％s”,&a)；B.scanf(n%sn,a[])；

C.gets(a[20])；D.gets(a)；

24.若有inta[10]={1,2,3,4,5,6,7,8,9,10);

则数值为6的表达式是(C)o

A.a[0]B.a[6]C.a[0]+5D.a[l]+5

25.下面程序执行后的正确输出项是(A)o

#include<stdio.h>

voidswap1(inta[])

{intt;

t=a[O];a[0]=a[l];a[l]=t;

)

voidswap2(inta,intb)

{intt;

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

)

voidmain()

{intx⑵={1,5};

inty[2]={l,5};

swapl(x);

swap2(y[0],y[l]);

printf(nx:%d%d\nM,x[0],x[U)；

printf("y:%d%d\nM,y[O],y[l]);

)

A.x：51B.x：15C.x：15D.x：51

y：15y：51y：15y：51

26.有以下程序

main()

{chara[7]=,,a0\0a0\0,,;inti,j;

i=sizeof(a);j=strlen(a);

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

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

A.22B.76C.72D.62

27.执行下列程序后的输出结果是(D)。

#include<stdio.h>

intf(inta[],intn)

{if(n==O)returna[0|;

elsereturnf(a,n-l)+a[n];

)

main()

{intx[]={1,3,579};

printf(n%d\nn,f(x,3))；

)

A.1B.4C.9D.16

28.下面对数组定义正确的是(D)o

A.inta[];B.intn=5,a[n];C.intn,a[n]={1,2,3,4,5};D.int

a[10/2];

29.设有语句"inta[]={1,2,3,9,8,7};",则表达式"a⑵-a[4]"的值是(C)。

A.-2B.-4C.-5D.-7

30.数组定义为则数组a有(D)个数组元素。

A.12B.144C.100D.121

31.以下能正确定义二维数组的是(B)。

A.inta[][3];B.inta[][3]={{2},{2*3}};C.inta[][3]={};D.inta⑵[3]={{1},{2},{3,4}};

32.若有以下说明和语句，则输出结果是(B)。

charsp||="\t\v\\\0will\n";

printf("%d",strlen(sp));

A.14B.3C.9D.字符串中有非法字符

33.若有以下说明和语句，则输出结果是(C

charstr[]="\"c:\\abc.dat\"";printf("%s",str);

A.字符串中有非法字符B.\"c:\\abc.dat\"C."c:\abc.dat"D."c:\\abc.dat"

34.设有定义语句chars[4]="abc";,则表达式s[3]的值是(B3

A.未知字符B.0C.'O'D.'c'

35.设变量定义为charformat口="s=%d\n";，则数组format元素的个数为(C设

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

36.函数调用"strcmp("123","321")的返回值是(D

A.OB.1C.任意正整数D.负整数

37.下列宏定义命令中，哪一个格式是正确的(D)。

A.#definepi=3.14l59；B.definepi=3.14159

C.#definepi="3.14159"D.#definepi(3.14159)

38.宏定义为“#definediv(x,y)3y；”,若语句“printf("div(x,y)=%d\n",div(x+3,y-

3))；”作宏替换后为(C)o

A.printf("x/y=%d\n".(x+3)/(y—3))；B.printf("x/y=%d\n",x+3/y—3)；

C.printf("div(x,y)=%d\n".x+3/y—3；)；D.printf("x/y=%d\n",x+3/y—3；)；

39.程序中调用了库函数exit,必须包含头文件(B

A.string.hB.stdlib.hC.ctype.hD.math.h

40.已知宏定义

#defineN3

#defineY(n)((N+l)*n)

执行语句z=2*(N+Y(5+l));后,变量z的值是（B)o

A.42B.48C.52D.出错

41.下列程序段的输出结果是(D)o

#defineM(x,y)x/y

printf("％d"，M(10,2+3));

A.2B.2.0C.5D.8

42.执行下列程序段后变量i的值应为(B)o

#defineMA(x,y)(x*y)

i=5；

i=MA(i,i+l)-7;

A.30B.19C.23D.1

43.下面程序的运行结果是(B)o

#definePS3+4

#include<stdio.h>

voidmain()

{intz;

z=PS*2;

printf(n%dn,z);

A.14B.11C.2D.24

44.对于以下变量定义，（D）是正确的赋值。

int*p[3],a[3];

A.p=aB.*p=a[0]C.p=&a[0]D.p[0]=&a[0]

45.下列语句定义p为指向float型变量d的指针，其中正确的是（C）o

A.floatd,*p=d；B.float*p=&d,d；

C.floatd,*p=&d；D.floatd,p=d；

46.指针变量pl、p2类型相同，要使p2、pl指向同一变量，哪一个语句是正确的（A）。

A.p2=*&pl；B.p2=**pl；C.p2=&p1；D.p2=*pl；

47.若有“floata=1.5,b=3.5,*pa=&a；*pa*=3；pa=&b；"，则正确的是（C）。

A.pa的值是1.5B.*pa的值是4.5

C.*pa的值是3.5D.pa的值是3.5

48.数组定义为"inta[4][5]；,\下列哪一个引用是错误的（D）。

A.*aB.*(*(a+2)+3)C.&a[2][3]D.++a

49.表达式“c=*p++”的执行过程是（A)»

A.复制*p的值给c后再执行p++B.复制*p的值给C后再执行（*p）++

C.复制p的值给c后再执行p++D.执行p++后将*p的值复制给c

50.若已定义intx,*p;则以下正确的赋值表达式是（A）o

A.p=&xB.p=xC.*p=&xD.*p=*x

51.下面程序输出结果是（B）o

#include<stdio.h>

voidmain()

{intx=4,y=7,*px=&x,*py=&y;

*py=*px;

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

A.7,7B.4,4C.4,7D.7,4

52.声明语句为^chars[4][15]>*pl,**p2；intx,*y；”,下列语句中正确的是(D)。

A.p2=s；B.y=*s；C.*p2=s；D.y=&x；

53.定义函数int*max()的正确含义是(B

A.返回整型值的函数

B.返回指向整型变量的指针

C.返回指向函数max()的指针

D.上面的叙述都不正确。

54.若有定义“int(*ptr)(float)；”，其正确的含义是(C若

A.ptr是指向一维数组的指针变量

B.ptr是指向int型数据的指针变量

C.ptr是指向函数的指针变量，该函数有一个float型参数，返回值是整型

D.ptr是一个函数名，该函数的返回值是指向int型数据的指针

55.指出正确的程序是(程序(2))。

程序(1)程序(2)

#include<stdio.h>#include<stdio.h>

voidmain()voidmain()

ff

\i

char*p;chars[80];doublex,y,*p;

P=s|0];x=3.45;p=&x;y=*p;

scanf(n%sn,s);printf(H%f\nM,y);

printf(n%s\nn,p);

))

程序(3)程序(4)

#include<stdio.h>#include<stdio.h>

voidmain()voidmain()

((

intx,*p;int*p=&a;

*p=x;inta;

printf(n%d\n",*p);printf("%d\n",*p);

))

56.下面程序的输出结果是(B)o

voidmain()

|

inta[12]={l,2,3,4,5,6,7,8,9,10,ll,12},*p[4],i;

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

p[i]=a+i*3;//或p[i]=&a[i*3];

printf("%d",*(p[3]+2));//或printf("%d",p[3][2]);

）

A.8B.12C.6D.程序有错

57.变量的指针，其含义是指该变量的（B）。

A.值B.地址C.名D.一个标志

58.设变量定义为“intx,*p=&x;",则&*p相当于（A）.

A.pB.*pC.xD.*&x

59.若变量已正确定义，（A）不能使指针p成为空指针。

A.p=EOFB.p=0C.p='\0'D.p=NULL

60.对于类型相同的指针变量，不能进行（A）运算。

A.+B.-C.=D.==

61.设有指针变量p已指向float型变量x,正确的输入语句是（C）o

A.scanf（n%fn,x）;B.scanf（n%dn,&x）;C.scanf（M%f',p）;D.scanf（M%f',*p）;

62.执行下列程序段，输出结果（D）。

intm=5,n=25,*ql,*q2=&n,;

ql=&m;

q2=ql；

printf(n%d%d",*ql,*q2);

A.&m&m;B.2525C.255D.55

63.下面程序执行后输出是（B）。

#include<stdio.h>

voidmain()

{intk=4,*pl=&k;

if(*pl==k)printf(,'%d',,l);

elseprintf(M%dH,0);

)

A.4B.1C.0D.运行时出错

64.设有定义语句shortx=12;假定分配给x的内存地址是OxfTOO和OxfTOl,则在程序中能表

示变量x地址的表达式是(A)。

A.&xB.&12C.ffOOD.ffDl

65.设有定义语句inta,*pa二&a;和赋值语句*pa=a;,则下列说法正确的是（A）。

A.定义语句中的“*pa=&a”表示将a的地址赋给pa

B.定义语句中的“*pa=&a”表示将a的值赋给pa

C.赋值语句中的“*pa二a”表示将a的地址赋给pa

D.赋值语句中的“*pa二a”表示将a的值赋给pa

66.已有定义intk=2,*pl=&k,*p2=&k;下面不能正确执行的赋值语句是（B）。

A.k=*pl+*p2;B.p2=k;C.pl=p2;D.k=*pl*（*p2）;

67.若有语句int*p,a=4^lp=&a;下面均代表地址的一组选项是（D）。

A.a,p,*&aB.&*a,&a,*pC.*&p,*p,&aD.&a,&*p,p

68.若有定义：int*p,m=5,n;以下正确的程序段是（D）。

A.p=&n;scanf（"%dn,&p）;B.p=&n;scanf（n%d",*p）;

C.scanf（n%dM,&n）;*p=n;D.p=&n;*p=m;

69.指出函数abc的作用是（D）o

voidabc（char*s,char*t）

{while(*t++);

while(*t++=*s++);//注：是单等号

）

A.求字符串长度B.将字符串t复制到字符串s中

C.比较字符串大小D.将字符串t连接到字符串s的尾部

70.若有定义：int*pl,*p2,m=5,n;以下均是正确赋值语句的选项是（C）。

A.pl=&m;p2=&pl;B.pl=&m;*pl=*p2;

C.pl=&m;p2=pl;D.pl=&m;*p2=*pl;

71.声明语句为，下列表达式中与数组元素等价的是（A）。

A.*(a[2]+l)B.a[9]C.*(a[l]+2)D.*(*(a+2))+l

72.已有变量定义和函数调用语句：inta=25;print_value(&a);下面函数的正确输出结果是

(D)o

voidprint_value(int*x)

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

A.32B.24C.25D.26

73.下面程序的输出是(B)

#include"stdio.h"

voidfun(int*a,intb)

{*a=13;b*=5;

return;}

voidmain()

{intx=12,y=12;

fun(&x,y);

printfCtx=%d,y=%d\n,,,x,y);}

A.x=12,y=12B.x=13,y=12C.x=13,y=60D.x=12,y=60

74.inta[]={1,2,3},*p,*q；

p=a+l;

q=p++；

执行该程序段后，p和q所指向的单元的内容分别为(C)。

A.(*p)=1,(*q)=2B.(*p)=2,(*q)=3

C.(*p)=3,(*q)=2D.以上都错

75.和定义语句char*a="ccw”;功能完全相同的程序段是(C

A.char*a,a="ccwH;B.char*a;*a=,,ccw";C.char*a;a=,,ccw";D.char*a,*a=',ccwn;

76.下列程序段的输出结果是(D)o

intt,a[3]={10,5,1};

int*p;

for(p=a;p<a+3;p++)

t=t+*p;

printf(H%d';t);

A.15B.16

C.10D.不确定

77.设有定义语句intx[]={1,2,3},*p=x;则结果不是地址值的表达式是(C)。

A.p+1B.xC.*pD.&x[0]

78.执行下列程序段后，变量y的值为（D）。

intx[]={l,2,3,4),y,*p=&x[l];

y=(*-p)++；

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

79.设有定义语句inta[]={1,2,3,4,5,6,7,8,9,10},*p=a;则结果为8的表达式是（D）。

A.p+7B.*p+8C.*(p+8)D.*p+=7

80.设变量定义为：int*p[3],a[3];,（C）是正确的赋值。

81.A.p=&a[0]B.*p=**a

82.C.p[0]=aD.**p=a

83.执行下列程序段后，m的值为（D）。

inta[2][3]={{l,2,3},{4,5,6});

intm,*p;

p=&a[0][0];

m=(*p)*(*(p+2))*(*(p+4));

A.12B.13C.14D.15

84.运行下列程序的输出结果是（C）。

#include<stdio.h>

main()

{inti;

chara[20]=Ml23456",*p;

for(p=&a[5];p>=a;p—)

printf(',%c,,*p);

)

A.135B.246C.654321D.123456

85.运行下列程序的输出结果是（A）o

#include<stdio.h>

main()

{char*p=u13542";

while(*p!='4')

printf(,'%c,',*(p4-+)+l);

)

A.246B.135C.152D.13542

86.不正确的赋值或赋初值的方式是（D）o

A.charstr[6]={'s't'r'i'n'g，}；

B.charstr[10]=,>string”；

C.char*str=wstringn;

D.charstr[10];str=,,string”；

87.如下程序段，其输出应为（B）o

intc[]={l,7,12);

int*k;

k=c;

printf(',%d,,,*++k);

A.2B.7C.1D.以上均不对

88.调用f（“1234”）的返回结果是（B）,,

intf(char*s)

{intk=0;

while(*s)k=k*10+*s++-'0‘；

return(k);

}

A.”1234”B.1234C."4321D.4321

89.以下程序运行后的输出结果是(B)。

main()

{chars[]=,,Yes\n/No,',*ps=s;

printf("％s”，ps+4);

*(ps+4)=0;

puts(s);

)

A.n/No/NoB./NoYesC.n/NOYesD.YesYesYes/No

90.设有定义:charstr[]=UABCD,\*p=str；则语句printf("%d\n"，*(p+4))；的输出结

果是(B)o

A.68B.0C.字符d的地址D.不确定的值

91.下面程序执行后a的值是(B)。

#includeHstdio.hn

voidmain()

{inta,k=4,m=6,*pl=&k,*p2=&m;

a=pl!=&m;

printf(n%d\nM,a);

)

A.4B.1C.0D.运行时出错,a无定值

92.语句：printf(printf("％d\n”,sMen("ATS\nO12\l\\”)));的输出结果是(C)。

A)llB)10C)9D)8

93.以下程序段输出字符串str,其中循环条件str[i]!='0'还可以写成(A)。

charstr[80];

for(i=0;str[i]!='W;i++)

putchar(str[i]);

A.str[i]!=NULLB.i<80

C.!(str[i]=W)D.i<=80

94.设变量定义为：intn,*p;charch,*q,*g;,则语句(D)是不正确的。

A.p=&n;g=q=&ch;B.p=&n;q=&ch;

C.p=&n;g=&ch;D.p=&n;q=&ch;g=p；

95.下列数据定义语句中，正确的是(B)。

A.charc[2],*p=c[l];B.charc,*p=&c;C.float*p=&a,a=5;D.floatbl,p=&bl;

96.设有charstr[100];inti=5;则引用数组元素的错误形式是(A)。

A.*((str++)+i)B.*(str+i-l)C.*(str+i)D.str[i+10]

97.设有定义语句inta⑶[4],*p=a[0];则下列表达式中，不能代表合法数组元素的是(D)。

A.**aB.*(a[2]+1)C.*(p+2*4+l)D.*(*(p+2)+l)

98.下列程序段的输出结果是(B)o

char*st[]={"SUNM,"MOON",nSTAR",nXn};

printf(u(%s,%c)M,*(st+l)+l,*(*(st+2)+2)+2);

A.(MOON,M)B.(OON,C)C.(OON,Q)D.(OON,A)

99.已有定义：inti,a[10],*p;,则合法的赋值语句是（D

A.p=100;B.p=a[5];C.p=a[2]+2;D.p=a+2;

100.以下程序运行后的输出结果是(D

main()

{chars[]=HABCD",*p;

for(p=s+l;p<s+4;p++)printf(n%s\nH,p);

A.ABCDB.AC.BD.BCD

BCDBCCD

CDCDD

10L有定义：char*p[10];,则p是一个（D）。

A.函数名B.指针变量C.数组元素D.数组名

102.S12和s2已正确定义并分别指向两个字符串。若要求：当si所指串大于s2所指串时,

执行语句S;则以下选项中正确的是（D）。

A.if(sl>s2)S;B.if(strcmp(sl,s2))S;

C.if(strcmp(s2,s1)>0)S;D.if(strcmp(s1,s2)>0)S;

103.设有定义语句

intx[6]={2,4,6,8,5,7),*p=x,i;

要求依次输出x数组6个元素中的值，不能完成此操作的语句是(D)o

A.for(i=0;i<6;i++)printf(n%2d",*(p++));

B.for(i=0;i<6;i++)printf(M%2dH,*(p+i));

C.for(i=0;i<6;i++)printf("%2d”,*p++);

D.for(i=0;i<6;i++)printf(,,%2d",(*p)++);

104.有以下的结构变量定义语句：

structstudent{intnum;charname[9];}stu;

则下列叙述中错误的是(B)。

A.结构类型名为studentB.结构类型名为stu

C.num是结构成员名D.struct是C的关键字

105.设变量定义如下，则对其中的结构分量num正确的引用是(A),

structstudent{

intnum;

charname[20];

floatscore;

}stud[10];

A.stud[l].num=10;B.student.stud.num=10;

C.struct.stud.num=10;D・structstudent.num=10;

106.对于以下的变量定义，语句(B)在语法和语义上都是正确的。

structnode{

floatx,y;

chars[10];

}point={1,2,''abc''},*p；

A.*p=point;B.p=&point;

C.point=p;D.p->x=point.y;

107.设变量定义如下，则表达式(D)是正确的。

structstudent{

intnum;

charname[20];

floatscore;

}stud[10];

A.stud[2]=stud[l]+3B.studfl]==stud[2]

C.stud[l]=stud[l]-stud[2]D.stud[l]=stud[2]

108.有以下的定义语句：

structstudent{intnum;charname[9];};

则不能正确定义结构数组并赋初始值的是（C）o

A.structstudentstu[2]={L"zhangsan",2,"lisi"};

B.structstudentstu[2]={{1,"zhangsan"},{2,“lisi"}};

C.structstu[2]={{1,"zhangsan"),{2,"lisi"}}；

D.structstudentstu[]={{L"zhangsan”},{2,“lisi"}};

109.若有以下定义语句：

structdate{inty,m,d;};

structstudent

{intnum;charname[9];structdatebir;}stu,*p=&stu;

则以下对结构变量stu成员的引用错误的是(A)o

A.p->bir->yB.p->bir.yC.stu.bir.yD.

110.若结构体定义如下，则下面正确的项是(C)