还剩82页未读,继续阅读
本资源只提供10页预览,全部文档请下载后查看!喜欢就下载吧,查找使用更方便
文本内容:
试题一
(11)以下叙述中正确的是A)C语言比其他语言高级B)C语言可以不用编译就能被计算机识别执行C)C语言以接近英语国家的自然语言和数学语言作为语言的表达形式D)C语言出现的最晚,具有其他语言的一切优点
(12)C语言中用于结构化程序设计的3种基本结构是 A)顺序结构、选择结构、循环结构 B)ifswitchbreakC)forwhiledo-while D)ifforcontinue
(13)C语言中最简单的数据类型包括A)整型、实型、逻辑型 B)整型、实型、字符型C)整型、字符型、逻辑型 D)字符型、实型、逻辑型
(14)若变量已正确定义并赋值,以下符合C语言语法的表达式是 A)a:=b+1 B)a=b=c+2 C)int
18.5%3 D)a=a+7=c+b
(15)下列可用于C语言用户标识符的一组是 A)voiddefineWORD B)a3_b3_123Car C)For-abcIFCase D)2aDOsizeof
(16)C语言中运算对象必须是整型的运算符是 A)%= B)/ C)= D)=
(17)若变量ai已正确定义且i已正确赋值,合法的语句是 A)a==1 B)++i; C)a=a++=5; D)a=int(i);
(18)已知 intt=0; while(t=1) {...} 则以下叙述正确的是 A)循环控制表达式的值为0 B)循环控制表达式的值为1 C)循环控制表达式不合法 D)以上说法都不对
(19)若变量已正确说明为float型,要通过语句scanf("%f%f%f"abc);给a赋予
10.0,b赋予
22.0,c赋予
33.0,下列不正确的输入形式是 A)10回车22回车33回车 B)
10.
022.
033.0回车 C)
10.0回车
22.
033.0回车 D)10 22回车33回车
(20)有如下程序 main() { intx=1a=0b=0; switch(x){ case0:b++; case1:a++; case2:a++;b++; } printf(a=%db=%d\nab);} 该程序的输出结果是 A)a=2b=1 B)a=1b=1 C)a=1b=0 D)a=2b=2
(21)有以下程序 main() {inti=1j=1k=2; if((j++||k++)i++) printf(%d%d%d\nijk); } 执行后输出结果是 A)112 B)221 C)222 D)223
(22)有如下程序 main() {floatx=
2.0y; if(x
0.0)y=
0.0; elseif(x
10.0)y=
1.0/x; elsey=
1.0; printf(%f\ny);} 该程序的输出结果是 A)
0.000000 B)
0.250000 C)
0.500000 D)
1.000000
(23)有如下程序 main() {intn=9; while(n6){n--;printf(%dn);} } 该程序的输出结果是 A)987 B)876 C)8765 D)9876
(24)在下列选项中,没有构成死循环的是 A)inti=100; while
(1) {i=i%100+1; if(i100)break; } B)for(;;); C)intk=10000; do{k++;}while(k10000); D)ints=36; while(s)--s;
(25)设intx=1y=1;表达式(!x||y--)的值是 A)0 B)1 C)2 D)-1
(26)若已定义的函数有返回值,则以下关于该函数调用的叙述中错误的是A)函数调用可以作为独立的语句存在 B)函数调用可以作为一个函数的实参C)函数调用可以出现在表达式中 D)函数调用可以作为一个函数的形参
(27)有以下程序 floatfun(intxinty) {return(x+y);} main() {inta=2b=5c=8; printf(%
3.0f\nfun((int)fun(a+cb)a-c)); } 程序运行后的输出结果是 A)编译出错 B)9 C)21 D)
9.0
(28)若有以下调用语句,则不正确的fun函数的首部是 main() {… inta[50]n; … fun(na[9]); … } A)voidfun(intmintx[]) B)voidfun(intsinth[41]) C)voidfun(intpint*s) D)voidfun(intninta)
(29)fseek函数的正确调用形式是 A)fseek(文件指针起始点位移量) B)fseek(文件指针位移量起始点) C)fseek(位移量起始点文件指针) D)fseek(起始点位移量文件指针)
(30)若fp是指向某文件的指针,且已读到文件末尾,则函数feof(fp)的返回值是 A)EOF B)-1 C)1 D)NULL
(31)若有说明语句charc=\72;则变量c A)包含1个字符 B)包含2个字符 C)包含3个字符 D)说明不合法,c的值不确定
(32)若有说明inta[3][4];则a数组元素的非法引用是 A)a[0][2*1] B)a[1][3] C)a[4-2][0] D)a[0][4]
(33)设有以下说明语句 structstu {inta; floatb; }stutype; 则下面的叙述不正确的是 A)struct是结构体类型的关键字 B)structstu是用户定义的结构体类型 C)stutype是用户定义的结构体类型名 D)a和b都是结构体成员名
(34)在C语言中,引用数组元素时,其数组下标的数据类型允许是 A)整型常量 B)整型表达式 C)整型常量或整型表达式 D)任何类型的表达式
(35)若运行时给变量x输入12,则以下程序的运行结果是 main() {intxy; scanf(%dx); y=x12x+10:x-12; printf(%d\ny); } A)0 B)22 C)12 D)10
(36)以下说法正确的是 A)C语言程序总是从第一个的函数开始执行 B)在C语言程序中,要调用函数必须在main()函数中定义 C)C语言程序总是从main()函数开始执行 D)C语言程序中的main()函数必须放在程序的开始部分
(37)表达式0x13^0x17的值是 A)0x04 B)0x13 C)0xE8 D)0x17
(38)有以下程序 #defineF(XY)(X)*(Y) main() {inta=3b=4; printf(%d\nF(a++b++)); } 程序运行后的输出结果是 A)12 B)15 C)16 D)20
(39)下列程序执行后的输出结果是 voidfunc(int*aintb[]) {b[0]=*a+6;} main() {intab[5]; a=0;b[0]=3; func(ab);printf(%d\nb[0]); } A)6 B)7 C)8 D)9
(40)若有下面的程序段 chars[]=china;char*p;p=s; 则下列叙述正确的是 A)s和p完全相同 B)数组s中的内容和指针变量p中的内容相等 C)s数组长度和p所指向的字符串长度相等 D)*p与s[0]相等
(41)以下程序中函数sort的功能是对a数组中的数据进行由大到小的排序 voidsort(inta[]intn) {intijt; for(i=0;in-1;i++) for(j=i+1;jn;j++) if(a[i]a[j]){t=a[i];a[i]=a[j];a[j]=t;} } main() {intaa[10]={12345678910}i; sort(aa[3]5); for(i=0;i10;i++)printf(%daa[i]); printf(\n); } 程序运行后的输出结果是 A)12345678910 B)10987654321 C)12387654910 D)12109876543
(42)以下程序的运行结果是 #includestdio.h main() {structdate {intyearmonthday;}today; printf(%d\nsizeof(structdate)); } A)6 B)8 C)10 D)12
(43)若有语句int*pointa=4;和point=a;下面均代表地址的一组选项是 A)apoint*a B)*aa*point C)*point*pointa D)a*pointpoint
(44)在调用函数时,如果实参是简单的变量,它与对应形参之间的数据传递方式是 A)地址传递 B)单向值传递 C)由实参传形参,再由形参传实参 D)传递方式由用户指定
(45)已定义以下函数 fun(char*p2char*p1) { while((*p2=*p1)!=\0){p1++;p2++;} } 函数的功能是 A)将p1所指字符串复制到p2所指内存空间 B)将p1所指字符串的地址赋给指针p2 C)对p1和p2两个指针所指字符串进行比较 D)检查p1和p2两个指针所指字符串中是否有\0
(46)若执行下述程序时,若从键盘输入6和8时,结果为 main() {intabs; scanf(%d%dab); s=a if(ab) s=b; s*=s; printf(%ds); } A)36 B)64 C)48 D)以上都不对
(47)fscanf函数的正确调用形式是 A)fscanf(fp格式字符串输出表列); B)fscanf(格式字符串输出表列fp); C)fscanf(格式字符串文件指针输出表列); D)fscanf(文件指针格式字符串输入表列);
(48)下列关于C语言数据文件的叙述中正确的是 A)文件由ASCII码字符序列组成,C语言只能读写文本文件 B)文件由二进制数据序列组成,C语言只能读写二进制文件 C)文件由记录序列组成,可按数据的存放形式分为二进制文件和文本文件 D)文件由数据流形式组成,可按数据的存放形式分为二进制文件和文本文件
(49)有以下程序 voidss(char*schart) {while(*s) {if(*s==t)*s=t-a+A; s++; } } main() {charstr1[100]=abcddfefdbdc=d; ss(str1c);printf(%s\nstr1); } 程序运行后的输出结果是 A)ABCDDEFEDBD B)abcDDfefDbD CabcAAfefAbA D)Abcddfefdbd
(50)若以下定义: structlink {intdata; structlink*next; }abc*p*q; 且变量a和b之间已有如下图所示的链表结构:指针p指向变量aq指向变量c则能够把c插入到a和b之间并形成新的链表的语句组是:A)a.next=c;c.next=b; B)p.next=q;q.next=p.next; C)p-next=c;q-next=p-next; D)(*p).next=q;(*q).next=b;
二、填空题
(6)设y是int型,请写出y为奇数的关系表达式【6】答案y%2==1
(7)设inta=5b=6表达式(++a==b--)++a:--b的值是【7】 解析此表达式为三目运算符,++a的值为6b--的值为6,则整个表达式的值为++a的值,++a的值为7请注意前缀++--和后缀++,--的区别
(8)下列程序的输出结果是【8】maim (){charb[]=Helloyou;b[5]=0;printf(%s\nb);}解析语句b[5]=0;相当于语句b[5]=′\0′且′\0′为字符串结束标志,输出时遇到′\0′就停止输出
(9)当调用函数时,实参是一个数组名,则向函数传递的是【9】解析在函数中,可以通过指针变量来引用调用函数中对应的数组元素,此操作是通过传递数组的首地址来实现
(10)以下程序的输出结果是【10】inta=1234;printf(%2d\n,a);解析在%与格式符之间插入一个整形数来指这输出宽度,并不影响数据的完整性,当插入的宽度小于实际的宽度时,则实际的宽度输出
(11)用高级语言编写的程序称为【11】程序,它可以通过解释程序翻译一句执行一句的方式执行,也可以通过编译程序一次翻译产生目标程序,然后执行解析用高级语言编写的程序称为源程序,源程序不能在计算机上直接运行,运行源程序有两种方式一种是通过解释程序,对源程序逐句解释执行;另一种是先让编译程序将源程序一次翻译产生目标程序(目标程序是计算机可直接执行的机器语言程序,它是一种二进制代码程序),然后执行目标程序
(12)以下程序的输出结果是【12】main(){inta=0;a+=(a=8);printf(%d\na);}解析赋值表达式的值就是所赋值变量的值,本题中a+=8相当于a=a+8,对表达式逐步进行求解a+=(a=8)此时,a的值由于赋值为8,而不是0a+=8a=a+8a=16
(13)函数voidfun(float*snintn)的功能是:根据以下公式计算S计算结果通过形参指针sn传回;n通过形参传入n的值大于等于0请填空 voidfun(float*snintn){floats=
0.0wf=-
1.0;inti=0;for(i=0;i=n;i++){f=【13】*f;w=f/(2*i+1);s+=w;}【14】=s;}解析C语言中实参变量和形参变量的数据传递是单向的“值传递”方式指针变量作函数也要遵循这一规则调用函数不可能改变实参指针变量的值,但可以改变实参指针变量所指变量的值
(14)函数fun的功能是根据以下公式求p的值,结果由函数值返回m与n为两个正数且要求mn 例如m=12,n=8时,运行结果应该是
495.000000请在题目的空白处填写适当的程序语句,将该程序补充完整#includeconio.h#includestdio.hfloatfun(intmintn){inti;doublep=
1.0;for(i=1;i=m;i++)【15】;for(i=1;i=n;i++)【16】;for(i=1;i=m-n;i++)p=p/i;returnp;}main(){clrscr();printf(p=%f\nfun
(128));}解析本题中,欲求p的值,需要先求m,n,m-n的阶乘值,可用循环语句实现
(15)该程序运行的结果是【17】#includeconio.h#includestdio.h#defineM100voidfun(intmint*aint*n){intij=0;for(i=1;i=m;i++)if(i%7==0||i%11==0)a[j++]=i;*n=j;}main(){intaa[M]nk;clrscr();fun(10aan);for(k=0;kn;k++)if((k+1)%20==0)printf(\n);elseprintf(%4daa[k]);printf(\n);}解析解答本题的关键是要读懂程序,试题要找出能被7或11整除的所有整数,注意数学中的“或”和C语言中的“或”的区别,但在此处,if条件语句中用了“||”运算符,若要找能同时被7和11整除的所有整数则在if()中应用“”运算符当然,如果m的值输入50,即表达式fun(10aan);为fun(50aan);时输入结果为7 11 14 21 22 28 33 35 42 44 49
(16)下列程序的功能是求出ss所指字符串中指定字符的个数,并返回此值例如,若输入字符串123412132,输入字符1,则输出3,请填空#includeconio.h#includestdio.h#defineM81intfun(char*sscharc){inti=0;for(;【18】;ss++)if(*ss==c)i++;returni;}main(){chara[M]ch;clrscr();printf(\nPleaseenterastring:);gets(a);printf(\nPleaseenterachar:);ch=getchar();printf(\nThenumberofthecharis:%d\nfun(ach));}解析从字符串ss中找出子字符串的方法是从第1个字符开始,对字符串进行遍历;若ss串的当前字符等于t串的第1个字符,两字符串的指针自动加1,继续比较下一个字符;若比较至字符串的结尾,则跳出循环;若ss串的字符和c串的字符对应不同,继续对ss串的下一个字符进行处理本程序是采用逐一比较的方式找出出现的次数循环的作用是在串中从左到右逐一走动,if()的作用是进行判断是否相同,若与c相同则表示又出现一次
(17)下面程序把从终端读入的文本(用@作为文本结束标志)输出到一个名为bi.dat的新文件中,请填空#includestdio.hFILE*fp;{charch;if((fp=fopen(【19】))==NULL)exit
(0);while((ch=getchar())!=@)fputc(chfp);fclose(fp);}解析fopen函数的调用方式通常为FILE*fpfp=fopen(文件名,使用文件方式);
(18)设有如下宏定义#defineMYSWAP(zxy){z=x;x=y;y=z;}以下程序段通过宏调用实现变量a,b内容交换请填空floata=5b=16c;MYSWAP(【20】ab);解析该题考查两个知识点
(1)用一个指定的标识符(即名字)来代表一个字符串,它的一般形式为#define标识符 字符串
(2)在MYSWAP宏定义中,利用中间变量z来交换x和y的值,所以要实现a和b的交换,只需通过中间变量即可,所以,此处应填c
一、选择题11-15 C A B B B16-20 A B B B A 21-25 C C S D B26-30 D B DBC31-35 A D C C A36-40 C A A A D41-45 C A B B A46-50 B D D B D试题
二一、选择题
(11)下列叙述中正确的是 A)C语言编译时不检查语法 B)C语言的子程序有过程和函数两种 C)C语言的函数可以嵌套定义 D)C语言的函数可以嵌套调用
(12)在C语言中,退格符是 A)\n B)\t C)\f D)\b
(13)以下叙述中正确的是 A)构成C程序的基本单位是函数 B)可以在一个函数中定义另一个函数 C)main()函数必须放在其他函数之前 D)所有被调用的函数一定要在调用之前进行定义
(14)在C程序中,判逻辑值时,用“非0”表示逻辑值“真”,又用“0”表示逻辑值“假”在求逻辑值时,用()表示逻辑表达式值为“真”,又用()表示逻辑表达式值为“假” A)1 0 B)0 1 C)非0 非0 D)1 1
(15)在C语言中,运算对象必须是整型数的运算符是 A)% B)\ C)%和\ D)**
(16)字符型数据在机器中是用ASCII码表示的,字符“5”和“7”在机器中表示为 A)10100011和01110111 B)01000101和01100011 C)00110101和00110111 D)01100101和01100111
(17)若已定义inta=25b=14c=19;以下三目运算符(?)所构成语句的执行后 a=25b--=2cprintf(***a=%db=%dc=%d\nabc):printf(###a=%db=%dc=%d\n,abc);程序输出的结果是 A)***a=25b=13c=19 B)***a=26b=14c=19 C)###a=25b=13c=19 D)###a=26b=14c=19
(18)若有定义inta=7;floatx=
2.5y=
4.7;则表达式x+a%3*(int)(x+y)%2/4的值是 A)
2.500000 B)
2.750000 C)
3.500000 D)
0.000000
(19)下列程序段的输出结果是 inta=1234; floatb=
123.456; doublec=
12345.54321; printf(%2d%
2.1f%
2.1fabc); A)无输出 B)12,
123.
512345.5 C)
1234123.
512345.5 D)
1234123.
41234.5
(20)若运行以下程序时,从键盘输入ADescriptorCR(CR表示回车),则下面程序的运行结果是#includestdio.h main() {charc; intv0=1v1=0v2=0; do{switch(c=getchar()) {case′a′:case′A′: case′e′:case′E′: case′i′:case′I′: case′o′:case′O′: case′u′:case′U′:v1+=1; default:v0+=1;v2+=1; } }while(c!=′\n′); printf(v0=%dv1=%dv2=%d\nv0v1v2);} A)v0=7v1=4v2=7 B)v0=8v1=4v2=8 C)v0=11v1=4v2=11 D)v0=13v1=4v2=12
(21)设有以下程序段 intx=0s=0; while(!x!=0)s+=++x; printf(%ds); 则 A)运行程序段后输出0 B)运行程序段后输出1 C)程序段中的控制表达式是非法的 D)程序段执行无限次
(22)有如下程序 main() {floatx=
2.0y; if(x
0.0)y=
0.0; elseif(x
10.0)y=
1.0/x; elsey=
1.0; printf(%f\ny);} 该程序的输出结果是 A)
0.000000 B)
0.250000 C)
0.500000 D)
1.000000
(23)执行下面的程序段后,变量k中的值为 intk=3s[2]; s[0]=k;k=s[1]*10; A)不定值 B)33 C)30 D)10
(24)以下程序段的描述,正确的是 x=-1; do {x=x*x;} while(!x); A)是死循环 B)循环执行两次 C)循环执行一次 D)有语法错误
(25)以下选项错误的是 A)main() {intxyz; x=0;y=x-1; z=x+y;} B)main() {intxyz; x=0y=x+1; z=x+y;} C)main() {intx;int inty; x=0y=x+1; z=x+y;} D)main() {intxyz; x=0;y=x+1; z=x+y}
(26)有如下程序段 inta=14b=15x; charc=′A′; x=(ab)(c′B′); 执行该程序段后,x的值为 A)ture B)false C)0 D)1
(27)下列程序执行后的输出结果是 voidfunc1(inti); voidfunc2(inti); charst[]=hellofriend!; voidfunc1(inti) {printf(%cst[i]); if(i3){i+=2;func2(i);}} voidfunc2(inti) {printf(%cst[i]); if(i3){i+=2;func1(i);}} main() {inti=0;func1(i);printf(\n);} A)hello B)hel C)hlo D)hlm
(28)以下函数返回a所指数组中最大值所在的下标值 fun(int*aintn) {intij=0p; p=j; for(i=j;in;i++) if(a[i]a[p])_________; return(p);} 在下划线处应填入的内容是 A)i=p B)a[p]=a[i] C)p=j D)p=I
(29)下面说明不正确的是 A)chara[10]=china; B)chara[10]*p=a;p=china C)char*a;a=china; D)chara[10]*p;p=a=china
(30)以下程序的输出结果是 #includestdio.h voidprt(int *xint *yint *z) {printf(%d%d%d\n++*x++*y*(z++));} main() {inta=10b=40c=20; prt(abc); prt(abc);} A)114231 122241 B)114120 124220 C)112140 112121 D)114121 124222
(31)若有函数内部说明inta[3][4];则数组a中各元素 A)可在程序的运行阶段得到初值0 B)可在程序的编译阶段得到初值0 C)不能得到确定的初值 D)可在程序的编译或运行阶段得到初值0
(34)定义如下变量和数组 intk; inta[3][3]={987654321}; 则下面语句的输出结果是 for(k=0;k3;k++)printf(%da[k][k]); A)753 B)951 C)963 D)741
(35)下列程序执行后的输出结果是 main() {chararr[2][4]; strcpy(arryou);strcpy(arr[1]me); arr[0][3]=′′; printf(%s\narr);} A)youme B)you C)me D)err
(36)有以下函数 charfun(char*p) {returnp;} 该函数的返回值是 A)无确切的值 B)形参p中存放的地址值 C)一个临时存储单元的地址 D)形参p自身的地址值
(37)以下正确的说法是 A)定义函数时,形参的类型说明可以放在函数体内 B)return后边的值不能为表达式 C)如果函数值的类型与返回值类型不一致,以函数值类型为准 D)如果形参与实参类型不一致,以实参类型为准
(38)有以下程序 intf(intn) {if(n==1)return1; elsereturnf(n-1)+1;} main() {intij=0; for(i=1;i3;i++)j+=f(i); printf(%d\nj);} 程序运行后的输出结果是 A)4 B)3 C)2 D)1
(39)设有如下定义 strucksk {inta; floatb; }data; int*p; 若要使P指向data中的a域,正确的赋值语句是 A)p=a; B)p=data.a; C)p=data.a; D)*p=data.a;‘
(40)以下对结构体类型变量的定义中,不正确的是 A)typedefstructaa {intn; floatm; }AA; AAtdl; B)#defineAAstructaa AA{intn; floatm; }tdl; C)struct {intn; floatm; }aa; structaatdl; D)struct {intn; floatm; }tdl;
(41)若说明int*pn;则通过语句scanf能够正确读入数据的程序段是 A)p=n;scanf(%dp); B)p=n;scanf(%d*p); C)scanf(%dn); D)p=n;scanf(%dp);
(42)在下述程序中,判断ij共执行的次数是 main() {inti=0j=10k=2s=0; for(;;) {i+=k; if(ij) {printf(%ds); break; }s+=i; } } A)4 B)7 C)5 D)6
(43)以下4个选项中,不能看做一条语句的是 A); B)a=5b=
2.5c=
3.6; C)if(a5); D)if(b!=5)x=2;y=6;
(44)在C语言中,变量的隐含存储类别是 A)auto B)static C)extern D)无存储类别
(45)若有以下程序 #includestdio.h voidf(intn); main() {voidf(intn); f
(5); } voidf(intn) {printf(%d\nn);} 则以下叙述中不正确的是 A)若只在主函数中对函数f进行说明,则只能在主函数中正确调用函数f B)若在主函数前对函数f进行说明,则在主函数和其后的其他函数中都可以正确调用函数f C)对于以上程序,编译时系统会提示出错信息提示对f函数重复说明 D)函数f无返回值,所以可用void将其类型定义为无返回值型
(46)若有下面的说明和定义 structtest {intml;charm2;floatm3; unionuu{charul[5];intu2[2];}ua; }myaa; 则sizeof(structtest)的值是 A)12 B)16 C)14 D)9
(47)以下程序的输出是 structst {intx;int*y;}*p; intdt[4]={10203040}; structstaa[4]={50dt[0]60dt[0]60dt[0]60dt[0]}; main() {p=aa; printf(%d\n++(p-x)); } A)10 B)11 C)51 D)60
(48)若有运算符sizeof^=则它们按优先级由高至低的正确排列次序是 A)sizeof=^ B)sizeof^= C)^sizeof= D)^=sizeof
(49)函数fseek(pfOLSEEK_END)中的SEEK_END代表的起始点是 A)文件开始 B)文件末尾 C)文件当前位置 D)以上都不对
(50)有以下程序 #includestdio.h main() {FILE*fp;inti=20j=30kn; fp=fopen(d
1.datw); fprintf(fp%d\ni);fprintf(fp%d\nj); fclose(fp); fp=fopen(d
1.datr); fscanf(fp%d%d,kn);printf(%d%d\nkn); fclose(fp); } 程序运行后的输出结果是 A)2030 B)2050 C)3050 D)3020
二、填空题
(6)以下程序的运行结果是【6】#defineMAX(ab)(aba:b)+1main (){inti=6j=8k;printf(%d\nMAX(ij));}解析本题考查宏定义与三目运算符的综合用法,宏定义是原样替换,本题中,如果ab成立,则a+1的值为整个表达式的值,否则为b+1的值为整个表达式的值,(应注意后面的加1)
(7)以下程序的功能是从健盘输入若干学生的成绩,并输出最高成绩和最低成绩,当输入负数时结束请填空main(){floatxamaxamin;scanf(%fx);amax=x;amin=x;while(【7】){if(xamax)amax=x;elseif【8】amin=x; elsescanf(%fx);}printf(\namax=%f\namin=%f\namaxamin);}解析本题先从键盘接受数值,并分别赋给amax(用于保存最高成绩)和amin(用干保存最低成绩),然后通过while循环控制是否结束输入,并且通过if语句来给amax和amin赋值和进行下一次的输入
(8)在对文件操作的过程中,若要求文件的位置指针回到文件的开始处,应当调用的函数是【9】答案;rewind
(9)在计算机中,字符的比较是对它们的【10】进行比较解析C语言中,字符也可以进行比较运算,且是按照ASCII码值进行的
(10)在内存中,存储字符′x′要占用1个字节,存储字符串″X″要占用【11】个字节解析计算机存储一个字符用1个字节,存储字符串时,每个字符用占用1个字节,另在字符串的有效字符之后存储1个字符串的结束标记符所以存储字符串“X”要占用2个字节,存储字符′x′只要1个字节
(11)下列程序的输出结果是
16.00,请填空main(){inta=9b=2;floatx=【12】y=
1.1z;z=a/2+b*x/y+1/2;printf(%
5.2f\nz);}解析本题最后一条语句,表示以浮点格式输出z的值,宽度为5,其中所含2位小数,应该注意的是,两个整型运算结果仍为整型,如1/2的结果为0,对本题可逐步求解
16.00=9/2+2*x/
1.1+1/
216.00=4+2*x/
1.1+
012.00=2*x/
1.1所以,x的值为
6.6
(12)设在主函数中有以下定义和函数调用语句,且fun函数为void类型;请写出fun函数的首部【13】要求形参名为bmain(){doubles[10][22];intn;┆┆fun(s);┆}解析本题中,为了明确表示“不带回值”,可以用“void”定义“无类型”(或称“空类型”)这系统就保证不使函数带回任何值,二维数组的第一维可以省略
(13)下列程序的功能是输入一个整数,判断是否是素数,若为素数输出1,否则输出0,请填空main(){intixy=1;scanf(%dx);for(i=2;i=x/2;i++)if【14】{y=0;break;}printf(%d\ny);}解析为判数x是否是素数,预置变量y的值为1(x可能是素数),然后用循环,用2至x/2的整数i测试对x的整除性,若能被其中的某个整数整除,则x是合数,置y的值为0(x不是素数),结束测试循环若都不能整除,则x为素数i能否整除x,可用求余运算x%i等于0来判定所以程序中的空框可填x%i==0测试x为素数的代码可写成y=1;for(i=2;i=x/2;i++)if(x%i==0){y=0;break;}
(14)下面程序的功能是将一个字符串str的内容颠倒过来,请填空#includestring.hmain(){intij【15】;charstr[]={1234567};for(i=0j=strlen(str)【16】;ij;i++j--){k=str[i];str[i]=str[j];str[j]=k;}printf(%s\nstr);}解析颠倒一个字符串中的字符,就是首尾对应的元素两两交换简单地可用两个游标变量i和j,i是前端元素的下标,j是后端元素的下标,交换以这两个变量值为下标的元素str[i]和str[j]开始时,i的值为0,j的值为字符串末元素的下标(字符串长度减1)每次交换后,i增1,j减1继续交换的条件是str[i]还位于str[j]的前面,即ij字符串末元素的下标是它的长度减1,所以在第二个空框处应填入-1程序为了交换str[i]和str[j],使用了变量k,该变量应在程序的变量定义部分中一起定义,所以在第一个空框处应填入k
(15)以下程序可把输入的十进制数以十六进制数的形式输出,请填空main(){charb[17]={0123456789ABCDEF};intc[64]di=0base=16;longn;printf(Enteranumber:\n);scanf(%ldn);do{c[i]=【17】;i++;n=n/base;}while(n!=0);printf(Transmitenewbase:\n);for(--i;i=0;--i){d=c[i];printf(%cb【18】);}printf(\n);}解析程序中,字符数组b存储十六进制的16个数字符,整型数组c存储译出的十六进制数的各位数值从整数n译出它的各位十六进制数值,需采用除16取余的方法,即求n除16的余,得到它的十六进制的个位数,接着将n除以16在n不等于0的情况下循环,能顺序求出n的十六进制的个位数、十位数、百位数等等程序中变量base已预置16,所以在第1个空框处可填代码n%base当n的十六进制数的个位、十位、百位等依次存放于数组c中后,就从最高位至最低位,参照数组c[i]的内容d(以其内容为下标),取十六进制数字符表中的字符b[d]输出所以在第2个空框处可填入代码[d]
(16)若给fun函数的形参s传送字符串“]]6354abcc”(其中]表示空格字符),则函数的返回值是【19】#includectype.hlongfun(chars[]){longn;intsign;for(;isspace(*s);s++);sign=(*s==′-′)-1:1;if(*s==′+′||*s==′-′)s++;for(n=0;isdigit(*s);s++)n=10*n+(*s-′0′);returnsign*n;}解析函数fun的第一个for循环跳过字符串的前导空白符,接着判断第一个非空白符是否是负号,若是则置变量sign为-1;否则,置变量sign为1接着的if语句在第一个非空白字符是负号或正号时,跳过该字符以后的for循环将后面的数字符当作十进制数的各位数字译出一个长整数n遇字符a时,结束循环最后,函数返回sign与n的乘积所以若调用函数时提供的实参是“∪∪6354abc”,函数返回值是6354
(17)设有定义“struct{inta;floatb;charc;}abc*p_abc=abc;”,则对结构体成员a的引用方法可以是abc.a和p_abc【20】a解析若有结构变量abc有成员a,并有指针p_abc指向结构变量abc,则引用变量abc成员a的标记形式有abc.a和p_abc-a
一、选择题11-15 D D A A A16-20 C C A C D21-25 B D A C D26-30 D C D D B31-35 C D B B A36-40 B C B C C41-45 D D D A C 46-50 A C B B A试题
三一、选择题
(11)以下叙述中正确的是 A)构成C程序的基本单位是函数 B)可以在一个函数中定义另一个函数 C)main()函数必须放在其他函数之前 D)C函数定义的格式是KR格式
(12)结构化程序所规定的三种最基本控制结构是 A)输入、处理、输出 B)树形、网形、环形 C)顺序、选择、循环 D)主程序、子程序、函数
(13)一个C语言程序是由 A)一个主程序和若干子程序组成 B)函数组成 C)若干过程组成 D)若干子程序组成
(14)请选出可用作C语言用户标识符的是 A)voiddefineWORD B)a3_b3_123IF C)FOR--abcCase D)2aDoSizeof
(15)下列各数据类型不属于构造类型的是 A)枚举型 B)共用型 C)结构型 D)数组型
(16)在16位C编译系统上,若定义longa;,则能给a赋40000的正确语句是 A)a=20000+20000; B)a=4000*10; C)a=30000+10000; D)a=4000L*10L
(17)以下不正确的叙述是 A)在C程序中,逗号运算符的优先级最低 B)在C程序中,APH和aph是两个不同的变量 C)若a和b类型相同,在计算了赋值表达式a=b后b中的值将放入a中,而b中的值不变 D)当从键盘输入数据时,对于整型变量只能输入整型数值,对于实型变量只能输入实型数值
(18)sizeof(float)是 A)一个双精度型表达式 B)一个整型表达式 C)一种函数调用 D)一个不合法的表达式
(19)若xij和k都是int型变量,则计算表达式x=(i=4j=16k=32)后,x的值为 A)4 B)16 C)32 D)52
(20)下面程序的功能是把316表示为两个加数的和,使两个加数分别能被13和11整除,请选择填空 #includestdio.h main() {inti=0jk; do{i++;k=316-13*i;}while(______); j=k/11; printf(316=13*%d+11*%dij); } A)k/11 B)k%11 C)k/11==0 D)k%11==0
(21)设有定义intn=0*p=n**q=p则下列选项中正确的赋值语句是 A)p=1; B)*q=2; C)q=p; D)*p=5;
(22)下面程序的运行结果是 #includestdio.h main() {inty=10; do{y--;}while(--y); printf(%d\ny--); } A)-1 B)1 C)8 D)0
(23)下面程序的输出结果是 main() {inta[10]={12345678910}*p=a; printf(%d\n*(p+2));} A)3 B)4 C)1 D)2
(24)有如下程序 inta[10]={12345678910}; int*p=a[3]b;b=p[5]; 则b的值是 A)5 B)6 C)9 D)8
(25)设有intx=11;则表达式(x++*1/3)的值是 A)3 B)4 C)11 D)12
(26)请选出以下语句的输出结果 printf(%d\nstrlen(\t\\065\xff\n)); A)5 B)14 C)8 D)输出项不合法,无正常输出
(27)下列程序的输出结果是 main() {doubled=
3.2;intxy; x=
1.2;y=(x+
3.8)/
5.0; printf(%d\nd*y); } A)3 B)
3.2 C)0 D)
3.07
(28)下列程序的输出结果是 intb=2; intfunc(int*a) {b+=*a;return(b);} main() {inta=2res=2; res+=func(a); printf(%d\nres); } A)4 B)6 C)8 D)10
(29)下面能正确进行字符串赋值操作的是 A)chars[5]={ABCDE}; B)chars[5]={′A′′B′′C′′D′′E′}; C)char*s;s=ABCDE; D)char*s;chara;scanf(%ss);
(30)执行以下程序后,ab的值分别为 main() {intabk=4m=6*p1=k*p2=m; a=p1==m; b=(*p1)/(*p2)+7; printf(a=%d\na); printf(b=%d\nb); } A)-15 B)16 C)07 D)410
(31)设有数组定义:chararray[]=China;则数组array所占的空间为 A)4个字节 B)5个字节 C)6个字节 D)7个字节
(32)若已定义: inta[]={0123456789}*p=ai; 其中0≤i≤9则对a数组元素不正确的引用是 A)a[p-a] B)*(a[i]) C)p[i] D)a[10]
(33)以下不正确的定义语句是 A)doublex[5]={
2.
04.
06.
08.
010.0}; B)inty[5]={013579}; C)charc1[]={′1′′2′′3′′4′′5′}; D)charc2[]={′\x10′′\xa′′\x8′};
(34)若有以下程序 #include stdio.h inta[]={2468}; main() {inti; int*p=a; for(i=0;i4;i++)a[i]=*p; printf(%d\na[2]); } 上面程序输出结果是 A)6 B)8 C)4 D)2
(35)下面程序段的运行结果是 char*format=%sa=%db=%d\n; inta=11b=10; a+=b; printf(formata+=bab); A)fora+=bab B)formata+=b C)a+=ba=21b=10 D)以上结果都不对
(36)C语言允许函数类型缺省定义,此时函数值隐含的类型是 A)float B)int C)long D)double
(37)以下程序有语法错误,有关错误原因的正确说法是 main() {intG=5k; voidprt_char(); ... k=prt_char(G); ... } A)语句voidprt_char();有错,它是函数调用语句,不能用void说明 B)变量名不能使用大写字母 C)函数说明和函数调用语句之间有矛盾 D)函数名不能使用下划线
(38)以下叙述中不正确的是 A)在不同的函数中可以使用相同的名字的变量 B)函数中的形式参数是局部变量 C)在一个函数内定义的变量只在本函数范围内有效 D)在一个函数内的复合语句中定义的变量在本函数范围内有效
(39)有以下程序 #includestdio.h unionpw {inti; charch[2];}a; main() {a.ch[0]=13;a.ch[1]=0;printf(%d\na.i);} 程序的输出结果是 A)13 B)14 C)208 D)209
(40)在16位IBM-PC机上使用C语言,若有如下定义 structdata {inti; charch; doublef; }b; 则结构变量b占用内存的字节数是 A)1 B)2 C)7 D)11
(41)下面程序的运行结果是 #includestdio.h main() {inta=1b=10; do {b-=a;a++;}while(b--0); printf(a=%db=%d\nab); } A)a=3b=11 B)a=2b=8 C)a=1b=-1 D)a=4b=9
(42)以下程序的输出结果是 voidreverse(inta[]intn) {intit; for(i=0;in/2;i++) {t=a[i];a[i]=a[n-1-i];a[n-1-i]=t;} } main() {intb[10]={12345678910};intis=0; reverse(b8); for(i=6;i10;i++)s+=b[i]; printf(%d\ns); } A)22 B)10 C)34 D)30
(43)有如下程序 longfib(intn) {if(n2)return(fib(n-1)+fib(n-2)); elsereturn
(2); } main() {printf(%d\nfib
(3));} 该程序的输出结果是 A)2 B)4 C)6 D)8
(44)假定以下程序经编译和连接后生成可执行文件PROG.EXE,如果在此可执行文件所在目录的DOS提示符下键入 PROGABCDEFGHIJKL回车,则输出结果为 main(intargcchar*argv[]) {while(--argc0) printf(%sargv[argc]); printf(\n); } A)ABCDEFG B)IJHL C)ABCDEFGHIJKL D)IJKLABCDEFGH
(45)以下程序有错,错误原因是 main() {int*pi;char*qch; p=i; q=ch; *p=40; *p=*q; ...... } A)p和q的类型不一致,不能执行*p=*q;语句 B)*p中存放的是地址值,因此不能执行*p=40;语句 C)q没有指向具体的存储单元,所以*q没有实际意义 D)q虽然指向了具体的存储单元,但该单元中没有确定的值,所以执行*p=*q;没有意义,可能会影响后面语句的执行结果
(46)函数rewind的作用是 A)使文件位置指针重新返回文件的开始位置 B)将文件位置指针指向文件中所要求的特定位置 C)使文件位置指针指向文件的末尾 D)使文件位置指针自动移至下一个字符位置
(47)设有以下说明语句 structex {intx;floaty;charz;}example; 则下面的叙述中不正确的是 A)struct结构体类型的关键字 B)example是结构体类型名 C)xyz都是结构体成员名 D)structex是结构体类型名
(48)设有以下语句 charx=3y=6z; z=x^y2; 则z的二进制值是 A)00010100 B)00011011 C)00011100 D)00011000
(49)阅读以下程序及对程序功能的描述,其中正确的描述是 #includestdio.h main() { FILE*in*out; charchinfile[10]outfile[10]; printf(Entertheinfilename:\n); scanf(%sinfile); printf(Entertheoutfilename:\n); scanf(%soutfile); if((in=fopen(infiler))==NULL) { printf(cannotopeninfile\n); exit
(0); } if((out=fopen(outfilew))==NULL) { printf(cannotopenoutfile\n); exit
(0); } while(!feof(in))fputc(fgetc(in)out); fclose(in); fclose(out); } A)程序完成将磁盘文件的信息在屏幕上显示的功能 B)程序完成将两个磁盘文件合二为一的功能 C)程序完成将一个磁盘文件复制到另一个磁盘文件中 D)程序完成将两个磁盘文件合并并在屏幕上输出
(50)C语言中,能识别处理的文件为 A)文本文件和数据块文件 B)文本文件和二进制文件 C)流文件和文本文件 D)数据文件和二进制文件
二、填空题
(6)下面程序是指从终端读入的20个字符放入字符数组中,然后利用指针变量输出上述字符串,请填空#includestdio.hmain(){inti;char s[21]*p;for(i=0;i20;i++)s[i]=getchar();s[i]=【6】;p=【7】while(*p)putchar (【8】);}解析本题选通过for循环从键盘读入20个字符,然后在最后赋一定值′\0′后为结束标志,再使指针P指向字符串的首地址最后通过while循环对字符串进行扫描并输出
(7)以下程序将数组a的4个元素和数组b的6个元素写到名为lett.dat的二进制文件中,请填空#includestdio.hmain(){FILE *fp;chara[4]=1234,b[6]=abcedf;if((fp=fopen(【9】wb))=NULL)exit
(0);fwrite(asizeof(char)4fp);fwrite(b【10】1fp);fclose(fp);}解析本题主要考查函数fwrite(char*ptunsignedsizeunsignednFILE*fp)把pt所指向的n*size个字节输出到fp所指定的文件中
(8)在C语言中(以16位PC机为例),一个float型数据在内存中所占的字节数为4;一个double型数据在内存中所占的字节数为【11】解析在一般系统中,一个float型数据在内存中占4个字节(32位),一个double型数据占8个字节
(9)以下程序输出的结果是【12】main(){inta=5b=4c=3d;d=(abc);printf(%d\nd);}解析本题的关键在于对变量c的赋值运算d=(abc)d=
(543)先算53为真,得1,即d=
(13)此时13为假,得0
(10)以下函数的功能是求出能整除x且不是偶数的各整数,并按从小到大的顺序放在pp所指的数组中,这些除数的个数通过形参n返回例如,若x中的值为30,则有4个数符合要求,它们是1,3,5,15请按题意,完成填空试题程序#includeconio.h#includestdio.hvoidfun(intxintpp[]int*n){intij=0;【13】if(x%i==0)pp[j++]=i;【14】;}main(){int xaa[1000]ni;clrscr();printf(\nPleaseenteranintegernumber:\n);scanf(%dx);fun(xaan);for(i=0;in;i++)printf(%daa[i]);printf(\n);}解析本题题干信息是能整除且不是偶数的所有整数之和循环语句中i从1开始且每次增2,所以i始终是奇数,*n=j;语句是记录能够符合题意的各个整数的各数#includeconio.h#includestdio.hintfun(int*sinttint*k){inti;*k=0;【15】if(s[*k]s[i])*k=i;return【16】;}main(){inta[10]={876675896101301401980431451777}k;clrscr();fun(a10k);printf(%d%d\nka[k]);}解析本题中直接使用指针变量k,但在使用时要注意对k的指针运算,此外,一开始应认*k的值为数组中的某一下标值,即*k=0
(12)mystrlen函数的功能是计算str所指字符串的长度并作为函数值返回请填空intmystrlen(char*str){inti;for(i=0;【17】!=′\0′;i++);return(i);}解析str是指针变量,它指向字符型数据,在循环过程中,可以用*(str+i)来访问字符串中的第i个元素,判断是否是结束标志,如果不是,i=i+1,继续取下一个元素进行判断,直到*(str+i)的值为′\0′为止,也可以用下标的方式引用字符,如*(str+i)相当于str[i]
(13)以下程序的输出结果为【18】#defineJFT(x)x*xmain(){intak=3;a=++JFT(k+1);printf(%da);}解析宏替换的原则是按原样替换,本题中遇到形参x则以实参k+1替换,其他字符不变所以JFT(k+1)经替换后为k+1*k+1,所以a=++k+1*k+1,若k+1,若k的值为3,则经过运算为a=4+1*4+1=9
(14)以下定义的结构体类型拟包含两个成员其中成员变量info用来存入整形数据;成员变量link是指向自身结构体的指针,请将定义补充完整structnode{intinfo;【19】link;};解析本题中的结构类型名为structnode,所以空白处应填structnode*即定义一个指向自身的结构体指针
(15)设有以下结构体类型structst{charname[8];intnum;floats[4];}student[50];并且结构体数组student中的元素都已有值,若要将这些元素写到硬盘文件fp中,请将以下fwrite语句补充完整fwrite(student【20】1fp);解析fwrite函数的一般调用形式为fwrite(buffersizecountfp),其中buffer是一个指针变量,是要输出数据的起始地址size要写的字节数count要进行写多少个size字节的数据项fp文件型指针
一、选择题 11-15 A C B B A 16-20 D D B C B 21-25 D D A C A 26-30 A C B C C 31-35 C D B D C 36-40 B C D A D 41-45 B A B D D 46-50 A B B C B 试题
四一、选择题
(11)C语言规定,在一个源程序中,main函数的位置 A)必须在最开始 B)必须在系统调用的库函数的后面 C)可以任意 D)必须在最后
(12)下列数据中,不合法的C语言实型数据的是 A)
0.123 B)123e3 C)
2.1e
3.5 D)
789.0
(13)下面四个选项中,均是不合法的用户标识符的选项是 A)A P_0 do B)float la0 _A C)b-a goto int D)_123 temp int
(14)设变量a是int型,f是float型,i是double型,则表达式10+′a′+i*f值的数据类型为 A)int B)float C)double D)不确定
(15)能正确表示逻辑关系“a≥10或a≤0”的C语言表达式是 A)a=10ora=0 B)a=0|a=10 C)a=10a=0 D)a=10‖a=0
(16)设以下变量均为int类型,表达式的值不为7的是 A)(x=y=6x+yx+1) B)(x=y=6x+yy+1) C)(x=6x+1y=6x+y) D)(y=6y+1x=yx+1)
(17)若有说明int*pm=5n;以下正确的程序段是 A)p=n;scanf(%dp); B)p=n;scanf(%d*p) C)scanf(%dn);*p=n; D)p=n;*p=m;
(18)以下程序段的输出结果是 inta=1234; printf(%2d\na); A)12 B)34 C)1234 D)提示出错、无结果
(19)若变量a是int类型,并执行了语句a=′A′+
1.6;,则正确的叙述是 A)a的值是字符C B)a的值是浮点型 C)不允许字符型和浮点型相加 D)a的值是字符′A′的ASCII值加上1
(20)有如下程序 main() {inta=2b=-1c=2; if(ab) if(b0)c=0; elsec++; printf(%d\nc); } 该程序的输出结果是 A)0 B)1 C)2 D)3
(21)有如下程序 main() {intx=23; do {printf(%dx--);} while(!x); } 该程序的执行结果是 A)321 B)23 C)不输出任何内容 D)陷入死循环
(22)执行语句for(i=1;i++4;);后变量i的值是 A)3 B)4 C)5 D)不定
(23)有一堆零件(100到200之间),如果分成4个零件一组的若干组,则多2个零件;若分成7个零件一组,则多3个零件;若分成9个零件一组,则多5个零件下面程序是求这堆零件总数,请选择填空 #includestdio.h main() {inti; for(i=100;i200;i++) if((i-2)%4==0) if(!((i-3)%7)) if(_______) printf(%di); } A)i%9=5 B)i%9!=5 C)(i-5)%9!=0 D)(i-5)%9==0
(24)已有定义inta=-2;和输出语句printf(%8lxa);以下正确的叙述是 A)整型变量的输出形式只有%d一种 B)%x是格式符的一种,它可以适用于任何一种类型的数据 C)%x是格式符的一种,其变量的值按十六进制输出,但%8lx是错误的 D)%8lx不是错误的格式符,其中数字8规定了输出字段的宽度
(25)若变量c为char类型,能正确判断出c为小写字母的表达式是 A)′a′=c=′z′ B)(c=′a′)||(c=′z′) C)(′a′=c)and(′z′=c) D)(c=′a′)(c=′z′)
(26)以下正确的说法是 A)用户若需调用标准库函数,调用前必须重新定义 B)用户可以重新定义标准库函数,若如此,该函数将失去原有含义 C)系统根本不允许用户重新定义标准库函数 D)用户若需调用标准库函数,调用前不必使用预编译命令将该函数所在文件包括到用户源文件中,系统自动调用
(27)以下正确的函数头定义形式是 A)doublefun(intxinty) B)doublefun(intx;inty) C)doublefun(intxinty); D)doublefun(intxy);
(28)下面程序段的运行结果是 chara[]=lanuage*p; p=a; while(*p!=′u′){printf(%c*p-32);p++;} A)LANGUAGE B)language C)LAN D)langUAGE
(29)下面程序段的运行结果是 charstr[]=ABC*p=str; printf(%d\n*(p+3)); A)67 B)0 C)字符′C′的地址 D)字符′C′
(30)若fp是指向某文件的指针,且已读到文件末尾,则库函数feof(fp)的返回值是 A)EOF B)-1 C)1 D)NULL
(31)在C语言中,char型数据在内存中的存储形式是 A)补码 B)反码 C)原码 D)ASCII码
(32)若有说明inta[][3]={1234567};则a数组第一维的大小是 A)2 B)3 C)4 D)无确定值
(33)以下不正确的定义语句是 A)doublex[5]={
2.
04.
06.
08.
010.0}; B)inty[
5.3]={013579}; C)charc1[]={′1′′2′′3′′4′′5′}; D)charc2[]={′\x10′′\xa′′\x8′};
(34)有以下语句,则对a数组元素的引用不正确的是(0≤i≤9) inta[10]={0123456789}*p=a; A)a[p-a] B)*(a[i]) C)p[i] D)*(*(a+i))
(35)当说明一个结构体变量时系统分配给它的内存是 A)各成员所需内存量的总和 B)结构中第一个成员所需内存量 C)成员中占内存量最大者所需的容量 D)结构中最后一个成员所需内存量
(36)有以下程序 fun(intxintyintz) {z=x*y;} main() {inta=4b=2c=6; fun(abc); printf(%dc); } 程序运行后的输出结果是 A)16 B)6 C)8 D)12
(37)函数fun的返回值是 fun(char*achar*b) {intnum=0n=0; while(*(a+num)!=′\0′)num++; while(b[n]){*(a+num)=b[n];num++;n++;} returnnum; } A)字符串a的长度 B)字符串b的长度 C)字符串a和b的长度之差 D)字符串a和b的长度之和
(38)以下叙述中不正确的是 A)预处理命令行都必须以#号开始 B)在程序中凡是以#号开始的语句行都是预处理命令行 C)宏替换不占用运行时间,只占编译时间 D)在以下定义是正确的 #definePI
3.1415926;
(39)调用gets和puts函数时,必须包含的头文件是 A)stdio.h B)stdlib.h C)define D)以上都不对
(40)利用fseek函数可以实现的操作是 A)改变文件的位置指针 B)文件的顺序读写 C)文件的随机读写 D)以上答案均正确
(41)下列程序的输出结果是 main() {inta[5]={246810}*p**k; p=a; k=p; printf(%d*(p++)); printf(%d\n**k); } A)4 B)22 C)24 D)46
(42)若有以下结构体,则正确的定义或引用的是 structTest {intx; inty; }vl; A)Test.x=10; B)Testv2;v
2.x=10; C)structv2;v
2.x=10; D)structTestv2={10};
(43)下面程序段的运行结果是 char*p=abcdefgh; p+=3; printf(%d\nstrlen(strcpy(pABCD))); A)8 B)12 C)4 D)7
(44)下面判断正确的是 A)char*a=china;等价于char*a;*a=china; B)charstr[5]={china};等价于charstr[]={china}; C)char*s=china;等价于char*s;s=china; D)charc[4]=abcd[4]=abc;等价于charc[4]=d[4]=abc;
(45)下列函数的运行结果是 main() {inti=2p; intjk; j=i; k=++i; p=f(jk); printf(%dp); } intf(intaintb) {intc; if(ab)c=1; elseif(a==b)c=0; elsec=-1; return(c); } A)-1 B)1 C)2 D)编译出错,无法运行
(46)在位运算中,操作数左移一位,其结果相当于 A)操作数乘以2 B)操作数除以2 C)操作数除以4 D)操作数乘以4
(47)若调用fputc函数输出字符成功,则其返回值是 A)EOF B)1 C)0 D)输出的字符
(48)已知函数的调用形式fread(bufsizecountfp)参数buf的含义是 A)一个整型变量,代表要读入的数据项总数 B)一个文件指针,指向要读的文件 C)一个指针,指向要读入数据的存放地址 D)一个存储区,存放要读的数据项
(49)有如下程序 #define N 2 #define M N+1 #define NUM 2*M+1 main() { inti; for(i=1;i=NUM;i++)printf(%d\ni); } 该程序中的for循环执行的次数是 A)5 B)6C)7 D)8
(50)以下定义中,标识符prtint(*prt)[3] A)定义不含法 B)是一个指针数组名,每个元素都是一个指向整数变量的指针 C)是一个指针,它指向一个具有三个元素的一维数组 D)是一个指向整型变量的指针
二、填空题
(6)以下程序段的输出结果是【6】main(){inta=2,b=3,c=4;a*=16+(b++)-(++c);printf(%da);}解析a*=16+(b++)-(++c)等价于a=a*(16+(b++)-(++c)),b++的值为3++c的值为5请注意前缀++和后缀++的用法
(7)若变量n中的值为24,则print()函数共输出【7】行,最后一行有【8】个数voidprint(intnintaa[]){inti;for(i=1; i1;i++){printf(%6daa[i]);if(!(i%5))printf(\n);}printf(\n);}解析语句if(!(i%))printf(\n);是将每5个数输出一行,因为n的值为24所以共输出5行,最后一行有4个数
(8)调用C语标准库函数时要求用【9】命令解析include命令可调用标准的C语言库函数,可以用一对括号或一对双引号,但要在前面加#
(9)stract函数的作用是【10】解析连接两个字符数组中的字符串
(10)C语言程序的注释可以出现在程序中的任何地方,一个注释以【11】作为开始和结束解析C语言程序的注释可以出现在程序基本单词之间的任何地方,C语言程序的注释以′/*′作为开始标记,并以′*/′作为结束标记
(11)设二进制数A是00101101,若想通过异或运算A^B使A的高4位取反,低4位不变,则二进制数B应是【12】解析按位异成运算的一个重要应用是让某个整型变量的二进位取反,0变成1,而1变成0这只要设计这样一个位串信息,让要变反的位为1,不要改变的位为0,用这个位串信息与整型变量按位加就能得到希望的结果要使字节的高4位取反,低4位不变,则需要位串信息是11110000
(12)若已知a=10,b=20,则表达式!ab的值为【13】解析计算表达式!ab,先计算!a,因a的值为10,!a的值为0关系表达式020为真,所以表达式!ab的值为1
(13)设i,j,k均为int型变量,则执行完下面的for语句后,k的值为【14】for(i=0j=10;i=j;i++j--)k=i+j;解析该for语句以i为0,j为10初始化,循环条件是i=j,每次循环后i增
1、j减1,循环体是将i与j的和赋给k这样变量k将保存的是最后一次赋给它的值一次循环后i为
1、j为9,二次循环后i为
2、j为8,……,五次循环后i为
5、j为5,继续第六次循环,将i与j的和10存于k后,i为
6、j为4,结束循环所以循环执行后k为10
(14)下面函数的功能是找出一维数组元素中最大的值和它所在的下标,最大值的和它所在的下标通过形参传回数组元素中的值已在主函数中赋予主函数中x是数组名,n是x中的数据个数,max存放最大值,index存放最大值所在元素的下标请填空#includestdlib.h#includestdio.hvoidfun(inta[]intnint*maxint*d){inti;*max=a[0];*d=0;for(i=0;【15】;i++)if(*max【16】){*max=a[i];*d=i;}}main(){intix[20]max indexn=10;randomize();for(i=0;in;i++){x[i]=rand()%50;printf(%4dx[i]);}printf(\n);fun(xnmaxindex);printf(Max=%5dIndex=%4d\nmaxindex);}解析该程序直接使用形参max和d,由于它们都是指针变量,所以要引用它所指向的变量时要对它进行指针运算,也即*号运算
(15)以下程序的输出结果是【17】voidfun(){staticinta=0;a+=2;printf(%da);}main(){intcc;for(cc=1;cc4;cc++)fun();printf(\n);}解析本题考查静态局部变量的使用用关键字static声明的局部变量为静态局部变量,其值在函数调用结束后不消失而保留原值,即其占用的存储单元不释放,在下一次该函数调用时,该变量已有值,就是上一次函数调用结束时的值
(16)以下程序的输出结果是【18】#defineMAX(xy)(x)(y)(x):(y)main(){inta=5b=2c=3d=3t;t=MAX(a+bc+d)*10;printf(%d\nt);}解析本题综合考查带参数的宏以及三目运算符的计算方法,“”运算符是一个三目运算符,其一般形式是表达式1表达式2:表达式3“”运算符的含义是先求表达式1的值,如果为真,则求表达式2的值并把它作为整个表达式的值;如果表达式1的值为假,则求表达式3的值并把它作为整个表达式的值注意,在本题中宏替换时可采用逐步求解,最终为767:6*10,即t=767:60,其值为t=7
(17)用以下语句调用库函数malloc,使字符指针st指向具有11个字节的动态存储空间,请填空st=(char*)【19】;解析malloc函数的参数可以是一个具体的常数,也可以是一个表达式在本题中,可以是malloc
(11),也可以借助于sizeof运算符来表示
(18)以下程序段打开文件后,先利用fseek函数将文件位置指针定位在文件末尾,然后调用ftell函数返回当前文件位置指针的具体位置,从而确定文件长度,请填空FILE*myf;longf1;myf=【20】(test.trb);fseek(myf0SEEK_END);f1=ftell(myf);fclose(myf);printf(%d\nf1);解析函数fopen的原型为FILE*fopen(char*filenamechar*mode)功能为以mode指定的方式打开名为filename的文件;函数fseek的原型为intfseek(FILE*fplongoffsetintbase)功能为将fp所指向的文件的位置指针移到以base所指出的位置为基准以offset是以字节为单位的位移量;函数ftell的原型为longftell(FILE*fp)功能为返回fp所指向的文件中的读写位置;函数fclose的原型为intfclose(FILE*fp)功能为关闭fp所指的文件,释放文件缓冲区
一、选择题11-15 C C C C D16-20 C D C D C21-25 B C D D B26-30 B A C B C31-35 D B B D A36-40 B D D A D41-45 C D C C A46-50 A D C B D试题
五一、选择题
(11)以下叙述不正确的是 A)一个C源程序可由一个或多个函数组成 B)一个C源程序必须包含一个main函数 C)C程序的基本组成单位是函数 D)在C程序中,注释说明只能位于一条语句的后面
(12)在C语言中,intchar和short三种类型数据在内存中所占用的字节数 A)由用户自己定义 B)均为2个字节 C)是任意的 D)由所用机器的机器字长决定
(13)以下叙述正确的是 A)在C程序中,每行中只能写一条语句 B)若a是实型变量,C程序中允许赋值a=10,因此实型变量中允许存放整型数 C)在C程序中,无论是整数还是实数,都能被准确无误地表示 D)在C程序中,%是只能用于整数运算的运算符
(14)C语言中的标识符只能由字母,数字和下划线三种字符组成,且第一个字符 A)必须为字母 B)必须为下划线 C)必须为字母或下划线 D)可以是字母,数字和下划线中任一字符
(15)已知各变量的类型说明如下 intkab; unsignedlongw=5; doublex=
1.42; 则以下不符合C语言语法的表达式是 A)x%(-3) B)w+=-2 C)k=(a=2b=3a+b) D)a+=a-=(b=4)*(a=3)
(16)x,y,z被定义为int型变量,若从键盘给x,y,z输入数据,正确的输入语句是 A)INPUTx、y、z; B)scanf(%d%d%dxyz); C)scanf(%d%d%dxyz); D)read(%d%d%dxyz);
(17)设x、y均为整型变量,且x=10y=3,则以下语句的输出结果是 printf(%d%d\nx----y); A)103 B)93 C)92 D)102
(18)以下程序的输出结果是 main() {inta=4b=5c=0d; d=!a!b||!c; printf(%d\nd);} A)1 B)0 C)非0的数 D)-1
(19)执行下列程序时输入:123空格456空格789回车输出结果是 main() {chars[100];intci; scanf(%cc);scanf(%di);scanf(%ss); printf(%c%d%s\ncis);} A)123456789 B)1456789 C)123456789 D)123456
(20)下面有关for循环的正确描述是 A)for循环只能用于循环次数已经确定的情况 B)for循环是先执行循环体语句,后判断表达式 C)在for循环中,不能用break语句跳出循环体 D)for循环的循环体语句中,可以包含多条语句,但必须用花括号括起来
(21)以下程序的输出结果是 main() {intijx=0; for(i=0;i2;i++) {x++; for(j=0;j3;j++) {if(j%2)continue; x++; } x++; } printf(x=%d\nx); } A)x=4 B)x=8 C)x=6 D)x=12
(22)设有以下程序段 intx=0s=0; while(!x!=0)s+=++x; printf(%ds); 则 A)运行程序段后输出0 B)运行程序段后输出1 C)程序段中的控制表达式是非法的 D)程序段执行无限次
(23)对下Ⅰ,Ⅱ两个语句描述正确的是 Ⅰ.while
(1)Ⅱ.for(;;) A)都是无限循环 B)Ⅰ是无限循环,Ⅱ错误 C)Ⅰ循环一次,Ⅱ错误 D)以上答案都错
(24)若有以下定义,则能使值为3的表达式是 intk=7x=12; A)x%=(k%=5) B)x%=(k-k%5) C)x%=k-k%5 D)(x%=k)-(k%=5)
(25)设有 inta=1b=2c=3d=4m=2n=2; 执行(m=ab)(n=cd)后n的值是 A)1 B)2 C)3 D)4
(26)以下描述中正确的是 A)由于do-while循环中循环体语句只能是一条可执行语句,所以循环体内不能使用复合语句 B)do-while循环由do开始,用while结束,在while(表达式)后面不能写分号 C)在do-while循环体中,是先执行一次循环,再进行判断 D)do-while循环中,根据情况可以省略while
(27)以下函数返回a所指数组中最小的值所在的下标值 fun(int*aintn) {intij=0p; p=j; for(i=j;in;i++) if(a[i]a[p])________; return(p);} 在下划线处应填入的是 A)i=p B)a[p]=a[i] C)p=j D)p=I
(28)以下叙述正确的是A)函数可以嵌套定义但不能嵌套调用 B)函数既可以嵌套调用也可以嵌套定义C)函数既不可以嵌套定义也不可以嵌套调用D)函数可以嵌套调用但不可以嵌套定义
(29)若有说明语句 chara[]=Itismine; char*p=Itismine; 则以下不正确的叙述是 A)a+1表示的是字符t的地址 B)p指向另外的字符串时,字符串的长度不受限制 C)p变量中存放的地址值可以改变 D)a中只能存放10个字符
(30)以下程序的运行结果是 sub(intxintyint*z) {*z=y-x;} main() {intabc; sub(105a); sub(7ab); sub(abc); printf(%4d%4d%4d\nabc);} A)523 B)-5-12-7 C)-5-12-17 D)5-2-7
(31)若二维数组a有m列,则计算任一元素a[i][j]在数组中相对位置的公式为(假设a[0][0]位于数组的第一个位置上) A)i*m+j B)j*m+I C)i*m+j-1 D)i*m+j+1
(32)下列说法正确的是 intix; for(i=0x=0;i=9x!=876;i++)scanf(%dx); A)最多的执行10次 B)最多执行9次 C)是无限循环 D)循环体一次也不执行
(33)若有下面的程序片段 int[12]={0}*p[3]**ppi; for(i=0;i3;i) p[i]=a[i*4]; pp=p; 则对数组元素的错误引用是 A)pp[0][1] B)a[10] C)p[3][1] D)*(*(p+2)+2)
(34)若有说明inta[3][4]={0};则下面正确的叙述是 A)只有元素a[0][0]可得到初值0 B)此说明语句不正确 C)数组a中各元素都可得到初值,但其值不一定为0 D)数组a中每个元素均可得到初值0
(35)对下面程序描述正确的一项是(每行程序前面的数字表示行号) 1 main() 2 { 3 floata[3]={
0.0}; 4 inti; 5 for(i=0;i3;i++)scanf(%da[i]); 6 for(i=1;i3;i++)a[0]=a[0]+a[i]; 7 printf(%f\na[0]); 8 } A)没有错误 B)第3行有错误 C)第5行有错误 D)第7行有错误
(36)以下不正确的说法是 C语言规定 A)实参可以是常量,变量或表达式 B)形参可以是常量,变量或表达式 C)实参可以为任何类型 D)形参应与其对应的实参类型一致
(37)已有如下数组定义和f函数调用语句,则在f函数的说明中,对形参数组array的正确定义方式为 inta[3][4]; f(a); A)f(array[3][4]) B)f(intarray[3][]) C)f(intarray[][4]) D)f(intarray[][])
(38)下面程序的输出结果为 main() {intab;b=(a=3*5a*4a*5); printf(%db);} A)60 B)75 C)65 D)无确定值
(39)在位运算中,操作数右移一位,其结果相当于 A)操作数乘以2 B)操作数除以2 C)操作数乘以4 D)操作数除以4
(40)有以下结构体说明和变量的定义且指针p指向变量a指针q指向变量b则不能把结点b连接到结点a之后的语句是 structnode {chardata; structnode*next; }ab*p=a*q=b; A)a.next=q; B)p.next=b; C)p-next=b; D)(*p).next=q;
(41)下面程序的输出结果是 structst {intx; int*y; }*p; intdt[4]={10203040}; structstaa[4]={50dt[0]60dt[1]70dt[2]80dt[3]}; main() {p=aa; printf(%d\n++p-x); printf(%d\n(++p)-x); printf(%d\n++(*p-y));} A)10 20 20 B)50 60 21 C)51 60 21 D)60 70 31
(42)下面程序的输出结果是 #includestdio.h #includestring.h main() {char*p1=abc*p2=ABCstr[50]=xyz; strcpy(str+2strcat(p1p2)); printf(%s\nstr);} A)xyzabcABC B)zabcABC C)xyabcABC D)yzabcABC
(43)以下程序的输出结果是 longfun(intn) {longs; if(n==1||n==2)s=2; elses=n-fun(n-1); returns;} main() {printf(%ld\nfun
(3));} A)1 B)2 C)3 D)4
(44)以下所列的各函数首部中,正确的是 A)voidplay(var:Integervarb:Integer) B)voidplay(intab) C)voidplay(intaintb) D)Subplay(aasintegerbasinteger)
(45)不合法的main函数命令行参数表示形式是 A)main(intachar*c[]) B)main(intarcchar**arv) C)main(intargcchar*argv) D)main(intargvchar*argc[])
(46)有如下程序 main() {charch[2][5]={69378254}*p[2]; intijs=0; for(i=0;i2;i++)p[i]=ch[i]; for(i=0;i2;i++) for(j=0;p[i][j]′\0′;j+=2) s=10*s+p[i][j]-′0′; printf(%d\ns);} 该程序的输出结果是 A)69825 B)63825 C)6385 D)693825
(47)以下程序的输出结果是 unionmyun {struct {intxyz;}u; intk;}a; main() {a.u.x=4;a.u.y=5;a.u.z=6; a.k=0; printf(%d\na.u.x);} A)4 B)5 C)6 D)0
(48)以下程序的输出结果是 main() {charx=040; printf(%o\nx1);} A)100 B)80 C)64 D)32
(49)C语言中系统的标准输入文件是指 A)键盘 B)显示器 C)软盘 D)硬盘
(50)下面的程序执行后,文件test中的内容是 #includestdio.h voidfun(char*fnamechar*st) {FILE*myf;inti; myf=fopen(fnamew); for(i=0;istrlen(st);i++)fputc(st[i]myf); fclose(myf);} main() {fun(testnewworld);fun(testhello);} A)hello B)newworldhello C)newworld D)hellorld
二、填空题6)以下程序段的输出结果是【6】intx=17y=26;printf(%dy/=(x%=6));
(7)关系表达式xyz,用C语言的表达式为【7】
(8)若有如下定义,double a[100];则a数组元素的下标上限是【8】
(9)下面程序的输出结果【9】main(){enumteam{y1=4y2y3};printf(%dy3);}
(11)若有以下程序段:intc1=1c2=2c3;c3=
1.0/c2*c1;则执行后,c3中的值是【11】
(12)若有以下定义chara;intb;floatc;doubled;则表达式a*b+d-c值的类型为【12】
(13)设有代码“staticinta[3][4]={{1}{2}{3}};”,则a[1][1]和a[2][1]的值为【13】
(14)以下函数用来在w数组中插入xn所指向的存储单元中存放w数组中字符个数数组w中的字符已按从小到大的顺序排列,插入后数组w中的字符仍有序请填空voidfun(char*wcharxint*n){ intip;p=0;w[*n]=x;while(xw[p])p++;for(i=*n;ip;i--)w[i]=【14】;w[p]=x;++*n;}
(15)设intab=10;执行a=b2+1;后a的值是【15】
(16)以下程序的输出结果是【16】main(){intx=100a=10b=20ok1=5ok2=0;if(ab)if(b!=15)if(!ok1)x=1;elseif(ok2)x=10;elsex=-1;printf(%d\nx);}
(17)以下程序的输出结果是【17】main(){inty=9;for(;y0;y--)if(y%3==0){printf(%d--y);continue;}}
(18)以下函数的功能是【18】floatav(an)floata[];intn;{inti;floats;for(i=0s=0;in;i++)s=s+a[i];returns/n;}
(19)以下程序的输出结果是【19】#define PR(ar)printf(%dar)main(){intja[]={135791115}*p=a+5;for(j=3;j;j--)switch(j){case1:case2:PR(*p++);break;case3:PR(*(--p));}printf(\n);}
(20)以下程序的功能是处理由学号和成绩组成的学生记录,N名学生的数据已在主函数中放入结构体数组s中,它的功能是把分数最高的学生数据放在h所指的数组中,注意分数高的学生可能不只一个,函数返回分数最高学生的人数请填空#includestdio.h#define N 16typedef struct{charnum[10];int s;}STREC;int fun(STREC*aSTREC*b){intij=0max=a[0].s;for(i=0;iN;i++)if(maxa[i].s)max=a[i].s;for(i=0;iN;i++)ssif(【20】)b[j++]=a[i];returnj;}main(){STREC s[N]={{GA00585}{GA00376}{GA00269}{GA00485}{GA00191}{GA00772}{GA00864}{GA00687} {GA01585}{GA01391}{GA01264}{GA01491}{GA01166}{GA01764}{GA01864}{GA01672}};STRECh[N];intin;FILE*out;n=fun(sh);printf(The%dhighestscore:\nn);for(i=0;in;i++)printf(%s%4d\nh[i].numh[i].s);printf(\n);out=fopen(out
15.datw);fprintf(out%d\nn);for(i=0;in;i++);fprintf(out%4d\nh[i].s);fclose(out);}
一、选择题11-15 D D D C A 16-20 B D A D D21-25 B B A D B 26-30 C D D D B 31-35 A A C D C36-40 B C B B B41-45 C C A C C46-50 C D A A A
二、填空题
6、
57、xyyz
8、
999、
611、
012、double或双精度
13、0
014、w[i-1]
15、
8016、-
117、
85218、求出数组元素
19、9,9,11,
20、max==a[i]试题
六一、选择题
(11)以下说法错误的是 A)一个算法应包含有限个步骤 B)在计算机上实现的算法是用来处理数据对象的 C)算法中指定的操作不能通过已经实现的基本运算执行有限次后实现 D)算法的目的是为了求解
(12)下列选项中不是结构化程序基本结构的是 A)顺序结构 B)跳转分支结构 C)选择结构 D)循环结构
(13)已知intkm=1;执行语句k=-m++;后,k的值是 A)-1 B)0 C)1 D)2
(14)已知intm;floatk;正确的语句是 A)(intk)%m B)int(k)%m C)int(k%m) D)(int)k%m
(15)下面各选项中,均是C语言标识符的选项组是 A)33 we auto B)_23 me _3ew C)_43 3e_ else D)ER -DF 32
(16)已知intk;floatm=-3;执行语句k=m%2;后,变量k的值是 A)-1 B)0 C)1 D)语句有错误
(17)不能进行++和--运算的数据类型为 A)指针 B)整型 C)长整型 D)常量
(18)已知intk=10m=3n;则下列语句输出结果是 printf(%d\nn=(k%mk/m)); A)2 B)3 C)4 D)5
(19)已知inta;floatb;所用的scanf调用语句格式为 scanf(a//%db=%fab); 为了将数据3和
25.08分别赋给x和y,正确的输入应当是 A)
325.08Enter B)a=3b=
25.08Enter C)a//3b=
25.08Enter D)a//3Enterb=
25.08Enter
(20)当k的值不为0时,在下列选项中能够将k的值赋给变量mn的是 A)m=k=n B)(m=k)(n=k) C)(m=k)||(n=k) D)(k=m)(n=k)
(21)下列程序的运行结果是 #includestdio.h main() {intx=-9y=5z=8; if(xy) if(y0)z=0; elsez+=1; printf(%d\nz);} A)6 B)7 C)8 D)9
(22)现有定义intk=1;则执行语句while(++k4);后,k的值为 A)4 B)5 C)6 D)8
(23)以下程序的运行结果为 #includestdio.h main() {intmn; for(m=0n=10;mn;m+=3n--); printf(%d%d\nmn);} A)67 B)76 C)97 D)79
(24)阅读下列程序,程序的输出结果是 #includestdio.h main() { intmn; floatk; for(m=6;m2;m--) {k=0; for(n=m;n1;n--) k=k+m*n; } printf(%f\nk); } A)
5.000000 B)
15.000000 C)
25.000000 D)
35.000000
(25)下列程序的输出结果是 #includestdio.h main() {intia=0b=0; for(i=1;i10;i++) {if(i%2==0) {a++; continue;} b++;} printf(a=%db=%dab);} A)a=4b=4 B)a=4b=5 C)a=5b=4 D)a=5b=5
(26)下列选项可以正确表示字符型常量的是 A)′\r′ B)a C)\897 D)296
(27)下面对C语言的描述中,正确的是 A)函数一定有返回值,否则无法使用函数 B)C语言函数既可以嵌套定义又可以递归调用 C)在C语言中,调用函数时,只能将实参的值传递给形参 D)C语言程序中有调用关系的所有函数都必须放在同一源程序文件中
(28)阅读下面程序段,则执行后的结果为 #includestdio.h main() {intm=4n=2k; k=fun(mn); printf(%d\nk);} fun(intmintn) {return(m*m*m-n*n*n);} A)64 B)8 C)56 D)0
(29)阅读下面程序段,则执行后输出的结果是 #includestdio.h main() {charfun(charint); chara=′A′; intb=13; a=fun(ab); putchar(a);} charfun(charaintb) {chark; k=a+b; returnk;} A)A B)M C)N D)L
(30)编写求两个双精度数之和的函数,选项中正确的是 A)double add(doubleadoubleb) {doubles; s=a+b; returns;} B)double add(doubleab) {doubles; s=a+b; return(s);} C)double add(doubleadoubleb) {doubles; s=a+b; returns;} D)double add(ab) {doubleabs; s=a+b; return(s);}
(31)已知inta;则下面的说明指针变量p的语句正确的是 A)intp=a B)int*p=a C)int*p=a D)int*p=*a
(32)已知char**t;则变量t是 A)指向char变量的指针 B)指向指针的char变量 C)指向指针的指针 D)以上说法都不对
(33)阅读下面程序,执行后的结果为 #includestdio.h voidfun(int*aint*b) {intk; k=5; *a=k; *b=*a+k;} main() {int*a*bx=10y=15; a=x; b=y; fun(ab); printf(%d%d\n*a*b);} A)1015 B)515 C)510 D)1510
(34)阅读下面程序,在程序执行后的结果为 #includestdio.h int*fun(int*aint*b) {intm; m=*a; m+=*b-3; return(m);} main() {intx=21y=35*a=x*b=y; int*k; k=fun(ab); printf(%d\n*k);} A)53 B)21 C)35 D)14
(35)已知inta[10];则对a数组元素的正确引用是 A)a[10] B)a C)a+5 D)a[10-10]
(36)在C语言中,一维数组的定义方法为 类型说明符数组名 A)[常量表达式] B)[整型常量] C)[整型变量] D)[整型常量]或[整型表达式]
(37)阅读下列程序,则运行结果为 #includestdio.h fun() {static intx=5; x++; returnx;} main() { intix; for(i=0;i3;i++) x=fun(); printf(%d\nx);} A)5 B)6 C)7 D)8
(38)下列程序的输出结果是 #includestdio.h #defineM(xy)x%y main() { intam=12n=100; a=M(nm); printf(%d\na--);} A)2 B)3 C)4 D)5
(39)阅读下面程序,则程序段的功能是 #includestdio.h main() { intc[]={231562347034}ijt; for(i=1;i7;i++) { t=c[i];j=i-1; while(j=0tc[j]) {c[j+1]=c[j];j--;} c[j+1]=t;} for(i=0;i7;i++) printf(%dc[i]); putchar(′\n′);} A)对数组元素的升序排列 B)对数组元素的降序排列 C)对数组元素的倒序排列 D)对数组元素的随机排列
(40)阅读下列程序,则执行后的结果为 #includestdio.h main() {intc[][4]={1234567342135662323123456}; printf(%x%x\nc[2][2]*(*(c+1)+1));} A)3e6 B)625 C)565 D)3E6
(41)下列选项中错误的说明语句是 A)chara[]={′t′′o′′y′′o′′u′′\0′}; B)chara[]={toyou\0}; C)chara[]=toyou\0; D)chara[]=′toyou\0′;
(42)下述对C语言字符数组的描述中错误的是 A)字符数组的下标从0开始 B)字符数组中的字符串可以进行整体输入/输出 C)可以在赋值语句中通过赋值运算符“=”对字符数组整体赋值 D)字符数组可以存放字符串
(43)阅读下列程序,则在执行后,程序的运行结果为 #includestdio.h #includestring.h main() {chara[30]=nicetomeetyou!; strcpy(a+strlen(a)/2you); printf(%s\na);} A)nicetomeetyouyou B)niceto C)meetyouyou D)nicetoyou
(44)阅读下面程序,则执行后的结果是 #includestdio.h main() {charstr[]=tomeetme*p; for(p=str;pstr+7;p+=2)putchar(*p); printf(\n);} A)tomeetme B)tmem C)oete D)tome
(45)下面程序的文件名为t.exe,在DOS下输入的命令行参数如下ttomeetme回车 则程序输出的结果是 #includestdio.h main(argcargv) intargc;char*argv[]; {inti; printf(%d\nargc);} A)3 B)4 C)2 D)以上答案都不正确
(46)阅读下面程序,则执行后的结果为 #includestdio.h longfun(intn) {if(n2) return(fun(n-1)+fun(n-2)); elsereturn
(2);} main() {printf(%ld\nfun
(5));} A)10 B)15 C)20 D)以上3个答案都不正确
(47)已知如下定义,则sizeof(a)的值是 struct{inti; charc; doublea;}a; A)8 B)9 C)10 D)11
(48)已知函数的原形如下,其中结构体a为已经定义过的结构,且有下列变量定义 structa*f(intt1int*t2strcutat3structa*t4) structap*p1;inti; 则正确的函数调用语句为 A)p=f(10ipp1); B)p1=f(i++(int*)p1pp); C)p=f(i+1(i+2)*pp); D)f(i+1ipp);
(49)下面程序段的输出为 #includestdio.h main() {printf(%d\n122);} A)0 B)47 C)48 D)24
(50)假定当前盘符下有两个文本文件,如下 文件名 a
1.txt a
2.txt 内容 123# 321# 则下面程序段执行后的结果为 #includestdio.h voidfc(FILE*p) { charc; while((c=fgetc(p))!=′#′)putchar(c);} main() { FILE*fp; fp=fopen(a
1.txtr); fc(fp); fclose(fp); fp=fopen(a
2.txtr); fc(fp); fclose(fp); putchar(′\n′);} A)123321 B)123 C)321 D)以上答案都不正确
二、填空题
(6)定义inta=5b;则执行表达式b=++a*--a之后,变量b的值为【6】【命题目的】考查对于基本运算符的掌握情况【解题要点】++和--做前缀使用的时候,先对变量进行增1或减1,之后进行其他的运算【考点链接】赋值运算符的优先级仅仅高于逗号运算符
(7)以下程序的输出结果是【7】#includestdio.hmain(){inta=065; printf(%d\n--a);}【命题目的】考查对于数据的格式化输出的掌握情况【解题要点】八进制的65转换为十进制的53之后减1输出【考点链接】0开头的是八进制整数
(8)阅读下面程序,则执行后的输出结果是【8】#includestdio.hmain(){intxyz;x=1;y=2;z=3;if(xy)if(xz)printf(%dx);elseprintf(%dy);printf(%d\nz);}【命题目的】考查对于if语句的掌握情况【解题要点】C语言的语法规定else子句总是与前面最近的不带else的if相结合因为x不大于y所以执行printf(%d\nz);语句
(9)如下语句printf(%c\n′B′+40);在执行后的输出结果是【9】【命题目的】考查对于字符常量运算的掌握情况【解题要点】在C程序中的字符量可参与任何整数运算【考点链接】%c是以字符的形式输出
(10)阅读下面程序,则程序的执行结果为【10】#includestdio.hmain(){inta=30b=20z;z=fun(a+ba-b);printf(%d\nz);}fun(intaintb){intz;z=a/b;returnz;}【命题目的】考查对于函数的调用和返回值的掌握情况【解题要点】函数调用的时候,函数名字必须与所调用的函数名完全一致,形参与实参类型要一致,在没有给出函数返回值类型的情况下,默认为整形,当返回值为整型的函数放到主函数后面时,可以不需要事先说明就调用这个函数【考点链接】retrun既可以返回一个普通常量,也可以返回一个指针变量
(11)下面的程序实现的是指针p所指向的地址的n个数中,求出最大的和最小的数据,请填空fun(int*pintn){int*q; intmaxmin; max=min=*p; for(q=p;【11】;q++) if(【12】)max=*q; elseif(【13】)min=*q;}【命题目的】考查对于函数的地址传递的掌握情况【解题要点】通过地址传递可以在被调函数中对调用函数中的变量进行引用
(12)下面的函数fun的功能是将形参x的值转换成二进制数,所得二进制数的每一位放在一维数组中返回,二进制的最低位放在下标为0的元素中,其他依次类推,请填空 fun(intxintb[]){intk=0r;do{ r=x%【14】; b[【15】]=r; x/=【16】;}while(x);}【命题目的】考查对于数组操作的综合运用【解题要点】深刻理解十进制转化为二进制的方法,即取余法;数组名作为实参,在函数内部可以直接修改调用函数中定义的数组的值【考点链接】do…while循环,先执行循环体,后判断循环条件
(13)下面函数的功能是将一个字符串的内容颠倒过来,请填空voidfun(charstr[]){intij【17】; for(i=0j=【18】;ij;i++j--) {k=str[i];str[i]=str[j];str[j]=k;}}
(14)阅读下面程序,则程序的执行结果为【19】#includestdio.hfun(intkint*p){intab;if(k==1||k==2) *p=1;else{ fun(k-1a);fun(k-2b);*p=a+b; }}main(){ intx; fun(6x); printf(%d\nx);}
(14)阅读下面程序,则程序的执行结果为【19】#includestdio.hfun(intkint*p){intab;if(k==1||k==2) *p=1;else{ fun(k-1a);fun(k-2b);*p=a+b; }}main(){ intx; fun(6x); printf(%d\nx);}
(15)阅读下列程序,则程序的输出结果为【20】#includestdio.hstructty{intdata; charc;};main(){ structtya={30′x′}; fun(a); printf(%d%ca.dataa.c);}fun(structtyb){b.data=20;b.c=′y′;}【命题目的】考查对于结构体的掌握情况【解题要点】本题的参数传递属于值传递,所以函数内不能改变调用函数中的数据
一、选择题11-15 C B A D B16-20 D D B C B 21-25 D A C B B26-30 A C C C A31-35 C C C A D 36-40 A D C B A 41-45 D C D B B 46-50 A D B C A试题
七一、选择题
(11)下列关于C语言的说法不正确的是 A)C语言既具有高级语言的一切功能,也具有低级语言的一些功能 B)C语言中的每一条执行语句都必须用分号结束,分号不是C语言的一部分,是语句之间的分隔符号 C)注释可以出现在程序中任意合适的地方 D)命令行后面不能加分号,命令行不是C语言的语句
(12)下列关于标识符的说法中错误的是 A)合法的标识符是由字母、数字和下划线组成 B)C语言的标识符中,大写字母和小写字母被认为是两个不同的字符 C)C语言的标识符可以分为三类,即关键字、预定义标识符和用户标识符 D)用户标识符与关键字不同时,程序在执行时将给出出错信息
(13)下列合法的整型常量的表示是 A)098 B)oXde C)32767 D)0xDG
(14)现在有以下定义,inta;doubleb;floatc;chark;则下面的表达式a/b+c-k值的类型为 A)int B)double C)float D)char
(15)假设整型变量abc的值均为5,则表达式a+++b+++c++的值为 A)17 B)16 C)15 D)14
(16)下列关于复合语句和空语句的说法错误的是 A)复合语句是由“{”开头,由“}”结尾的 B)复合语句在语法上视为一条语句 C)复合语句内,可以有执行语句,不可以有定义语句部分 D)C程序中的所有语句都必须由一个分号作为结束
(17)关于printf()函数的返回值叙述正确的是 A)通常是本次调用中输出字符的个数 B)通常是输出的第一个数值 C)通常返回布尔值真 D)通常返回非零值
(18)现有格式化输入语句,scanf(x=%dцsumцy=%dlineцz=%dLxyz);,现在已知在输入数据后,xyz的值分别是12,34,45,则下列数据是正确的输入格式的是 A)123445Enter B)x=12y=34z=45Enter C)x=12Csumy=34z=45Enter D)x=12цsumцy=34lineцz=45Enter [注]:“ц”表示空格Enter表示回车
(19)设xyzt均为整型变量现有如下语句x=y=z=1;t=++x||++y++z;则执行这个语句后t的值为 A)2 B)1 C)0 D)不定值
(20)现有如下程序段,此程序段编译有错误,则程序段的错误出在 #includestdio.h main() { inta=30b=40c=50d; d=a30b:c; switch(d){casea:printf(%da); caseb:printf(%db); casec:printf(%dc); default:printf(#);}} A)default:printf(#);这个语句 B)d=a30b:c;这个语句 C)casea:printf(%da);caseb:printf(%db);casec:printf(%dc);这三个语句 D)switch(d)这个语句
(21)下列语句中,错误的是(xyab假设已经定义好) A)while(x=y)5; B)dox++while(x==10); C)while
(0); D)do2;while(a==b);
(22)若ij已经定义为整型,则以下程序段中,内循环体的执行次数是 for(i=6;i;i--) for(j=0;j5;j++){……} A)40 B)35 C)30 D)25
(23)下列说法中错误的是 A)只能在循环体内使用break语句 B)在循环体内使用break语句可以使流程跳出本层循环体,从而提前结束本层循环 C)在while和do…while循环中,continue语句并没有使整个循环终止 D)continue的作用是结束本次循环,即跳过本次循环体中余下尚未执行的语句,接着再一次进行循环判断
(24)阅读如下程序段 #includestdio.h main() {intxab; scanf(%dx); a=b=x; for(;x!=0;) {if(xb)b=x; if(xa)a=x; scanf(%dx);} printf(a=%db=%d\nab);} 现输入如下[注]:′ц′表示空格 34ц56ц23ц45ц5ц56ц7ц12ц365ц49ц48ц57ц87ц7ц6ц7569ц789ц0Enter 输入后输出结果是 A)a=7569b=789 B)a=5b=365 C)a=7b=789 D)a=7569b=5
(25)下面关于字符常量的说法错误的是 A)一个字符常量代表ASCII字符集中的一个字符 B)单引号中的大写字母和小写字母代表不同的字符常量 C)字符常量只能包含一个字符 D)字符常量可以用单引号或双引号括起来
(26)现有如下程序 #includestdio.h intfun(intx) {printf(x=%d\n++x);} main() {fun(12+5);} 则程序的输出结果是 A)12 B)13 C)17 D)18
(27)现有如下程序段 #includestdio.h intaa(intxinty); main() {inta=24b=16c; c=aa(ab); printf(%d\nc);} intaa(intxinty) {intw; while(y) {w=x%y; x=y; y=w;} returnx;} 则程序段的输出结果是 A)8 B)7 C)6 D)5
(28)下列说法错误的是 A)函数调用时,函数名必须与所调用的函数名字完全相同 B)实参的个数必须与形式参数的个数一致 C)实参可以是表达式,在类型上必须与形参一一对应匹配 D)C语言规定,函数必须先定义,后调用(函数的返回值类型为int或char时除外)
(29)函数的值通过return语句返回,下面关于return语句的形式描述错误的是 A)return表达式; B)return(表达式); C)一个return语句可以返回多个函数值 D)一个return语句只能返回一个函数值
(30)现有如下定义intab*p*q;,则下列赋值语句错误的是 A)p=a; B)q=b; C)p=q; D)p=a;
(31)现有如下程序段 #includestdio.h int*fun(int*aint*b) {intc; c=*a%*b; returnc;} main() {inta=5b=19*c; c=fun(ab); printf(%d\n++*c);} 则程序段执行后的结果为 A)8 B)7 C)6 D)5
(32)现有inta*b;b=a;,则下列运算错误的是 A)*a B)*a C)*b D)*b
(33)现有如下程序段 #includestdio.h main() {intk[30]={12324456768982134453456}; intcount=0i=0; while(k[i]) {if(k[i]%2==0‖k[i]%5==0)count++; i++;} printf(%d%d\ncounti);} 则程序段的输出结果为 A)78 B)88 C)710 D)810
(34)现有如下定义语句 int*ps[20]i; p=s; 表示数组元素s[i]的表达式不正确的是 A)*(s+i) B)*(p+i) C)*(s=s+i) D)*(p=p+i)
(35)阅读如下程序段,这个程序在编译的时候会有一个警告,下列关于这个警告叙述正确的是 #includestdio.h #defineN10 int*fun(inta[N]intn) {intib[N]; for(i=0;in;i++) b[i]=a[i]; return(b);} main() {inta[N]={123445563446552}; int*k; k=fun(a[N]5); printf(%d\n*k);} A)指针k没有指向任何对象而成为“无向指针”,所以这里会产生警告 B)return语句不应该有括号,所以在这里会有警告 C)return语句的返回值类型与指针k的基类型不一致,这里会产生警告 D)数组赋值的时候没有把数组全部都赋初值,所以在这里会有警告
(36)有如下定义语句intaa[][3]={122334456788945};则45在数组aa中的行列坐标各为 A)32 B)31 C)22 D)21
(37)现有如下程序段 #includestdio.h main() {inta[5][6]={23365216782856725435768224578346783245674211}; inti=0j=5; printf(%d\n*(a[0][0]+2*i+j-2));} 则程序的输出结果为 A)21 B)78 C)23 D)28
(38)下列程序的输出结果是 #includestdio.h #defineN3 #defineM3 voidfun(inta[M][N]) {printf(%d\n*(a[1]+2));} main() {inta[M][N]; intij; for(i=0;iM;i++) for(j=0;jN;j++) a[i][j]=i+j-(i-j); fun(a);} A)3 B)4 C)5 D)6
(39)下列关于字符串的说法中错误的是 A)在C语言中,字符串是借助于字符型一维数组来存放的,并规定以字符′\0′作为字符串结束标志 B)′\0′作为标志占用存储空间,计入串的实际长度 C)在表示字符串常量的时候不需要人为在其末尾加入′\0′ D)在C语言中,字符串常量隐含处理成以′\0′结尾
(40)有下面程序段 #includestdio.h #includestring.h main() {chara[3][20]={{china}{isa}{bigcountry!}}; chark[100]={0}*p=k; inti; for(i=0;i3;i++) {p=strcat(pa[i]);} i=strlen(p); printf(%d\ni);} 则程序段的输出结果是 A)18 B)19 C)20 D)21
(41)现有如下程序段 #includestdio.h #includestring.h main() {chara[]=acfijk;/*这里是有序的字符序列*/ charb[]=befijklqswz;/*这里是有序的字符序列*/ charc[80]*p; inti=0j=0k=0; while(a[i]!=′\0′b[j]!=′\0′) {if(a[i]b[j])c[k++]=a[i++]; elseif(a[i]b[j])c[k++]=b[j++]; else{c[k++]=b[j++]; i++;}} while(a[i]==′\0′b[j]!=′\0′) c[k++]=b[j++]; while(a[i]!=′\0′b[j]==′\0′) c[k++]=a[i++]; c[k]=′\0′; puts(c);} 则输出结果是 A)acfijkbefijklqswz B)abceffiijjkklqswz C)befijklqswzacfijk D)abcefijklqswz
(42)现在有如下程序 #includestdio.h main() {chars[80]; intij; gets(s); for(i=j=0;s[i]!=′\0′;i++) if(s[i]!=′H′______) s[j]=′\0′; puts(s);} 这个程序段的功能是删除输入的字符串中字符′H′,则空线上应当添入的是 A)s[j++]=s[i];j++; B)s[j]=s[i++];j++; C)s[j++]=s[i]; D)s[j]=s[i];
(43)下列说法中错误的是 A)静态局部变量的初值是在编译时赋予的,在程序执行期间不再赋予初值 B)若全局变量和某一函数中的局部变量同名,则在该函数中,此全局变量被屏蔽 C)静态全局变量可以被其他的编辑单位所引用 D)所有自动类局部变量的存储单元都是在进入这些局部变量所在的函数体(或复合语 句)时生成,退出其所在的函数体(或复合语句)时消失
(44)阅读下列程序段,则程序的输出结果为 #includestdio.h #defineM(XY)(X)*(Y) #defineN(XY)(X)/(Y) main() {inta=5b=6c=8k; k=N(M(ab)c); printf(%d\nk);} A)3 B)5 C)6 D)8
(45)若有以下定义和语句 structa {intnm;}; structast[3]={{120}{219}{321}}; structa*p=st; 则以下错误的引用是 A)(p++)-n; B)st[0].n; C)(*p).n; D)p=st.m;
(46)假设有如下定义structa{intn;floatk;}data*p;若要使p指向data中的成员n,正确的赋值语句是 A)p=data.n; B)*p=data.n; C)p=(structa*)data.n; D)p=(structa*)data.n;
(47)下面函数的功能是将指针t2所指向的线性链表,链接到t1所指向的链表的末端假定t1所指向的链表非空 structnode{floatx;structnode*next;}; connect(structnode*t1structnode*t2) {if(t1-next==NULL)t1-next=t2; elseconnect(______t2);} 要实现此功能则应该添入的选项是 A)t
1.next B)++t
1.next C)t1-next D)++t1-next
(48)C语言结构体类型变量在程序运行期间 A)TC环境在内存中仅仅开辟一个存放结构体变量地址的单元 B)所有的成员一直驻留在内存中 C)只有最开始的成员驻留在内存中 D)部分成员驻留在内存中
(49)有下列运算符~|^则运算的优先顺序是 A)~|^ B)~|^ C)~^| D)~^
(50)最简单的交换排序方法是 A)快速排序 B)选择排序 C)堆排序 D)冒泡排序
二、填空题
(6)语句printf(%f\n
13.0*(1/5));的输出结果为【6】【命题目的】考查对于基本运算符的掌握情况【解题要点】/表示整除,1/5为0,0乘以任何数都得零,但是与浮点型相乘,要转化为浮点型,所以结果为
0.000000【考点链接】在一个运算符的两边如果一个是字符型,一个是整型,则把字符型转换为整型之后再进行运算
(7)阅读下面语句,则程序的执行结果是【7】#includestdio.hmain(){ inta=-1b=1k; if((++a0)!(b--=0))printf(%d%d\nab); elseprintf(%d%d\nba);}【命题目的】考查对于if语句的掌握情况【解题要点】与运算两边的语句必须同时为真时,结果才为真,当执行完if((++a0)!(b--=0))时,ab的值已经发生了变化【考点链接】++,--运算符
(8)阅读下面语句,则执行后的输出结果为【8】 #includestdio.hmain(){charab; for(a=′0′b=′9′;ab;a++b--) printf(%c%cab);printf(\n);}【命题目的】考查对于for循环的掌握情况【解题要点】for是C语言的关键字,其后的一对圆括号中通常含有三个表达式,各个表达式之间用分号隔开,这三个表达式可以是任意形式的表达式,通常主要用于for循环控制【考点链接】对字符型的运算实际上是对其ASCII码值的运算
(9)阅读下面程序,则执行后程序的结果为【9】#includestdio.hmain(){inta=0b=0; while(a15)a++; while(b++15); printf(%d%d\nab);}【命题目的】考查对于while循环的掌握情况【解题要点】while是C语言的关键字,while后一对圆括号中的表达式,可以是C语言中任意合法的表达式,由它来控制循环体是否执行【考点链接】在语法上要求循环体可以是一条简单可执行语句,并且还要注意循环控制表达式的判断条件
(10)在使用putchar和getchar函数处理字符时,必须在程序的开头出现包含头文件的命令行是【10】【命题目的】考查对于基础知识的掌握情况【解题要点】使用putchar和getchar函数时,必须在程序的开头出现包含头文件#includestdio.h的命令行【考点链接】putchar的函数调用形式为putchar(字符变量或字符常量);getchar函数的调用形式为变量=getchar();getchar后的一对圆括号内没有参数,但这一对圆括号不可少
(11)下列程序的输出结果是【11】,【12】 #includemath.hmain(){floata=-
1.3;b=
1.3; printf(%f%ffabs(a)fabs(b);}【命题目的】主要考查math库函数【解题要点】本题是求浮点数的绝对值【考点链接】常用的math函数
(12)设有以下定义和语句,则*(*(p+2)+1)的值为【13】inta[3][2]={102030405060}(*p)[2];p=a;【命题目的】主要考查对于通过建立行指针来引用二维数组元素的掌握情况【解题要点】*(*(p+2)+1)相当于访问的是a[2][1]的值【考点链接】*(p[2]+1)、p[2][1]以及(*(p+2))[1]表达的含义都是a[2][1]的值
(13)有下列程序,功能是把输入的十进制长整型数以十六进制的形式输出,完成程序 #includestdio.hmain(){charb[17]={0123456789ABCDEF};intc[50]di=0base=16;longn;scanf(%ldn);do{c[i]=n%base;i++;n=【14】;}while(n!=0);for(--i;i=0;--i) {d=【15】;printf(%cb[d]);}printf(H\n);}【命题目的】考查字符串的实际运用的理解程度【解题要点】字符串的综合运用【考点链接】这是一种常用的十进制转换成十六进制的方法应该掌握
(14)现有如下程序段,则程序段的输出结果为【16】#includestdio.hintfun(){staticintk;returnk;}main(){intm;m=fun();printf(%d\nm);}【命题目的】考查对于静态存储类的局部变量的掌握情况【解题要点】在整个程序运行期间,静态局部变量在内存的静态存储区中占据着永久性的存储单元即使退出函数以后,下次再进入函数时,静态局部变量仍使用原来的存储单元,如未赋初值,则系统会自动赋值为0【考点链接】C语言中,有两种存储类别一种是自动类;一种是静态类局部变量既可以说明成自动类型;也可以说明成静态类型;而全局变量只能是静态类型
(15)现有如下定义structaa{inta;floatb;charc;}*p;现需用malloc函数动态的申请一个structaa类型大小的空间(由p指向)则定义的语句为【17】【命题目的】考查对于动态空间申请函数的掌握情况【解题要点】ANSIC标准规定malloc函数的返回值类型为void*,函数的调用形式为malloc(size)要求size的类型为unsignedint由于返回类型为void*,所以在调用函数时,必须利用强制转换将其转换为所需要的类型【考点链接】free函数的作用是释放申请的内存空间
(16)有如图所示的双链表结构,请根据图示完成结构体的定义{intdata; 【18】}node;【命题目的】考查对于结构体对链表的定义掌握情况【解题要点】结构体对链表的定义
(17)当调函数frend从磁盘文件中读取数据时,若函数数的返回时为5,则表明【19】;若函数的返回值为0,则表明【20】【命题目的】考查对于函数基本操作的掌握情况【解题要点】fread函数的调用形式为fread(buffersizecoutfp);其中buffer是数据块的指针,size表示每个数据块的字节数count用来指定每读、写一次,输入\输出数据块的个数(每个数据块有size个字节)fp是文件的指针
一、选择题11-15 B D C B C16-20 C A D B C21-25 B C A D D26-30 D A C C D31-35 C B D C A 36-40 C A B B B41-45 D C C A B 46-50 C C D D D试题
八一、选择题
(11)以下说法错误的是 A)高级语言都是用接近人们习惯的自然语言和数学语言作为语言的表达形式 B)计算机只能处理由0和1的代码构成的二进制指令或数据 C)C语言源程序经过C语言编译程序编译之后生成一个后缀为.EXE的二进制文件 D)每一种高级语言都有它对应的编译程序
(12)算法是指为解决某个特定问题而采取的确定且有限的步骤,下面不属于算法的五个特性的是 A)有零个输入或多个输入 B)高效性 C)有穷性 D)确定性
(13)已知inta=6;则执行a+=a-=a*a;语句后,a的值为 A)36 B)0 C)-24 D)-60
(14)下面各选项中,均是C语言标识符的选项组是 A)forchinato B)long_123short56_do C)voidunion_342 D)text.txt_023_3ew
(15)下列表达式中,结果为5的是 A)6*5%6 B)5*-2+15 C)5+75%10 D)6+-2/3
(16)下列常量中,为不合法的实型常量表示的是 A).0032 B)
0.0 C)
0.3242E8 D).E3
(17)关于C语言的主函数描述正确的是 A)C程序可以有多个main函数 B)C程序必有一个而且只能有一个main函数 C)C程序可以没有main函数 D)C程序的执行不一定在main函数开始执行
(18)已知inta=1b=-1;则语句printf(%d\n(a--++b));的输出结果是 A)-1 B)0 C)1 D)语句错误
(19)已知intab;doublec;则以下语句中错误的函数调用是 A)scanf(%d%x%lfabc); B)scanf(%d%d%leabc); C)scanf(%o%x%oab); D)scanf(%d%o%eabc);
(20)已知xyz均为整型变量,且值均为1,则执行语句++x||++y++z;后,表达式x+y的值为 A)1 B)2 C)3 D)4
(21)若intk=8;则执行下列程序后,变量k的正确结果是 main() {intk=8; switch(k) {case9:k+=1; case10:k+=1; case11:k+=1;break; default:k+=1;} printf(%d\nk);} A)12 B)11 C)10 D)9
(22)若intij;,则for(i=j=0;i10j8;i++j+=3)控制的循环体执行的次数是 A)9 B)8 C)3 D)2
(23)下列程序的输出结果是 #includestdio.h main() {inti=6; while(i--) printf(%d--i); printf(\n);} A)531 B)420 C)654321 D)死循环
(24)阅读下列程序,则执行结果是 #includestdio.h main() {inta=0b=0c=0i; for(i=0;i4;i++) switch(i) {case0:a=i++; case1:b=i++; case2:c=i++; case3:i++;} printf(%d%d%d%d\nabci);} A)0134 B)1234 C)0125 D)0234
(25)下面程序的运行结果是 #includestdio.h main() {intjik=0; for(j=50;j=60;j++) {if(!(k%10))printf(\n); for(i=2;ij;i++)if(!(j%i))break; if(i=j-1){printf(%dj); k++;}}} A)5359 B)5953 C)3595 D)9535
(26)已知charch=′C′;则以下表达式的值是 ch=(ch=′A′ch=′Z′)(ch+32):ch; A)A B)a C)Z D)c
(27)以下描述错误的是 A)C程序中,函数可以直接或间接的调用自己 B)函数调用时,函数名必须与所调用的函数名字完全一致 C)函数说明语句中的类型必须与函数返回值的类型一致 D)实参数可以与形参个数不一致
(28)阅读下面程序,则执行后的结果为 #includestdio.h main() {fun3(fun1()fun2());} fun1() {intk=20; returnk;} fun2() {inta=15; returna;} fun3(intaintb) {intk; k=(a-b)*(a+b); printf(%d\nk);} A)0 B)184 C)175 D)编译不通过
(29)阅读下面程序,则执行后的输出结果为 #includestdio.h fun(intaintb) {ints; s=a*b/2; printf(%d\ns);} main() {inta=10b=16; fun(ab);} A)10 B)16 C)160 D)80
(30)阅读下面程序,则程序执行后的结果为 #includestdio.h main() {inta=4b=6c=7; doubledfun(intintint); d=fun(abc); printf(%lf\nd);} doublefun(intaintbintc) {doubles; s=a%b*c; returns;} A)27 B)
27.000000 C)28 D)
28.000000
(31)下列不合法的指针变量的定义是 A)int*_k; B)char*_245; C)int*p; D)double*5_is
(32)下列关于指针变量赋空值的说法错误的是 A)当赋空值的时候,变量指向地址为0的存储单元 B)赋值语句可以表达为变量名=′\0′; C)赋值语句可以表达为变量名=0; D)一个指针变量可以被赋空值
(33)阅读下面程序,则执行后输出的结果为 #includestdio.h voidfun(int*aint*b) {intm; m=(*a+*b)*(*a+*b); m+=(*a-*b)*(*a-*b); printf(%d\nm);} main() {inta=5b=6*x=a*y=b; fun(xy);} A)120 B)121 C)122 D)123
(34)阅读下面程序,则输出结果是 #includestdio.h voidfun(int*aint*b) {intc=20d=25; *a=c/3; *b=d/5;} main() {inta=3b=5; fun(ab); printf(%d%d\nab);} A)65 B)56 C)2025 D)35
(35)以下对一维数组c进行正确的定义初始化的语句是 A)intc[10]=0; B)intc[10]={0}*10; C)intc[1]={0000000}; D)intc[10]={0};
(36)以下二维数组c的定义形式是 A)intc[3][] B)floatc[34] C)doublec[3][4] D)floatc
(3)
(4)
(37)阅读下列程序,则执行后输出的结果是 #includestdio.h intk=1; main() {fun(k); printf(%d\nk);} fun(intk) {k++; k=k*6;} A)1 B)2 C)6 D)12
(38)已知#defineM2;的宏定义,执行语句k=M*5;后,k的值是 A)10 B)5 C)2 D)以上答案都不对
(39)已知intc[3][4];则对数组元素引用正确的是 A)c[1][4] B)c[
1.5][0] C)c[1+0][0] D)以上表达都错误
(40)现有如下程序段 #includestdio.h voidfun(int*aint*bint*c) {*c=*a+*b;} main() {inta[2]={1223}c; fun(aa+1c); printf(%d\nc);} 则程序的输出结果为 A)23 B)12 C)0 D)35
(41)若有以下语句,则正确的描述是 chara[]=toyou; charb[]={′t′′o′′y′′o′′u′}; A)a数组和b数组的长度相同 B)a数组长度小于b数组长度 C)a数组长度大于b数组长度 D)a数组等价于b数组
(42)已知chara[15]b[15]={Ilovechina};则在程序中能将字符串Ilovechina赋给数组a的正确语句是 A)a=Ilovechina; B)strcpy(ba); C)a=b; D)strcpy(ab);
(44)阅读下面程序,则执行后的结果为 #includestdio.h main() { char*str=abcdefghijklmnopq; while(*str++!=′e′); printf(%c\n*str);} A)f B)a C)e D)q
(45)现有如下程序段 #includestdio.h intfun(intkint*m) {if(k%3)*m=k*k; else*m=k/3;} main() {int(*p)(intint*)m; p=fun; (*p)(78m); printf(%d\nm);} 则程序段的输出结果为 A)24 B)25 C)26 D)27
(46)阅读下列程序,则执行后的输出结果为 #includestdio.h fun(intx) {if(x/20)fun(x/2); printf(%dx%2);} main() {fun
(20); putchar(′\n′);} A)11100 B)10100 C)10101 D)10110
(47)阅读如下程序段,则执行后程序的输出结果是 #includestdio.h main() {structa{intx;inty;}num[2]={{205}{67}}; printf(%d\nnum[0].x/num[0].y*num[1].y);} A)0 B)28 C)20 D)5
(48)阅读程序段,则执行后的输出结果为 #includestdio.h typedefunion{longx[2]; inty[4]; charz[8];}atx; typedefstructaa{longx[2]; inty[4]; charz[8];}stx; main() {printf(union=%dstructaa=%d\nsizeof(atx)sizeof(stx));} A)union=8structaa=8 B)union=8structaa=24 C)union=24structaa=8 D)union=24structaa=24
(49)阅读下列程序段 #includestdio.h typedefstructaa {inta; structaa*next;}M; voidset(M*kintiint*b) {intjd=0; for(j=1;ji;j++) { k[j-1].next=k[j]; k[j-1].a=b[d++];} k[j].a=b[d];} main() {Mk[5]*p; intd[5]={2334455667}; set(k5d); p=k+1; printf(%d\ntable);} 则下面的表达式在table处,能使程序执行后,打印输出数据45的是 A)p-next-a B)++p-a C)(*p).a++ D)p++-a
(50)阅读下面程序,程序实现的功能是(a
123.txt在当前盘符下已经存在) #includestdio.h voidmain() {FILE*fp; inta[10]*p=a; fp=fopen(a
123.txtw); while(strlen(gets(p))0) {fputs(afp); fputs(\nfp);} fclose(fp);} A)从键盘输入若干行字符,按行号倒序写入文本文件a
123.txt中 B)从键盘输入若干行字符,取前2行写入文本文件a
123.txt中 C)从键盘输入若干行字符,第一行写入文本文件a
123.txt中 D)从键盘输入若干行字符,依次写入文本文件a
123.txt中
二、填空题
(6)定义inta=5b=20;若执行语句printf(%d\n++a*--b/5%13);后,输出的结果为【6】解析++和--做前缀使用的时候,先对变量进行增1或减1,之后进行其他的运算之后按照同级运算符自左向右依次运算
(7)执行程序时的输入为123456789,则程序的运行结果为【7】#includestdio.hmain(){ intab; scanf(%2d%*2d%1dab); printf(%d\na-b);}解析按照函数scanf中的格式控制符的描述%2d控制前2个数字赋给变量a,变量a的值为12,%1d控制将随后的1个数字作为输入数据存入变量b中,变量b的值为5,所以随后的输出为7注意在%和格式控制符号之间加*号,表示的是跳过相对应的输入数据
(8)阅读下面程序,则在执行时候的输出为【8】 #includestdio.hmain(){intx=1y=2z=0;if(x=2)z=xx=yy=z;printf(%d%d\nxy);}解析if语句的执行过程为首先计算紧跟在if后面一对圆括号中的表达式,如果表达式的值为非零,则执行其后的if子句,然后去执行if语句后的下一个语句,如果表达式为零,则跳过if子句直接执行if语句后的下一个语句,if(x=2)的值为真,即x的值为2
(9)语句printf(%d\n′H′-′0′+64);的执行结果为【9】解析在C程序中的字符量可参与任何整数运算在运算的时候都是以ASCII值进行的
(10)阅读下面程序,则程序的执行结果为【10】#includestdio.hmain(){inta=10; fun(a); printf(%d\na);}fun(intx){x=50;}解析函数调用的时候,函数名字必须与所调用的函数名完全一致,形参与实参类型要一致,在没有给出函数返回值类型的情况下,默认为整形,当返回值为整型放到主函数后面时,可以不需要事先说明就调用这个函数
(11)以下程序的输出结果是【11】intfun(intxintyint*pint*q){*p=x*y; *q=x/y;}main(){intabcd;a=4;b=3;fun(abcd);printf(%d%d\ncd);}解析通过地址传递可以在被调函数中对调用函数中的变量进行引用,通过地址的传递,在经过函数调用以后,改变了cd变量的值
(12)下面程序是求出数组arr的两条对角线上元素之和,请填空#includestdio.hmain(){intarr[3][3]={234832798}a=0b=0ij;for(i=0;i3;i++) for(j=0;j3;j++)if(【12】)a=a+arr[i][j];for(i=0;i3;i++)for(【13】;j=0;j--)if(【14】)b=b+arr[i][j];printf(%d%d\nab);}解析由于是求对角线元素的和,所以【12】是判断是否为对角线元素的,填i==j这个判断条件;对于次对角线的求和,初始化的时候应该是从数组的列最大开始,由于判断条件是j=0,所以初始化时候应该为最大值减1,即j=2,所以【13】应填j=2;【14】是对次对角线的判断,所以填i+j==2
(13)下面程序的功能是对字符串从小到大进行排序并输出,请填空#includestring.h#includestdio.hsort(char*a[]intn){intij;char*p;for(j=1;j=n-1;j++)for(i=0;【15】;i++)if(【16】0){p=a[i];a[i]=a[i+1];a[i+1]=p;}}main(){inti;char*book[]={itismeitisyouhowareyoufinegoodnightgoodbye};sort(【17】);for(i=0;i6;i++)printf(%s\nbook[i]);}解析这个题目其实用的是冒泡排序法,每一次都找一个最大的,之后顺序的从头开始排列所以【15】是一次循环的判定条件,填in-j,【16】则是字符串的比较,由于只给了一个空,所以必然要调用字符串处理函数的,所以填strcmp(a[i]a[i+1]),【17】是调用函数的函数头的填写,有两个要填写的项,一个是指针字符数组的传递,一个是整型变量的传递
(14)下面的函数是完成1~n的累加,完成函数a(intk){if(k=0)printf(error\n);if(k==1)【18】;else【19】;}解析由于题目没有给循环语句,所以实现累加一定是用递归算法
(15)阅读下列程序,则程序实现的功能是【20】#includestdio.hstructnode{chardata; structnode*next;}*head;fun(structnode*q){if(head==NULL){q-next=NULL;head=q;}else{q-next=head;head=q;}}main(){charch;structnode*p;head=NULL;while((ch=getchar())!=′\n′){p=(structnode*)malloc(sizeof(structnode));p-data=ch;fun(p);}p=head;while(p!=NULL){printf(%cp-data);p=p-next;}}解析本题目的功能是从键盘输入一行字符,调用函数建立反序的链表,然后输出整个链表,从主函数开始依次向下对程序进行分析,分析初始化状态的程序,之后再分析函数的功能
一、选择题11-15 C B D B B16-20 D B B D C21-25 D C B C A26-30 D D C D D31-35 D A C A D36-40 C A D C D41-45 C D A A C46-50 B B B A D试题九
(11)下列常数中不能作为C语言常量的是 A)0xabc B)
2.5e-
0.2 C)32 D)0747
(12)设int型的数据长度为2个字节,则unsignedint类型数据的取值范围是 A)-127~128 B)0~255 C)0~65535 D)0~32768
(13)已知intt=6s;则执行语句s=(++t)+(t++);后,s的值是 A)12 B)13 C)14 D)15
(14)已知intx=6y=2z;则执行表达式z=x=xy后,变量z的值为 A)0 B)1 C)4 D)5
(15)已知intia;执行语句i=(a=3a++--aa+4a+5++a);后,变量i的值为 A)2 B)3 C)4 D)5
(16)下列说法中正确的是 A)一个C程序是从命令行开始执行的 B)C程序中有些执行语句不用分号(;)结束 C)分号不是C语句的一部分,是C语句之间的分隔符 D)命令行必须用“#”开头,最后不能加“;”号,命令行不是C程序中的语句
(17)已知intx=2;执行语句x*=x+=++x;后,x的值是 A)16 B)26 C)36 D)46
(18)已知inta=20b=5;则执行以下语句后的输出结果是 printf(%d\na%=(b%=2)); A)0 B)1 C)2 D)3
(19)现有以下程序段 #includestdio.h main() {intabc; scanf(a=%*d%db=%d%*dc=%dabc); printf(a=%db=%dc=%d\nabc);} 若输出的结果为a=20b=30c=40,则以下能够正确输入数据的是 A)a=10]20b=20]30c=40CR B)203040CR C)a=20b=30c=40CR D)a=10]20b=30]20c=40CR [注]:“]”表示空格,CR表示回车
(20)已知intx=5y=3;则表达式(x||y)78的结果为 A)1 B)0 C)5 D)78
(21)有如下程序段 #includestdio.h main() {inta=10b=50c=30; a=a301:2; b=b301:2; c=c301:2; printf(%d%d%d\nabc);} 则执行结果为 A)212 B)121 C)112 D)211
(22)阅读如下程序段 #includestdio.h main() {inta=45b=40c=50d; d=a30b:c; switch(d) {case30:printf(%da); case40:printf(%db); case50:printf(%dc); default:printf(#);}} 则输出的结果是 A)4050 B)50# C)40# D)4050#
(23)若有定义intk=10;则下列程序的输出结果为 do{ printf(%dk--);}while(!k); A)9 B)10 C)10987654321 D)没有输出
(24)阅读下列程序段,则程序的输出结果是 #includestdio.h main() {inta=10b=10k; for(k=0;a8;b=++k) printf(%d%da----b); printf(\n);} A)1010100 B)10990 C)101091 D)9991
(25)下列程序的运行结果是 #includestdio.h main() {intabm; for(a=5;a=1;a--) {m=0; for(b=a;b=5;b++) m=m+a*b;} printf(%d\nm);} A)30 B)15 C)20 D)10
(26)有字符串如下,\n\\\407as1\\xabc则字符串的长度为 A)6 B)7 C)8 D)9
(27)阅读下面程序段 #includestdio.h main() {charc; c=(′z′-′a′)/2+′A′; putchar(c);} 输出结果为 A)M B)N C)O D)Q
(28)下列说法中不正确的是 A)C语言规定,不能在一个函数的内部再定义函数 B)在没有声明函数返回值类型的情况下,C默认的函数返回值类型为int型 C)函数的类型可以是整型、实型、字符型,但不能是指针型 D)函数可以没有形参,但函数名后的一对圆括号不能省略
(29)现有如下程序,则程序的输出结果为 #includestdio.h intf(intaintb) {intc; if(a0a10)c=(a+b)/2; elsec=a*b/2; returnc;} main() {inta=8b=20c; c=f(ab); printf(%d\nc);} A)随机数 B)80 C)28 D)14
(30)阅读如下程序段,则程序段的执行后的输出结果为 #includestdio.h main() {charc; inti; charcount(); intp(char); for(i=0;i30;i++)c=count(); p(c);} charcount() {charstr=′A′; str+=1; return(str);} p(charc) {putchar(c); putchar(′\n′);} A)A B)B C)a D)b
(31)阅读如下程序段,则执行后的结果为 #includestdio.h main() {inta*p*q**w; p=a; q=a; w=p; *p=5%6; *q=5; **w=3; printf(%d\na);} A)无确定值 B)1 C)5 D)3
(32)现有定义inta=10*p=a;则不能使a的内容增1的语句是 A)*p++; B)*p=*p+1; C)++*p; D)*p+=1;
(33)现有下列程序段 #includestdio.h voidJFT(int*aint*bint*cint*dint*e) {intijkm; for(i=0;i*a;i++) for(j=0;j*b;j++) for(k=0;k*c;k++) for(m=0;m*d;m++)*e++;} main() {inta=10b=10c=10d=10e=0; JFT(abcde); printf(%d\ne);} 则程序段的输出结果是 A)10000 B)1000 C)10001 D)0
(34)已知intc[5][6];则对数组元素引用不正确的是 A)c[0+2][2*1] B)c[1][3] C)c[4-2][0] D)c[5][2]
(35)以下能对二维数组c进行正确的初始化的语句是 A)intc[3][]={{3}{3}{4}}; B)intc[][3]={{3}{3}{4}}; C)intc[3][2]={{3}{3}{4}{5}}; D)intc[][3]={{3}{}{3}};
(36)阅读下列程序段,则程序段实现的功能是 #includestdio.h main() {intk[10]; intj; for(j=0;j10;j++) scanf(%dk[j]); for(j=9;j=0;j--) printf(%dk[j]);} A)输入10个数据的顺序输入并输出 B)输入10个数据的逆序存放 C)输入10个数据的逆序输出 D)以上叙述均错误
(37)阅读程序,则执行后的结果为 #includestdio.h main() {intimn; for(i=0;i3;i++) {m=test1(); n=test2();} printf(%d%d\nmn);} test1() {intx=0; x++; returnx;} test2() {staticintx=0; x++; returnx;} A)11 B)13 C)31 D)33
(38)以下关于宏替换叙述中,错误的是 A)宏替换占用编译时间 B)替换文本中可以包含已定义过的宏名 C)宏名可以由+号组成 D)宏替换只能是字符替换
(39)阅读下面程序,则程序的输出结果为 #includestdio.h main() {intc[]={123456}; int*p; p=c; printf(%d*p); printf(%d\n*++p);} A)12 B)21 C)11 D)22
(40)有如下定义,则函数fun的首部可以是 #defineN5 #defineM6 main() {doublec[M][N]; fun(c);} A)fun(doublea) B)fun(doublea[M][]) C)fun(double*a) D)fun(double(*a)[N])
(41)下面关于字符串的说明中,错误的是 A)chara[15]=jft; B)chara[]=jft; C)char*a=:jft; D)chara[]={′j′′f′′t′};
(42)已知chara[20]=abcb[20]=defghi;则执行下列语句后的输出结果为 printf(%dstrlen(strcpy(ab))); A)11 B)6 C)5 D)以上答案都不正确
(43)阅读如下程序段,则程序在先后输入love和china后,输出结果是 #includestdio.h #includestring.h main() {chara[30]b[30]; intk; gets(a); gets(b); k=strcmp(ab); if(k0)puts(a); elseif(k0)puts(b);} A)love B)china C)lovechina D)没有输出结果
(44)阅读下面程序,则执行后的结果为 #includestdio.h #includestring.h #defineN10 #defineM10 char*find(char(*a)[M]intn) {char*q;inti; q=a[0]; for(i=0;in;i++) if(strcmp(a[i]q)0)q=a[i]; returnq;} main() {chars[N][M]={tomeetmeyouandhechina}; char*p; intn=5i; p=find(sn); puts(p);} A)he B)and C)you D)tomeetme
(45)当定义一个结构变量时系统分配给它的内存是 A)各个成员占用内存的总和 B)成员中占内存量最大者所需的容量 C)定义的同时并不分配空间 D)结构中最后一个成员所需内存量
(46)有以下说明语句 structa{charx; doubley;}ptype; 则下列选项中错误的是 A)a是用户定义的结构体标识 B)structa是用户定义的结构类型 C)ptype是用户定义的结构类型名 D)x和y都是结构成员名
(47)已知有如下定义structa{charx;doubley;}data*t;若有t=data,则对data中的成员的正确引用是 A)(*t).data.x B)(*t).x C)t-data.x D)t.data.x
(48)若有以下程序段,则选项中值为2的是 structa{intn*next;}; intx=1y=2z=3; structas[3]*p=s; s[0].next=x;s[1].next=y;s[2].next=2; A)*(p++)-next B)*(++p)-next C)(*p).next D)(p++)-next
(49)下面程序段的输出为 #includestdio.h main() {inta=8b; b=a|1; b=1; printf(%d%d\nab);} A)44 B)40 C)84 D)80
(50)阅读下面程序,此程序的功能为 #includestdio.h main(intargcchar*argv[]) {FILE*p1*p2; intc; p1=fopen(argv[1]r); p2=fopen(argv[2]a); c=fseek(p20L2); while((c=fgetc(p1))!=EOF)fputc(cp2); fclose(p1); fclose(p2);} A)实现将p1打开的文件中的内容复制到p2打开的文件 B)实现将p2打开的文件中的内容复制到p1打开的文件 C)实现将p1打开的文件中的内容追加到p2打开的文件内容之后 D)实现将p2打开的文件中的内容追加到p1打开的文件内容之后
二、填空题
(6)表达式3*7/2+7/2%5的值为【6】解析算术运算符的优先级别依次为(由高到低)*/%+-
(7)阅读下面的程序,当程序在执行时,如果输入的是′A′,则输出结果为【7】#includestdio.hmain(){chara; a=getchar(); switch(a){case65:printf(%c′A′);case66:printf(%c′B′);default:printf(%s\nother);}}解析switch语句中的某一个标号被选中,将依次执行这个语句到default语句之间的所有语句如遇到break语句之后就跳出了switch语句
(8)以下程序的输出结果是【8】main(){chara[]=abcdefg;charb[10]=abcdefg;printf(%d%d\nsizeof(a)sizeof(b));}解析当维数组省略维数时,系统会按数组实际元数分配内存空间,如规定了一维的大小,则按维数分配内存空间的大小
(9)阅读下面程序段,则执行后的输出结果为【9】#includestdio.hmain(){inta=1;for(;a=15;)if(++a%5!=2)continue;elseprintf(%da);printf(\n);}解析continue是结束本次循环即从continue开始到最后的执行,直接执行循环判定条件
(10)以下程序的输出结果是【10】main(){intm=2n=6;for(;n=0;n--)m*=n;printf(%d\nm);}解析for语句执行最后时n的值为0,所以m的值也为0
(11)阅读下列程序,则执行后的结果为【11】#includestdio.hfun(intxinty){intz; z=x;x=y;y=z;}main(){intab;a=100;b=640;fun(ab);printf(%d%d\nab);}解析当传递数据值的时候,在被调用函数内部不能改变调用函数的变量的值
(12)阅读以下程序,使程序输出结果为30,
4.000000,请填空#includestdio.hmain(){inta=30b=40c;double【12】s;s=fun(abc);printf(%d%lf\ncs);}doublefun(int*aint*b【13】){*c=*a%*b; return(
4.0);}解析函数说明的一般形式为类型名函数名(参数类型1,参数类型2,……)
(13)下面程序段的功能是从键盘上输入两个字符串,对两个字符串分别排序;然后将它们合并,合并后的字符串按ASCII码值从小到大排序,并删去相同的字符请填空#includestdio.hfun(char*xchar*ychar*z){chart*p;p=z;while(*x!=′\0′*y!=′\0′){t=*x*y*x++:*y*x*y++:【14】;if(*p==′\0′)*p=t;elseif(t!=*p)*++p=t;}if(*x!=′\0′)while(*x!=′\0′)if(*x!=*p)*++p=*x++;elsex++;if(*y!=′\0′)while(*y!=′\0′)if(*y!=*p)*++p=*y++;elsey++;*++p=【15】;}sort(char*s){intijk;chart*p;p=s;for(k=0;*p!=′\0′;k++)p++;for(i=0;ik-1;i++)for(j=i+1;jk;j++)if(s[i]s[j]) {【16】}}main(){chars1[100]s2[100]s3[200];scanf(%ss1);scanf(%ss2);sort(s1);sort(s2);s3[0]=′\0′;fun(s1s2s3);printf(%s\ns3);}解析根据题目的要求认真阅读程序,找到各个部分的功能所在,这样就很容易做出答案
(14)下面函数是一个求阶乘的递归调用函数请填空intfun(intk){if(k==1)【17】;elsereturn(【18】);}解析解这个题目应该首先写递归公式,之后很容易得出答案
(15)以下函数set用来建立一个带头结点的单向链表,新产生的结点总是插入在链表的末尾单向链表的头指针作为函数值返回,请填空structnode{chardata; structnode*next;};structnode*set(){structnode*t1*t2*t3;charch;t1=(structnode*)malloc(sizeof(structnode));t3=t2=t1;ch=getchar();while(ch!=′\n′){t2=【19】malloc(sizeof(structnode));t2-data=ch;t3-next=t2;t3=t2;ch=getchar();}t3-next=′\0′; 【20】}解析动态申请的返回值是void*类型,所以在使用动态申请函数的时候都要在前面加上适当的强制类型转换,使它的返回值有意义
一、选择题11-15 B C C B C16-20 D C A D C21-25 A D B B B26-30 D A C D B 31-35 D A D B C 36-40 C B C A D 41-45 D B A B A 46-50 C B B C C试题十
(11)C语言程序的基本单位是 A)程序行 B)语句 C)函数 D)字符
(12)下面四个选项中,均是合法整型常量的选项是 A)160 -0xffff 011 B)-0xcdf 01a 0xe C)-01 986012 0668 D)-0x48a 2e5 0x
(13)以下选项中合法的用户标识符是 A)long B)_2Test C)3Dmax D)A.dat
(14)假定x和y为double型,则表达式x=2y=x+3/2的值是 A)
3.500000 B)3 C)
2.000000 D)
3.000000
(15)以下变量x,y,z均为double类型且已正确赋值,不能正确表示数学式子x÷y÷z的C语言表达式是 A)x/y*z B)x*(1/(y*z)) C)x/y*1/z D)x/y/z
(16)设xyt均为int型变量,执行语句 x=y=3; t=++x||++y; 完成后,y的值为 A)不确定 B)4 C)3 D)1
(17)已知i,j,k为int型变量,若从键盘输入1,2,3回车,使i的值为1,j的值为2,k的值为3,以下选项中正确的输入语句是 A)scanf(%2d%2d%2dijk); B)scanf(%d%d%dijk); C)scanf(%d%d%dijk); D)scanf(i=%dj=%dk=%dijk);
(18)若变量已正确定义并赋值,下面符合C语言语法的表达式是 A)m∶=5 B)c=b=a=1 C)float8%5 D)x+5=y+2
(19)下列程序运行的结果是 main() {floatx; inti; x=
3.6; i=(int)x; printf(x=%fi=%dxi); } A)x=
3.600000i=3 B)x=
3.6i=3 C)x=3i=3 D)x=
3.600000i=
3.000000
(20)若执行下面的程序时,从键盘上输入5和2,则输出结果是 main() {intabk; scanf(%d%dab); k=a; if(ab)k=a%b; elsek=b%a; printf(%d\nk); } A)5 B)3 C)2 D)0
(21)C语言中while和do-while循环的主要区别是 A)do-while的循环体至少无条件执行一次 B)while的循环控制条件比do-while的循环控制条件更严格 C)do-while允许从外部转到循环体内 D)do-while的循环体不能是复合语句
(22)以下程序的输出结果是 main() {intx=1y=3; printf(%dx++); {intx=0;x+=y*2; printf(%d%dxy); } printf(%d%d\nxy); } A)16313 B)16363 C)16323 D)17323
(23)下面程序输出的结果是 main() {inti; inta[3][3]={123456789}; for(i=0;i3;i++) printf(%da[2-i][i]); } A)159 B)753 C)357 D)591
(24)请阅读以下程序 main() {inta=5b=0c=0; if(a=b+c)printf(***\n); elseprintf($$$\n); } 以上程序 A)有语法错不能通过编译 B)可以通过编译但不能通过连接 C)输出*** D)输出$$$
(25)以下程序的输出结果是 main() {charc=′z′; printf(%cc-25); } A)a B)Z C)z-25 D)y
(26)下面函数的功能是 char*fun(char*str1char*str2) {while((*str1)(*str2++=*str1++)); returnstr2; } A)求字符串的长度 B)比较两个字符串的大小 C)将字符串str1复制到字符串str2中 D)将字符串str1接续到字符串str2中
(27)下面函数调用语句含有实参的个数为 func((exp1exp2)(exp3exp4exp5)); A)1 B)2 C)4 D)5
(28)下面程序段的运行结果是 char*s=abcde; s+=2;printf(%ds); A)cde B)字符′c′ C)字符′c′的地址 D)无确定的输出结果
(29)已有变量定义和函数调用语句inta=25;print_value(a);下面函数的正确输出结果是 voidprint_value(int*x) {printf(%d\n++*x);} A)23 B)24 C)25 D)26
(30)当顺利执行了文件关闭操作时,fclose函数的返回值是 A)-1 B)TRUE C)0 D)1
(31)设有如下定义 char*s[2]={abcdABCD}; 则下列说法错误的是 A)s数组元素的值分别是abcd和ABCD两个字符串的首地址 B)s是指针数组名,它含有两个元素分别指向字符型一维数组 C)s数组的两个元素分别存放的是含有4个字符的一维字符数组中的元素 D)s数组的两个元素中分别存放了字符′a′和′A′的地址
(32)以下不能对二维数组a进行正确初始化的语句是 A)inta[2][3]={0}; B)inta[][3]={{12}{0}}; C)inta[2][3]={{12}{34}{56}}; D)inta[][3]={123456};
(33)有以下程序 structSTU {charnum[10];floatscore[3];}; main() {structSTUs[3]={{20021909585} {20022958075} {200231009590} }*p=s; inti;floatsum=0; for(i=0;i3;i++) sum=sum+p-score[i]; printf(%
6.2f\nsum); } 程序运行后的输出结果是 A)
260.00 B)
270.00 C)
280.00 D)
285.00
(34)若有说明inta[10];则对a数组元素的正确引用是 A)a[10] B)a[35] C)a
(5) D)a[10-10]
(35)下面程序段中,输出*的个数是 char*s=\ta\018bc; for(;*s!=′\0′;s++)printf(*); A)9 B)5 C)6 D)7
(36)设有如下函数 fun(floatx) { printf(\n%dx*x);} 则函数的类型是 A)与参数x的类型相同 B)是void C)是int型 D)无法确定
(37)有如下定义 #defineD2 intx=5;floaty=
3.83; charc=′D′; 则下面选项中错误的是 A)x++; B)y++; C)c++; D)D++;
(38)以下程序段的执行结果为 #definePLUS(XY)X+Y main() {intx=1y=2z=3sum; sum=PLUS(x+yz)*PLUS(yz); printf(SUM=%dsum); } A)SUM=9 B)SUM=12 C)SUM=18 D)SUM=28
(39)C语言规定,函数返回值的类型是由 A)return语句中的表达式类型所决定 B)调用该函数时的主调函数类型所决定 C)调用该函数时系统临时决定 D)在定义该函数时所指定的函数类型所决定
(40)下列程序的运行结果是 voidfun(int*aint*b) {int*k; k=a;a=b;b=k; } main() {inta=2004b=9*x=a*y=b; fun(xy); printf(%d%dab); } A)20049 B)92004 C)00 D)编译时出错
(41)下列程序是用来判断数组中特定元素的位置所在如果输入如下整数 876 675 896 101 301 401 980 431 451 777 #includeconio.h #includestdio.h intfun(int*sinttint*k) {inti; *k=0; for(i=0;it;i++) if(s[*k]s[i])*k=i; returns[*k]; } main() { inta[10]={876675896101301401980431451777}k; clrscr(); fun(a10k); printf(%d%d\nka[k]); } 则输出结果为 A)7,431 B)6 C)980 D)6,980
(42)C语言结构体类型变量在程序执行期间 A)所有成员一直驻留在内存中 B)只有一个成员驻留在内存中 C)部分成员驻留在内存中 D)没有成员驻留在内存中
(43)下面程序应能对两个整型变量的值进行交换以下正确的说法是 main() {inta=10b=20; printf(
(1)a=%db=%d\nab); swap(ab); printf(
(2)a=%db=%d\nab); } swap(intpintq) {intt; t=p;p=q;q=t; } A)该程序完全正确 B)该程序有错,只要将语句swap(ab);中的参数改为ab即可 C)该程序有错,只要将swap()函数中的形参p和q以及t均定义为指针(执行语句不变)即可 D)以上说法都不对
(44)有以下程序 #includestdlib.h main() {char*p*q; p=(char*)malloc(sizeof(char)*20);q=p; scanf(%s %spq);printf(%s%s\npq); } 若从键盘输入abcdef回车,则输出结果是 A)defdef B)abcdef C)abcd D)dd
(45)以下程序的输出结果是 intf() {staticinti=0; ints=1; s+=i;i++; returns; } main() {intia=0; for(i=0;i5;i++)a+=f(); printf(%d\na); } A)20 B)24 C)25 D)15
(46)已知inta=1b=3则a^b的值为 A)3 B)1 C)2 D)4
(47)如果需要打开一个已经存在的非空文件“Demo”进行修改下面正确的选项是 A)fp=fopen(Demor); B)fp=fopen(Demoab+); C)fp=fopen(Demow+); D)fp=fopen(Demor+);
(48)若要打开A盘上user子目录下名为abc.txt的文本文件进行读、写操作,下面符合此要求的函数调用是 A)fopen(A:\user\abc.txtr) B)fopen(A:\\user\\abc.txtrt+) C)fopen(A:\user\abc.txtrb) D)fopen(A:\user\abc.txtw)
(49)有以下程序 #includestring.h main() {char*p=abcde\0fghjik\0; printf(%d\nstrlen(p)); } 程序运行后的输出结果是 A)12 B)15 C)6 D)5
(50)有以下程序 #includestdlib.h structNODE {intnum;structNODE*next;}; main() {structNODE*p*q*r; p=(structNODE*)malloc(sizeof(structNODE)); q=(structNODE*)malloc(sizeof(structNODE)); r=(structNODE*)malloc(sizeof(structNODE)); p-num=10;q-num=20;r-num=30; p-next=q;q-next=r; printf(%d\np-num+q-next-num); } 程序运行后的输出结果是 A)10 B)20 C)30 D)40
二、填空题
(6)下列y的值是【6】inty;y=sizeof(
2.25*4);解析sizeof(
2.25*4)为sizeof(
10.00)值为8,C语言规定浮点型常量当双精度处理(以IRM-PC机为例)
(7)下列x的值是【7】intx;x=sizeof
2.25*4;解析sizeof运算符高于算术运算符,所以sizeof
2.25*4等价于(sizeof
2.25)*4为8×4=32(以IBM-PC机为例)
(8)以下程序的输出结果是【8】main(){inti=010j=10; pirntf(%d%d\nij);}解析以0开头的是八进制数
(9)下列程序的输出结果为【9】main(){intx=3y=5;printf(%dx=(x--)*(--y));}解析x--的值为3,--y的值为4;注意前缀--和后缀--的区别
(10)以下程序的输出结果是【10】fun(intxintyintz){z=x*x+y*y;}main(){inta=31;fun(63a)printf(%da)}解析在函数调用时,形参值和改变,不能会改变实参的值
(11)若有inta=1;intb=2;则a|b的值为【11】解析将a化成二进数和制数是0001b化成二进制数为0010,|是或运算符,a|b=0011即为3
(12)已知字母a的ASCII码为十进制数97,且设ch为字符型变量,则表达式ch=′a′+′8′-′3′的值为【12】解析在C语言中,整型,实型,字符型数据间可以混合运算,在进行运算时,不同类型的数据要先转换成同一类型,然后再进行运算我们可以这样计算本题,97+8-3=102,即102所对应的字母为f
(13)若从键盘输入58则以下程序输出的结果是【13】main(){inta;scanf(%da);if(a50)printf(%da);if(a40)printf(%da);if(a30)printf(%da);}
(14)下列程序的输出的结果是【14】,【15】main(){intijrowcolumm;staticintarray[3][3]={{100200300}{2872-30}{-85026}};m=array[0][0];for(i=0;i<3;i++)for(j=0;j<3;j++)if(array[i][j]<m){m=array[i][j];colum=j;row=i;}printf(%d%d%d\nmrowcolum);}解析两个for循环是对数组元素进行扫描,并找是数组中值最小的元素和它的位置
(15)以下程序中,select函数的功能是在N行M列的二维数组中,选出一个最大值作为函数值返回,并通过形参传回此最大值所在的行下标请填空#defineN3#defineM3select(inta[N][M]int*n){intijrow=1colum=1;for(i=0;iN;i++)for(j=0;jM;j++)if(a[i][j]a[row][colum]){row=i;colum=j;}*n=【16】;return【17】;}main(){inta[N][M]={91123611591720}maxn;max=select(an);printf(max=%dline=%d\nmaxn);}解析本题中,首先假定a[1][1]为最大值,然后利用循环结构将二维数组中的每个元素逐个与a[row][colum]进行比较,如果比a[row][colum]的值大,则令a[row][colum]指向该元素,比较完后,row即是最大值所在的行,所以第1个空所在的行的语句应是*n=row;,在第2个空中返回最大值,显然,是a[row][colum]
(16)函数my_cmp()的功能是比较字符串s和t的大小,当s等于t时返回0,否则返回s和t的第一个不同字符的ASCII码差值,即st时返回正值,当st时返回负值请填空my_cmp(char*schar*t){while(*s==*t){if(*s==′\0′)return0;++s;++t;}return【18】;}解析两字符串大小比较必须从它们的首字符开始,在对应字符相等情况下循环,直至不相等结束相等时,若字符串已到了字符串的结束标记符,则两字符串相同,函数返回0值;如还有后继字符,则准备比较下一对字符对应字符不相同,循环结束循环结束时,就以两个当前字符的差返回所以在空框处应填入*s-*t,保证在st时返回正值,当st时返回负值
(17)若有以下说明和定义语句,则变量w在内存中所占的字节数是【19】unionaa{floatx;floaty;charc[6];};structst{unionaav;floatw[5];doubleave;}w;解析共用型aa有3个成分,一个是float型成分x一个是float型成分y,再一个是有6个元素的字符数组若float型数据占4个字节,则类型aa数据要占用6个字节结构变量w有3个成分,一个是共用型成分aa要占用6个字节;一个是有5个float型元素的数组w,要占用20个字节;一个是double型的avedouble型数据要8个字节,则结构变量w要占用34个字节
(18)“FILE*p”的作用是定义一个文件指针变量,其中的“FILE”是在【20】头文件中定义的解析代码“FILE*p”的作用是定义一个文件指针变量,其中的FILE是在标准输入输出头文件stdio.h中定义的
一、选择题 11-15 C A B D A 16-20 C C B A C 21-25 A C B D A26-30 C B C D C31-35 C C B D C36-40 C D B D A 41-45 B A D A D46-50 C D B D D。