C语言程序设计-期末综合练习题

题库整体描述

亲爱的同学，

您好、在学完C语言程序设计后，请您完成以下练习题。

提示：单项选择题10道，每题2分，共20分；13道填空题,

每题2分，共26分；5道看程序写结果题，每题6分，共30分；2

道写出函数功能题，每题6分，共12分；2题编写程序或函数题，

每题6分，共12分，所有题目满分为100分。

您可以选择每小题做完后提交，客观题会有问答正误判断和知识

点提示，主观题则会提示参考答案。也可以选择全部做完后'提交所

有答案并结束”，查看本次练习客观题总成绩。

所有题目都可乂反复练习，直到你熟练掌握为止。

1

#include<stdio.h>

intWF(intx,inty){

x=x+y;

y=x+y;

returnx+y;

voidmain(){

intx=5,y=7;

intz=WF(xzy);

printf("z=%d\n"zz);

}

1

doubleSF(doublex,intn){//n为正整数

doublep=lzs=l;

inti;

fo「(i=l;iv=n;i++){

p*=x;

s+=p；

}

returns;

}

1

#include<stdio.h>

structWorker(

charname[15];〃姓名

intage;〃年龄

floatpay;〃工资

}；

voidmain(){

structWorkerx={"wanghua,,52,4300};

structWorkery,*p;

y=x;p=&x;

printf("%s%d%6.2f\n",zy.agezp->pay);

1

voidQA(structWorkera口，intn){

inti;

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

n

scanf("%s%d%f,&a[i].namez&a[i].agez&a[i].p

ay);

)

假定结构类型structWorker的定义如下：

structWorker{charname[15];intage;floatpay;};

1

#include<stdio.h>

voidmain()

{

intx=5;

switch(2*x-3){

case4:printf("%d

case7;pnntf("%d”,2*x+l);

case10:printf("%dn,3*x-l);break;

default:printf("%s，7，default\nn);

}

}

1

编写一个函数，函数头格式为''doubleMean(doublea[M][N],int

m,intn)”,要求返回二维数组矶m][n]中所有元素的平均值，假定

在计算过程中采用变量v存放平均值。

2

intSG(intx){//x为大于等于2的整数

inti=2;

while(i*i<=x){

if(x%i==O)break;

i++；

}

if(i*i<=x)return0;elsereturn1;

}

2

#include<stdio.h>

#include<string.h>

voidfun(charss[]);

voidmain(){

chars[15]=n0123456789";

fun(s);

printf("%s\n"zs);

}

voidfun(charss[]){

inti,n=strlen(ss);

for(i=0;i<n/2;i++){

charc=ss[i];

ss[i]=ss[n-l-i];

ss[n-l-i]=c;

}

}

2

#include<stdio.h>

#include<string.h>

structWorker{

charname[15];〃姓名

intage;〃年龄

floatpay;〃工资

}；

voidmain(){

structWorkerx;

char*t="liouting";

intd=38;floatf=3493;

strcpy(,t);

x.age=d;x,pay=f;

printf("%s%d%6.0f\n",x.age,x.pay);

}

2

intCount(structIntNode*f)

{//f为指向一个单链表的表头指针

intc=0;

while(f){

C++；

f=f->next;

}

returnc;

}

假定structIntNode的类型定义为:

structIntNode{intdata;IntNode*next;};

2

编写一个递归函数''intFF(inta口，intn)”,求出数组a中所有n个

元素之积并返回。

3

#include<stdio.h>

intCount(inta[],intn,intx)

{

inti,c=0;

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

if(a[i]>x)C++;

returnc;

}

voidmain(){

int3网={20,15,32,47,24,36,28,70};

intb=Count(az8,30);

printf("b=%d\n"zb);

}

3

intWB(inta[],intn,intx){

for(inti=O;i<n;i++)

if(a[i]==x)return1;

return0;

)

3

#include<stdio.h>

structWorker(charname[15];intage;floatpay;};

intLess(structWorkerrl,structWorkerr2){

if(rl.age<r2.age)return1;elsereturn0;

voidmain(){

structWorker

a[4]={{"abc",25,2420},{"def",58,4638},

,

{"ghi",49,4260}/{"jkr,36,3750}};

structWorkerx=a[0];

inti;

for(i=l;iv4;i十十)

if(Less(x,a[i]))x=a[i];

printf("%s%d%6.0f\n",zx.agezx.pay);

)

3

voidxwl(char*fname){

FILE*fout=fopen(fname,"w");

chara[20];

printf("每个字符串长度小于20,字符串end作为结束标

志\n“)；

while(l){

scanf("%s"za);

if(strcmp(a,"end")==O)break;

fputs(a,fout);

fputc('\n',fout);

}

fclose(fout);

}

3

编写一个主函数，利用while循环，求出并显示满足不等式的最小n

值。

4

#include<stdio.h>

voidmain(){

inta[8]={3,5,7,9,2,3,4,8};

ints=Oz*p;

for(p=a;p<a+8;)s+=*p++;

printf("s=%d\n",s);

}

4

intfun(intmzintn){

intc=0;

staticintb=2;

if(m<b11n<b)returnm*n;

elseif(m%b==O&&n%b==O){c=b;return

c*fun(m/bzn/b);}

else{b++;returnfun(mzn);}

)

4

编写一个主函数，求出满足不等式22+42+…+n2〈1000的最大n

值，假定分别用i和s作为取偶数值和累加值的变量，并限定使用do

循环编程。

5

#include<stdio.h>

intLA(int*azintn,intx){

intizs=0;

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

if(a[i]<x)s+=a[i];

returns;

}

voidmain(){

inta[8]={5,10,15,8,12,3,9,20);

intb=LA(a,5,10);

intc=LA(a+2,6,10);

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

}

5

intLK(doublea[],intn){

doubles=0;

inti,m=0;

for(i=0;i<n;i+4-)s+=a[i];

s/=n;

for(i=0;ivn;i++)

if(a[i]>=s)m++;

returnm;

}

5

编写一个主函数，计算并输出M+22+…值，其中n值由键盘输

入。

写出函数的功能

intFH(){

intx,y=O;

scanf("%d",&x);

while(x!=-l){y+=x;scanf("%d",&x);}

returny;

)

函数功能：

写出函数的功能

intFF(structIntNode*f)〃f为指向一个单链表的表头指针

{

intn=0;

if(!f)return0;

while(f){

n++;

f=f->next;

}

returnn;

}

假定structIntNode的类型定义为：

structIntNode{intdata;structIntNode*next;};

函数功能：

写出函数的功能

#include<stdio.h>

intSA(intazintb){

if(a>b)return1;

elseif(a==b)return0;

elsereturn-1;

函数功能:

写出函数的功能

voidOutput(structIntNode*f)〃f为单链表的表头指针

{

if(!f)return;

while(f){

printf("%dH,f->data);

f=f->next;

}

printf("\n");

}

假定structIntNode的类型定义为：

structIntNode{intdata;structIntNode*next;};

函数功能：

写出函数的功能

intSC(inta,intb,intc){

if(a>=b&&a>=c)returna;

if(b>=a&&b>=c)returnb;

returnc;

}

写出函数的功能

int*LI(intn){

int*a=malloc(n*sizeof(int));

inti;

for(i=0;i<n;i++)scanf("％d\a+i);

returna;

)

写出函数的功能

#include<math.h>

intSG(intx){//x为大于等于2的整数

inta=(int)sqrt(x);〃sqrt(x)取x的平方根

inti=2;

while(i<=a){

if(x%i==O)break;

i++；

}

if(i<=a)return0;elsereturn1;

}

函数功能：

写出函数的功能

intFindMax(structIntNode*f)//f为一个单链表的表头指针

intx;

if(!f){printf(“单链表为空\n”),exit(l);}

x=f->data;

f=f->next;

while(f){

if(f->data>x)x=f->data;

f=f->next;

}

returnx;

}

假定structIntNode的类型定义为：

structIntNode{intdata;structIntNode*next;};

函数功能：

写出函数的功能

intWC(inta[],intn,intk){

inti,c=0;

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

if(a[i]>=k)C++;

returnc;

}

函数功能：

写出函数的功能

voidQA(structWorkera[]zintn)

{

inti;

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

scanf("%s%d%f"，a[i].namez&a[i].agez

&a[i].pay);

?

假定结构类型structWorker的定义如下：

structWorker{charname[15];intage;floatpay;};

函数功能：

写出程序运行后的输出结果

#include<stdio.h>

voidmain(){

inti,s=0;

for(i=l;;i++){

if(s>20)break;

if(i%2)s+=i;

}

printf("s=%d\n"zs);

写出程序运行后的输出结果

#include<stdio.h>

voidmain(){

inta[9]={36z25,48,24,55,40,18,30,20};

inti,blzb2;

bl=b2=a[0];

for(i=l;i<9;i++){

if(a[i]>bl)bl=a[i];

if(a[i]<b2)b2=a[i];

}

printf("%d%d\n”,bl,b2);

}

写出程序运行后的输出结果

#include<stdio.h>

voidSB(charch){

switch(ch){

case'A':case'a':

printf("WW")；break;

case'B':case'b':

printf(HGG");break;

default:

printf("BB");break;

}

}

voidmain(){

charal='a,,a2=,B',a3='f';

SB(al);SB(a2);SB(a3);

printf("\n");

}

写出程序运行后的输出结果

#include<stdio.h>

voidmain(){

inti,sl=0,s2=0;

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

if(i%2)sl+=i;

elses2+=i;

printf("%d%d\n"zsl,s2);

}

写出程序运行后的输出结果

#include<stdio.h>

constintM=20;

voidmain()

{

inti=2;

while(l){

if(i>M/2)break;

if(M%i==O)printf("%d",i);

i++；

}

printf(n\nn);

)

写出程序运行后的输出结果

#include<stdio.h>

inta[7]={4,5,6,15,20,62,9};

voidmain()

{

inti,sl,s2;

sl=s2=0;

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

switch(a[i]%2){

case0:s2+=a[i];break;

case1:sl+=a[i];break;

}

}

printf("%d%d\n"zslzs2);

)

写出程序运行后的输出结果

#include<stdio.h>

voidmain(){

inta[3][3]={{3z15z7}z{9,ll,10},{6z8z20}};

inti,*p=&a[0][0];

fo「(i=0;iv9;i++){

if(*p>10)printf("%d”产p);

P++；

)

printf("\n")；

}

写出程序运行后的输出结果

#include<stdio.h>

#include<string.h>

structWorker{charname[15];intage;floatpay;};

voidmain(){

structWorkerx;

char*t="liouting";

intd=38;floatf=2400;

strcpy(x,name,t);

x.age=d;x.pay=f;

x.age++;x.pay*=2;

printf("%s%d%6.2f\n",,x.age,x.pay);

写出程序运行后的输出结果

#include<stdio.h>

#defineM6

voidmain()

{

inti,x;

inta[M]={10,15,22,37,46,58};

for(i=0;i<M/2;i++){x=a[i];a[i]=a[M-l-i];

a[M-l-i]=x;}

printf("%d%d\n",a[2]za[4]);

)

写出程序运行后的输出结果

#include<stdio.h>

structWorker{

charname[15];intage;floatpay;

}；

voidmain(){

,

structWorkerx={"wanghua',34z4250};

structWorkery,*p;

y=x;p=&x;

printf("%d%7.2f\n"zy.age+p->age,

p->pay+300);

}

写出程序运行后的输出结果

#include<stdio.h>

voidmain(){

intn=6,y=l;

while(n—)y+=3+n;

n

printf("y=%d\nzy);

)

写出程序运行后的输出结果

#include<stdio.h>

voidmain(){

intfl,f2J;

fl=l;

printf(H%dn,fl);

for(i=2;iv5;i++){

f2=3*fl+i;

n

printf("%dzf2);

fl=f2;

}

printfC'Xn")；

}

写出程序运行后的输出结果

#include<stdio.h>

#defineN8

voidmain(){

inta[N]={12,39,26,41,55,63,72,40};

inti,il=0,i2=0;

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

if(a[i]%2==l)il++;elsei2++;

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

}

写出程序运行后的输出结果

#include<stdio.h>

#include<string.h>

voidmain(){

chars[15]="5678912340";

inti,n=strlen(s);

for(i=0;i<n/2;i++){

charc=s[i];

s[i]=s[n-l-i];

s[n-l-i]=c;

}

printf("%s\n"zs);

}

写出程序运行后的输出结果

#include<stdio.h>

intLB(int*azintn){

inti,s=l;

for(i=0;ivn;i++)s*=*a++;

returns;

}

voidmain(){

intd[]={l,2,3,4,2,2,5,8};

intb=LB(a,4)+LB(a+3,4);

printf("b=%d\n",b);

}

写出程序运行后的输出结果

#include<stdio.h>

voidmain()

{

inti,s=0;

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

if(i%3==0||i%4==0)s+=i;

printf("s=%d\n"zs);

}

写出程序运行后的输出结果

#include<stdio.h>

voidmain(){

chara[]="abcfkgamd";

intil=Ozi2=0,i=0;

while(a[i]){

if(a[i]<'e')il++;elsei2++;

i++;

}

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

}

写出程序运行后的输出结果

#include<stdio.h>

voidmain(){

inta[9]={2,4,8,12,16,20,24,28,32);

int*p=a;

do{

printf("%d"产p);

P+=3；

}while(p<a+9);

printf(n\nn);

}

写出程序运行后的输出结果

#include<stdio.h>

voidmain()

{

intx=5;

switch(2*x){

case4:printf("%dn,x);break;

case7:printf("%d",2*x);break;

H

case10:printf("%dz3*x);break;

default:printf("%s"/'default");

}

printf("%d\n',,4*x);

写出程序运行后的输出结果

#include<stdio.h>

structWorker{charname[15];intage;doublepay;};

voidmain(){

structWorker

a[4]={{"abc",20,2400},{"defa"z50,3600},

H

{"ghin",40z2500}z{"jkltz36z3200}};

inti,s=0;

for(i=0;i<4;i++)s+=a[i].age;

printf("s=%5.2Lf\n"z(double)s/4);

}

写出程序运行后的输出结果

#include<stdio.h>

voidmain(){

inti,s=0;

for(i=l;i<7;i++)s+=i*i;

,,

printf(''s=%d\nzs);

}

写出程序运行后的输出结果

#include<stdio.h>

#include<string.h>

voidmain(){

inti;

unsignedintlen;

char*

nnnn

a[5]={stud"/work"/"cadre"zsoldier"zzanl23"};

len=strlen(a[O]);

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

if(strlen(a[i])>len)len=strlen(a[i]);

printf("％d\n，len);

)

写出程序运行后的输出结果

#include<stdio.h>

voidmain()

{

inta,b;

for(a=2,b=3;b<30;){

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

a=a+b;

b=a+b;

}

}

写出程序运行后的输出结果

#include<stdio.h>

#defineN6

voidmain()

{

intiza[N]={2,5,8,10,15,20};

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

if(a[i]%4==0)printf("%d",a[i]);

printf("\n");

}

写出程序运行后的输出结果

#include<stdio.h>

voidLE(int*a,int*b){

intx=*a;

*a=*b;*b=x;

}

voidmain(){

intx=5,y=8;

n

printf("%d%dzxzy);

LE(&x,&y);

printf("%d%d\n"zxzy);

}

写出程序运行后的输出结果

#include<stdio.h>

voidmain(){

inti,j,k=O;

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

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

printf("％d\n”,k);

}

写出程序运行后的输出结果

#include<stdio.h>

voidmain(){

intx=28;

inti=2;

while(i<x){

if(x%i==O){printf("%d",i);x/=i;}

i++；

}

printf("%d\n"zx);

}

写出程序运行后的输出结果

#include<stdio.h>

voidmain(){

inta[8]={76,63,54,95,40,75,90,82};

inti,s=0;

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

if(a[i]>=70&&a[i]<=85)s+=a[i];

printf("s=%d\n"<s);

}

写出程序运行后的输出结果

#include<stdio.h>

intWF(intx,inty){

x=x+y;

y+=x；

returnx+y;

}

voidmain(){

intx=5,y=8;

H

printf("%d\n,WF(xzy));

)

写出程序运行后的输出结果

#include<stdio.h>

intLA(int*a,intn){

inti,s=O;

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

returns;

}

voidmain(){

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

intb=LA(a,5)+LA(a+2,3);

printf("b=%d\n",b);

}

按题目要求编写函数

编写一个函数，函数原型为、'intfun4(char*a)〃，请采用while循

环求出由字符指针a所指向的字符串中包含的十进制数字的个数，并

把这个值作为函数值返回。

按题目要求编写函数

编写一个主函数，计算并输出表达式1+22+32+…+«的值，假定

正整数n的值由键盘输入。

按题目要求编写函数

根据函数原型"doubleMean(doublea[M][N]zintm,intn)〃，编

写函数定义，要求返回二维数组矶m][n]中所有元素的平均值。假定

在计算过程中采用变量v存放累加值和最后的平均值。

按题目要求编写函数

根据函数原型''intMM(inta[Lintm)〃，编写函数定义，计算并返

回数组或m]中元素最大值和最小值之差。

按题目要求编写程序

编写一个程序，已知6WaW50,10WbW30,求出满足不定方程

3a+2b=120的全部整数组解。如(20,30)就是其中的一组解。

按题目要求编写程序

编写一个程序，首先从键盘上输入10个整数到一维数组a[10]中，

然后按照下标从大到小的次序输出数组a[10]中的所有元素值。假定

数组a[10]和循环变量i均在主函数中定义。

按题目要求编写程序或函数

编写一个递归函数''intFF(inta[],intn)”,求出数组a中所有n个

元素之积并返回。

按题目要求编写程序或函数

编写一个程序，利用while循环，计算并打印输出的值，其中正整数

n值由键盘输入。假定求和变量用sum表示，计数变量用i表示,sum、

i和n均定义为全局变量，sum和i的初值分别被赋予0和1。

按题目要求编写程序或函数

根据函数原型''voidDD(inta[],intn,intMM)〃编写函数定义，利

用双重循环查找并打印输出数组a[n]中任何两个元素的值等于MM

值的元素值。假定a[i]+a[j]等于MM,则输出格式为:(a[i],a[j])o

按题目要求编写程序或函数

编写一个程序，计算1+3+32+…+3】。的值并输出，假定分别用i,p,s

作为循环变量、累乘变量和累加变量的标识符。

按题目要求编写程序或函数

根据函数原型''intFF(inta口，intn)〃，编写函数定义，计算并返回

数组a[n]中所有元素之和。

按题目要求编写程序或函数

编写一个程序，输出35以内(含35)的、能够被4或者7整除的所

有整数。

根据函数回答相应问题

voidSF(intx){//n为大于等于0的整数

inti=2;

while(x>i){

if(x%i==O)printf("%d",i);

i++；

}

printf("\n");

}

假定使用SF(70)调用该函数，则输出的所有整数依次为

__________________O

根据函数回答相应问题

voidQC(structIntNode*f){〃f为一个单链表的表头指针

while(f){

printf("%d"zf->data);

f=f->next;

}

)

假定结构类型IntNode的定义为：

structIntNode{intdata;structIntNode*next;};

该函数的功能为：

编写一个函数，分别求出一维整型数组中所有奇数元素

的个数和所有偶数元素的个数，假定分别用cl和c2所指的对

象保存。

编写一个函数，分别求出一维整型数组a[n]中所有奇数元素的个数

和所有偶数元素的个数，假定分别用cl利c2所指的对象保存。

voidfun2(inta[],intn,int*cl,int*c2);

编写一个函数，求出一维整型数组a[n]中所有元素的平方之

和。

编写一个函数，求出一维整型数组矶n]中所有元素的平方之和。

intfunl(inta[]zintn);

编写一个非递归函数过程，求出两个自然数m和n的最大公

约数。

编写一个非递归函数过程，求出两个自然数m和n的最大公约数。

intfun5(intm,intn);

1.若x的值为15,则执行、'if(x>10)x++;elsex--;〃语句

后，x的值为()。

1.若X的值为15,则执行''if(x>10)X++;elsex・・;〃语句后，x

的值为()。

■r

16

■C

15

char类型的长度为个字节。

char类型的长度为个字节。

1

2

3

■r

4

C语言中打开一个数据文件的系统函数为()。

C语言中打开一个数据文件的系统函数为()。

r

fgetc()

■

fputc()

■r

fclose()

■

fopen()

C语言中的系统函数fopen（）是（）一个数据文件的函数。

C语言中的系统函数fopen（）是（）一个数据文件的函数。

r

读取

■r

写入

•厂

关闭

打开

C语言源程序文件的缺省扩展名为（）。

C语言源程序文件的缺省扩展名为（）o

cpp

exe

・

obj

C

C语言程序中的基本功能模块为（）。

C语言程序中的基本功能模块为（）。

表达式

■C

标识符

语句

C

函数

for循环语句'¥or（i=0;i

for循环语句、'for（i=0;i<n;i+=2）S;“中循环体S语句被执行的次

数为（）。

•0

（n+l）/2

■

n/2+l

■

n/2-l

■

n-1

for循环语句能够被改写为（）语句。

for循环语句能够被改写为（）语句。

复合

if

・

switch

■r

while

for语句能够被改写成的语句是（）。

for语句能够被改写成的语句是（）。

复合

■C

if

■r

switch

while

NULL是一个符号常量，通常作为空指针值，它的取值为（）。

NULL是一个符号常量，通常作为空指针值，它的取值为（）。

r

0

-1

■

'\rf

一个指针指向一个数据对象，它保存着该数据对象的地址，若

数据对象为DataType类型，则该指针的类型为（）。

一个指针指向一个数据对象，它保存着该数据对象的地址，若数据对

象为DataType类型，则该指针的类型为（）。

■

DataType*

DataType

DataType&

■r

DataType**

下面的函数原型声明中存在语法错误的是()。

下面的函数原型声明中存在语法错误的是()。

■

voidAA(inta,intb);

■

voidAA(int,int);

voidAA(inta;intb;);

■r

voidAA(inta,int);

与结构成员访问表达式p->name等价的表达式为()。

与结构成员访问表达式p・>name等价的表达式为()。

(*p).name

■

*

■

*(p->name)

与结构成员访问表达式x.name等价的表达式为()。

与结构成员访问表达式x.name等价的表达式为()。

■.r

x->name

&x->name

(&x)->name

・

(*x)->name

从一个二进制文件中读取数据的系统函数为fread(),它的参

数有()。

从一个二进制文件中读取数据的系统函数为fread(),它的参数有

()O

2个

■

3个

.r

4个

■

5个

从一个数据文件中读入以换行符结束的一行字符串的函数为

()O

从一个数据文件中注入以换行符结束的一行字符串的函数为()o

•0

gets。

■

fgets()

■

getc()

■

fgetc()

从一个数据文件中读入以换行符结束的一行字符串的系统函

数为()。

从一个数据文件中读入以换行符结束的一行字符串的系统函数为

()O

gets。

・

fgets()

getc()

■

fgetc()

从一个文本文件中读取以换行符结束的一个字符串的系统函

数为()。

从一个文本文件中读取以换行符结束的一个字符串的系统函数为

()O

.r

fputc()

fgets()

fputs（）

・

fgetc（）

假定a为一个数组名，则下面存在错误的表达式为（）。

假定a为一个数组名，则下面存在错误的表达式为（）。

a[i]

*d++

■

*a

*（a+l）

假定a为一个数组名，则下面表达式中错误的是（）。

假定a为一个数组名，则下面表达式中错误的是（）。

*a++

(*a)++

a+i

*a+i

假定a为一个数组名，则元素a[i]的指针访问方式为（）。

假定a为一个数组名，则元素a[i]的指针访问方式为（）。

a+i

*(a+i)

&a+i

*a+i

假定a为一个数组名，在下面的表达式中，存在语法错误的是

（）。

假定a为一个数组名，在下面的表达式中，存在语法错误的是（）。

■

a[i]

*a++

■I

*a

■

*（d+l）

假定d为一个整数类型的数组名，整数类型的长度为4,则元

素a[4]的地址比a数组的首地址大（）个字节。

假定a为一个整数类型的数组名，整数类型的长度为4,则元素矶4]

的地址比a数组的首地址大（）个字节。

4

8

■

16

■

32

假定i的初值为0,则在循环语句''while。

假定i的初值为0,则在循环语句、'while(i<n){s+=i*i;i++;}〃中,

其循环体被执行的总次数为()。

n-1

n

n+l

・

n/2

假定k是一个double类型的变量，则定义变量p的正确语句

为（）。

假定k是一个double类型的变量,则定义变量p的正确语句为（）。

doublep=&k;

■

int*p=&k;

■I

double&p=*k;

char*p="Thankyou!";

假定n的值为5,则表达式n++的值为（）。

假定n的值为5,则表达式n++的值为（）。

6

5

■c

4

■

7

假定p所指对象的值为25,p+1所指对象的值为42,则表

达式*P++的值为（）。

假定P所指对象的值为25,p+1所指对象的值为42,则表达式*p++

的值为（）。

■r

25

42

.r

26

■r

43

假定p是一个指向double类型的数据指针，则p+1所指向

的数据的地址比p所指向的数据的地址大（）个字节。

假定p是一个指向double类型的数据指针，则p+1所指向的数据

的地址比p所指向的数据的地址大（）个字节。

1

■

2

■

4

■

8

假定p是一个指向float型数据的指针，则p+1所指数据的

地址比p所指数据的地址增加的字节数为（）。

假定p是一个指向float型数据的指针,则p+1所指数据的地址比p

所指数据的地址增加的字节数为（）o

r

1

r

2

4

■

8

假定P是一个指针变量，则该变量的地址表示为（）。

假定p是一个指针变量，则该变量的地址表示为（）。

■

&P

*r

*P

■r

**D

•右

&&p

假定s被定义为指针类型char*的变量，初始指向的字符串

为“Helloworld!”，若要使变量p指向s所指向的字符串，则

P应定义为（）。

假定s被定义为指针类型char*的变量，初始指向的字符串为"Hello

）

world!”,若要使变量p指向s所指向的字符串，则p应定义为（o

■r

char*p=s;

■

char*p=&s;

■r

char*p;p=*s;

char*p;p=&s;

假定x的值为4,y的值为6,则表达式x++*++y的值为（）。

假定x的值为4,y的值为6,则表达式x++*++y的值为（）。

■

28

24

30

35

假定一个二维数组a的定义为、'int

a[3][4]={{3,4},{2,8,6）}：则元素况2][0]的值为（）。

假定一个二维数组a的定义为、'int矶3][4]={{3,4},{2,8,6}};〃,

则元素矶2][0]的值为（）。

0

2

■

4

■

6

假定一个二维数组的定义语句为''int

a[3][4]={{3,4},{2,8,6}）;〃,则元素的值为（）。

假定一个二维数组的定义语句为''int

z

a[3][4]={{3z4}z{2,8,6）}/,则元素的值为（）。

■

2

4

6

8

假定一个二维数组的定义语句为、'int

矶3][4]={{3,4},{2,8,6}};〃,则元素的值为()。

假定一个二维数组的定义语句为''int

a[3][4]={{3,4},{2,8,6}};”,则元素的值为()。

■

2

4

■

6

8

假定一个二维数组的定义语句为、'int

矶3][4]={{3,4},{2,8,6}};〃,则元素己[2]口]的值为()。

假定一个二维数组的定义语句为、'int

矶3][4]={{3,4},{2,8,6}};〃，则元素的值为()。

0

■

4

■

8

■

6

假定一个函数原型为''char*func(intn)",则该函数的返回

值类型为()。

假定一个函数原型为''char*func(intn)〃，则该函数的返回值类型

为()。

int

int*

■

char

■

char*

假定一个函数原型为''voidff(inta[],intn)〃，则对应的函数

指针类型为()。

假定一个函数原型为''voidff(inta[],intn)〃，则对应的函数指针类

型为()。

■

void

(*ff)(int*a,int)

■r

int(*ff)(int*a,int)

■r

void

*ff(int*a,int)

r

*ff(int[],int)

假定一个函数原型语句为、'intfl(inta[],intn);〃，与数组参

数等价的表示为()。

假定一个函数原型语句为''intfl(inta[]jntn);”,与数组参数等价

的表示为()。

int**a

*r

inta

r

int&a

■r

int*a

假定一个函数定义为"externchar*fl(char*x){return

x;)〃，表示该函数作用域的关键字为()。

假定一个函数定义为''externchar*fl(char*

x){returnx;}z,,表示该函数作用域的关键字为()。

■

extern

■r

char*

■r

char

int

假定一个函数定义为"staticintfl(intxjnty){return

x+y;}〃，该函数名称为()。

假定一个函数定义为''staticintfl(intx,inty){returnx+y;}〃,

该函数名称为()。

c

static

■

int

fl

return

假定一个函数的二维数组参数说明为charw[][N],与之等价

的指针参数说明为()。

假定一个函数的二维数组参数说明为char与之等价的指针

参数说明为()。

C

■

char(*w)[N]

char*w[N]

■

char(*w)N

char**a

假定一个函数的原型语句为“intff(int*x);〃，一个整型数组

为a[10],则下面函数调用表达式不正确的是()。

假定一个函数的原型语句为、'intff(int*x);”,一个整型数组为a[10],

则下面函数调用表达式不正确的是()。

ff(a)

ff(a[O])

■r

ff(a+3)

ff(&a[O])

假定一个函数的原型语句为、'intx);〃，一个整型数组

为a[10],则下面函数调用表达式不正确的是()。

假定一个函数的原型语句为木x);〃,一个整型数组为

则下面函数调用表达式不正确的是()。

■r

ff(a)

ff(a[O])

ff（a+3）

■

ff（&a[O]）

假定一个函数的参数说明为constinta,则在函数体中不能

进行的操作是（）。

假定一个函数的参数说明为constinta,则在函数体中不能进行的

操作是（）。

printf（，，%d，，»a）

■

a==0

int

x=a

■r

a=10

假定一个函数的数组参数说明为chara[],与之等价的指针参

数说明为（）01B

假定一个函数的数组参数说明为chara[]；与之等价的指针参数说明

为（）。1B

■r

chara

char*a

■

char&a

■

char**a

假定一个磁盘数据文件占用n个字节的存储空间，则按字节进

行编址的范围是（）。

假定一个磁盘数据文件占用n个字节的存储空间，则按字节进行编址

的范围是()。

■

O~(n-1)

■

l~n

■

0~n

假定一个结构类型的定义为''structA{intazb;double

C；}；〃,则该类型的长度为()o

假定一个结构类型的定义为''structA{intazb;doublec;};",则

该类型的长度为()。

c

8

10

12

■

16

假定一个结构类型的定义为''structA{intazb;double

C；}；〃，则该类型的长度为()o

假定一个结构类型的定义为''structA{intazb;doublec;};",则

该类型的长度为()。

8

■

10

■

12

16

假定一个结构类型的定义为"structD{inta;D*next;};",

则该类型的长度为（）。

假定一个结构类型的定义为''structD{inta;D*next;};",贝ij该

类型的长度为（）。

4

■

8

12

■

16

假定一个结构类型的定义为''structD{inta;D*next;};”,

则该类型的长度为（）。

假定一个结构类型的定义为''structD{inta;D*next;};",则该

类型的长度为（）。

■r

4

■X

8

■

12

16

假定一个联合类型的定义为''unionD{inta;D*next;};",

则该类型的长度为（）。

假定一个联合类型的定义为''unionD{inta;D*next;};",则该

类型的长度为（）。

*c

4

8

12

■

16

假定一个链表中结点的结构类型为''structAA{intdata,

structAA*next;};,z,则next数据成员的类型为（）。

假定一个链表中结点的结构类型为"structAA{intdata,structAA

*next;};〃，则next数据成员的类型为（）。

structAA

■

structAA*

■

AA

int

假定一个链表的表头指针为f,结点中包含有data和next域,

则向该链表的表头插入一个地址为p的结点时，应执行的操作

为（）。

假定一个链表的表头指针为f,结点中包含有data和next域，则向

该链表的表头插入一个地址为P的结点时，应执行的操作为（）o

p->next=f

p・>next=f和f=p

f=p->next

f->next=p和f=p

假定一个链表的表头指针为f,结点中包含有data和next域,

则向该链表的表头插入一个地址为p的结点时，应执行的操作

为（）。

假定一个链表的表头指针为f,结点中包含有data和next域，则向

该链表的表头插入一个地址为p