14.1 新增真考试题

第1套 新增真考试题

一、选择题

（1）下列叙述中错误的是（ ）。

A）算法的时间复杂度与问题规模无关　　　　B）算法的时间复杂度与计算机系统无关

C）算法的时间复杂度与空间复杂度没有必然的联系　　D）算法的空间复杂度与算法运行输出结果的数据量无关

（2）设表的长度为20。 则在最坏情况下，冒泡排序的比较次数为（　　）。

A）190　　　　B）20　　　　C）19　　　　D）90

（3）下列叙述中正确的是（　　）。

A）带链栈的栈底指针是随栈的操作而动态变化的

B）若带链队列的队头指针与队尾指针相同，则队列为空

C）若带链队列的队头指针与队尾指针相同，则队列中至少有一个元素

D）带链栈的栈底指针是固定的

（4）设一棵树的度为3，共有27个节点，其中度为3，2，0的节点数分别为4，1，10。 该树中度为1的节点数为（　 ）。

A）12　　　　B）13　　　　C）11　　　　D）不可能有这样的树

（5）下面描述中正确的是（　　）。

A）好的软件设计应是高内聚低耦合　　　　B）内聚性和耦合性无关

C）内聚性是指多个模块间相互连接的紧密程度　　　 D）耦合性是指一个模块内部各部分彼此结合的紧密程度

（6）某系统总体结构如下图所示。

该系统结构图的最大扇出数、最大扇入数的总和是（　 ）。

A）5　　　　B）7　　　　C）4　　　　D）8

（7）下面属于应用软件的是（　　）。

A）人事管理系统 B）Oracle数据库管理系统

C）C++编译系统 D）iOS操作系统

（8）下面选项中不是关系数据库基本特征的是（　　）。

A）不同的列应有不同的数据类型　　　　B）不同的列应有不同的列名

C）与行的次序无关　　　　D）与列的次序无关

（9）工厂生产中所需的零件可以存放在多个仓库中，而每一仓库中可存放多种零件。 则实体仓库和零件间的联系是（　　）。

A）多对多　　　　B）一对多　　　　C）多对一　　　　D）一对一

（10）学生和课程的关系模式定义为：

S（S＃，Sn，Sd，Dc，Sa）（其属性分别为学号、姓名、所在系、所在系的系主任、年龄）；

C（C＃，Cn，P＃）（其属性分别为课程号、课程名、先选课）；

SC（S＃，C＃，G）（其属性分别学号、课程号和成绩）。

关系中包含对主属性传递依赖的是（　　）。

A）S＃→Sd，Sd→Dc　　　　B）S＃→Sd

C）S＃→Sd，（S＃，C＃）→G　　　　D）C＃→P＃，（S＃，C＃）→G

（11）以下叙述中正确的是（　　）。

A）计算机能直接运行未经编译的C语言程序

B）循环结构、选择结构、顺序结构是结构化程序的3种基本结构

C）复杂算法不能使用N-S流程图来描述

D）计算机能够直接处理不超过20行源码的简单C语言程序

（12）以下说法正确的是（　　）。

A）C语言程序运行时可以从键盘上读入用户输入的C源程序并附加到本程序的尾部一并执行

B）C语言程序运行时可以从键盘上读入用户以二进制输入的指令，并执行这些指令

C）C语言程序运行时可以从键盘上读入用户输入的C源程序并逐行执行

D）C语言程序运行时可以从键盘上读入用户输入的字符或数据，并依此改变程序的运行步骤

（13）若有程序段：

charc；

doubled；

scanf（＂%lf%c＂，&d，&c）；

如果想把2.3输入给变量d，字符＇f＇输入给变量c，程序运行时正确的输入是（　　）。

A）2.3 f　　　　B）2.3f　　　　C）2.3＇f＇　　　　D）2.3 ＇f＇

（14）设a、b、c是已定义的整型变量且已正确赋初值，以下赋值语句中错误的是（　　）。

A）a=（b=3） =1；　　 B）a=（b=0） +c+0；　　　 C）a=b=c+0；　　　　D）a=0+（b=c=0）；

（15）若有定义：inta=3；doubleb=0.1263；charch=＇a＇；，则以下选项中，叙述有错的是（　　）。

A）逗号表达式的计算结果是最后一个逗号之后的表达式的运算结果

B）运算符%只能对整数类型的变量进行运算

C）语句ch=（unsigned int）a+b；是对a与b之和进行强制类型转换，结果赋值给变量ch

D）复合运算：a*=b+ch是将变量b、ch之和与a相乘，结果再给a赋值

（16）以下可以正确且安全地用作用户标识符的一组选项是（　　）。

A）_32int，long64　　　　B）Switch，unsigned

C）Abc， getch　　　　D）3break，enter

（17）若有定义：charch；inta；doubled；，当输入12345 678910.36时，以下选项中能给各个变量正确输入数据的是（　　）。

A）scanf（＂%d%c%lf＂，&a，&ch，&d）；　　　　B）scanf（＂%5d%2c%7.2lf＂，&a，&ch，&d）；

C）scanf（＂%d%c%lf＂，a，ch，d）；　　　　D）scanf（＂5d%2c%7.2lf%＂，&a，&ch，&d）；

（18）以下选项中，合法的C语言实数是（　　）。

A）3.1e3.1　　　　B）.2e1　　　　C）E09　　　　D）1.23E

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

A）＃include＜stdio.h＞是C程序的一条语句

B）使用符号\可以将一条＃include命令写在多行里

C）一个＃include行可以包含多个文件，文件名用逗号分开

D）一个＃include行可以包含多个文件，且最后一个文件起作用

（20）与数学公式（x2 -y2）·cos（45°）对应的C语言表达式是（　 ）。

A）（pow（x，2）-pow（y，2））*cos（3.1415926*45/180）

B）（pow（2，x）-pow（2，y））*cos（3.1415926*45/180）

C）（x*x-y*y）*cos（45）

D）（x^2-y^2）*cos（45）

（21）以下程序拟实现计算s=1+2 ×2+3 ×3+…+n ×n+…，直到s＞1000为止。

＃include＜stdio.h＞

main（）

｛ ints，n；

s=1；

n=1；

do

｛ n=n+1；s=s+n*n；}

while（s＞1000）；

printf（＂s=%d\n＂，s）；

}

程序运行后，不能得到正确结果，以下修改方案正确的是（　　）。

A）把n=n+1；改为n=n*n；　　　　B）把s=1；改为s=0；

C）把n=1；改为n=0；　　　　D）把while（s＞1000）；改为while（s＜=1000）；

（22）有如下程序：

＃include＜stdio.h＞

main（）

｛

chara，b；

inti；

a=＇3＇；

b=＇A＇；

for（i=0；i＜6；i++）

｛

if（i% 2）putchar（a+i）；

elseputchar（b+i）；

}

}

程序运行后的输出结果是（　　）。

A）AB56EF　　　　B）A4C6E8　　　　C）B4D6F8　　　　D）A5C7E9

（23）设有定义：intsum=100，i；

以下选项中，能够实现sum-=1+2+3…+10的程序段是（ ）。

A）for（i=0；i＜=10；）

sum=sum-i++；

B）i=0；

do

｛

sum=sum-++i；

}while（i＜=10）；

C）i=0；

while（i＜＞

sum=sum-++i；

D）i=1；

for（；i＜10；i++）

sum=sum-i++；

（24）有下列程序：

＃include＜stdio.h＞

main（）

｛ inta=123456，b；

while（a）

｛ b =a%10；

a/=10；

switch（b）

｛ default：printf（＂%d＂，b++）；

case1：

case2：printf（＂%d＂，b++）；break；

case3：printf（＂%d＂，b++）；break；

case4：printf（＂%d＂，b++）；

}

}

}

程序执行后的输出结果是（　　）。

A）76654321　　　　B）12345667　　　　C）67564321　　　　D）654321

（25）有以下程序：

＃include＜stdio.h＞

main（）

｛

chari，j，n；

for（i=＇1＇；i＜=＇9＇；i++）

｛

if（i＜＇3＇）continue；

for（j=＇0＇；j＜=＇9＇；j++）

｛

if（j＜＇2＇||j＞=＇4＇）continue；

n=（i-＇0＇）*10+j-＇0＇；

printf（＂%d＂，n）；

}

if（i==＇4＇）break；

}

printf（＂\n＂）；

}

程序运行后的输出结果是（　　）。

A）32 33 42 43　　　　B）30 31 40 41　　　　C）34 35 44 45　　　　D）35 36 45 46

（26）以下叙述中正确的是（　　）。

A）无论指针变量p具有何种基类型，表达式p=p+1都代表指针p移动一个字节

B）指针变量具有基类型，基类型不同的指针变量不能直接相互赋值

C）指针变量的赋值操作：p=0；是非法的

D）通过指针变量存取某个变量值的方式称为“直接存取”方式

（27）有以下程序：

＃include＜stdio.h＞

void swap（int*a，int*b）

｛ intt，*tp；

t=*a；*a=*b；*b =t；

tp =a；a=b；b =tp；

printf（＂%d，%d，＂，*a，*b）；

}

main（）

｛ inti=3，j=7，*p=&i，*q=&j；

swap（p，q）；

printf（＂%d，%d，%d，%d＂，i，j，*p，*q）；

}

程序执行后的输出结果是（　　）。

A）3，7，3，7，3，7　　　　B）7，3，7，3，7，3　　　　C）3，7，3，7，7，3　　　　D）3，7，7，3，7，3

（28）对于函数声明 void fun（floatarray[]，int*ptr）；以下叙述正确的是（　　）。

A）函数fun的参数array、ptr都是指针变量

B）函数fun的参数array是数组名，ptr是指针变量，它们有本质区别

C）调用函数fun时，实参数组元素个数可以比形参array数组元素个数多

D）调用函数fun时，传送给形参array的应是数组的所有元素

（29）以下叙述中正确的是（　　）。

A）＇\x41＇和＇\101＇都是转义字符常量　　　　B）＂\\＂与＇\\＇都是字符串常量

C）＂＂是空的字符串，＂是空字符NULL　　　　D）＂\n＂和＇\n＇都是回车字符

（30）以下选项中，能够正确利用随机函数rand（），产生一个英文字母的表达式是（　　）。

A）rand（）%2==0？ rand（）%＇A＇： rand（）%＇a＇　　　　B）rand（）%26+＇A＇||rand（）%26+＇a＇

C）rand（）%26+＇A＇&&rand（）%26+＇a＇　　　　D）rand（）%2==0？ rand（）%26+＇A＇：rand（）%26+＇a＇

（31）若有定义inta=3，*p=&a，**q=&p；，则以下叙述中错误的是（ ）。

A）q是指针变量，*q就是变量a　　　　B）p是指针变量，p指向变量a

C）q指向变量p，所以*q指向变量a　　　　D）*p与**q都代表变量a

（32）有下列程序：

＃include＜stdio.h＞

void f（intx[]，intn）

｛ if（n＞1）

｛ printf（＂%d＂，x[n-1]）；

f（x，n-1）；

printf（＂%d＂，x[n-1]）；

}

else

printf（＂%d＂，x[n-1]）；

}

main（）

｛ inta[4] =｛1，2，3，4}；

f（a，4）；

}

程序执行后的输出结果是（　　）。

A）1234321　　　　B）43211234　　　　C）4321234　　　　D）12344321

（33）有以下不完整函数：

intfun（char*p）

｛ char*t=p；

while（*t++）；

return（______）；

}

该函数的功能是：计算p所指字符串占用内存单元的个数，作为函数值返回。 return语句下划线处应填入的是（　　）。

A）t-p　　　　B）*t　　　　C）*t-*p　　　　D）t

（34）有下列程序：

＃include＜stdio.h＞

＃include＜string.h＞

main（）

｛charv[4][10] =｛＂efg＂，＂abcd＂，＂mnopq＂，＂hijkl＂}，*p[4]，*t；

inti，j；

for（i=0；i＜4；i++）

p[i] =v[i]；

for（i=0；i＜3；i++）

for（j=i+1；j＜4；j++）

if（strcmp（p[i]，p[i]）＞0）

｛t=p[i]；p[i] =p[i]；p[i] =t；}

for（i=0；i＜4；i++）

printf（＂%s＂，p[i]）；

}

程序执行后的输出结果是（　　）。

A）efgabcd hijklmnopq　　　　B）abcd efghijklmnopq

C）mnopq hijklefgabcd　　　　D）efgabcd mnopq hijkl

（35）有以下程序：

＃include＜stdio.h＞

＃defineS1（z）4*z+4*（z）

＃defineS2（x，y）4*（x）*（y）+y*x

main（）

｛ inta=1，b=2；

printf（＂%d，＂，S1（a+b））；

printf（＂%d，＂，S2（a，b）+S1（3））；

printf（＂%d＂，S2（3+a，b+3））；

}

程序执行后的输出结果是（　　）。

A）18，34，100　　　　B）24，34，92　　　　C）24，34，100　　　　D）18，34，92

（36）带有头节点的单向链表head，其3个数据节点A、B、C的连接关系如下图所示。

节点类型的定义为：

structlink

｛

doubledt；

structlink *next；

}；

若指针p指向A节点，在不改变p指向的前提下，以下选项中不能访问C节点数据成员dt的表达式是（　　）。

A）*（*p）.next-＞next-＞dt　　　　B）p-＞next-＞next-＞dt

C）（*（*（*p）.next）.next）.dt　　　　D）（*（p-＞next-＞next））.dt

（37）设有定义：

＃include＜stdio.h＞

＃include＜stdlib.h＞

typedefstruct｛ intx，y；} T；

typedefstruct｛ intx，y；} *USER；

USERfun（）

｛ USERp；

p=（USER）malloc（sizeof（T））；

p-＞x=1；

p-＞y=2；

return p；

}

函数fun返回值的类型是（　　）。

A）T类型的结构体　　　　B）指向结构体类型的指针

C）int类型的元素　　　　D）int类型的指针

（38）有以下宏定义及调用：

＃defineHA2

＃defineHB（a）（HA+1）*a

...

x=HA*（HA+HB（2））；

则以下判断正确的是（　　）。

A） 宏定义不允许嵌套　　　　B）x的值是6

C） x的值是16　　　　D）宏调用不允许嵌套

（39）若以“a+”方式打开一个已存在的文件，以下叙述正确的是（　　）。

A）文件打开时，原有文件内容不被删除，可以进行添加和读操作

B）文件打开时，原有文件内容不被删除，位置指针移到文件开头，可以进行重写和读操作

C）文件打开时，原有文件内容不被删除，位置指针移到文件中间，可以进行重写和读操作

D）文件打开时，原有文件内容被删除，只可进行写操作

（40）有下列程序：

＃include＜stdio.h＞

main（）

｛FILE*fp；

inti，a[6] =｛ 1，2，3，4，5，6}；

fp=fopen（＂d.dat＂，＂w+b＂）；

for（i=0；i＜6；i++）

fwrite（&a[i]，sizeof（int），1，fp）；

rewind（fp）；

fread（&a[3]，sizeof（int），3，fp）；

fclose（fp）；

for（i=0；i＜6；i++）

printf（＂%d，＂，a[i]）；

}

程序执行后的输出结果是（　　）。

A） 4，5，6，4，5，6，　　　　B）1，2，3，4，5，6，　　　　C）4，5，6，1，2，3，　　　　D） 1，2，3，1，2，3，

二、程序填空题

下列给定程序中，函数fun的功能是：将形参a所指数组中的前半部分元素中的值与后半部分元素中的值对换。形参n中存放数组中数据的个数，若n为奇数，则中间的元素不动。

例如，若a所指数组中的数据为：1，2，3，4，5，6，7，8，9，则调换后为：6，7，8，9，5，1，2，3，4。

请在程序的下划线处填入正确的内容并将下划线删除，使程序得出正确的结果。

注意：部分源程序给出如下。不得增行或删行，也不得更改程序的结构！

试题程序：

#include ＜stdio.h＞

#define N 9

void fun（int a[ ]，int n）

｛

int i，t，p；

／********found********／

p=（n% 2==0）？n／2：n／2+【1】；

for（i=0；i＜n／2；i++）｛

t=a[i]；

／********found********／

a[i] =a[p+【2】]；

／********found********／

【3】 =t；

｝

｝

main（）

｛

int b[N] =｛1，2，3，4，5，6，7，8，9｝，i；

printf（＂\nThe original data：\n＂）；

for（i=0；i＜N；i++）

printf（＂% 4d＂，b[i]）；

printf（＂\n＂）；

fun（b，N）；

printf（＂\nThe data after moving：\n＂）；

for（i=0；i＜N；i++）

printf（＂% 4d＂，b[i]）；

printf（＂\n＂）；

｝

三、程序修改题

下列给定程序中函数fun的功能是：把从主函数中输入的3个数，最大的数放在a中，中间的数放在b中，最小的数放在c中。

例如，若输入的数为：55 12 34，输出的结果应当是：a=55.0，b=34.0，c=12.0。

请改正程序中的错误，使它能得出正确的结果。

注意：不要改动main函数，不得增行或删行，也不得更改程序的结构！

试题程序：

#include ＜stdio.h＞

void fun（float*a，float*b，float*c）

｛

／********found********／

float *k；

if（*a＜*b）

｛

k=*a；

*a=*b；

*b=k；

｝

／********found********／

if（*a ＞ *c）

｛

k=*c；

*c=*a；

*a=k；

｝

if（*b＜*c）

｛

k=*b；

*b=*c；

*c=k；

｝

｝

main（）

｛

float a，b，c；

printf（＂Input a b c：＂）；

scanf（＂% f% f% f＂，&a，&b，&c）；

printf（＂a=% 4.1f，b=% 4.1f，c=% 4.1f\n\n＂，a，b，c）；

fun（&a，&b，&c）；

printf（＂a=% 4.1f，b=% 4.1f，c=% 4.1f\n\n＂，a，b，c）；

｝

四、程序设计题

学生的记录由学号和成绩组成，N名学生的数据已放入主函数中的结构体数组s中，请编写函数fun，其功能是：把分数最高的学生数据放在b所指的数组中。注意：分数最高的学生可能不止一个，函数返回分数最高的学生人数。

注意：部分源程序给出如下。

请勿改动主函数main和其他函数中的任何内容，仅在函数fun的花括号中填入你编写的若干语句。

试题程序：

#include ＜stdio.h＞

#define N 16

typedef struct

｛

char num[10]；

int s；

｝STREC；

int fun（STREC *a，STREC *b）

｛

｝

void main（）

｛

STREC s[N]=｛｛＂GA005＂，85｝，｛＂GA003＂，76｝，｛＂GA002＂，69｝，｛＂GA004＂，85｝，｛＂GA001＂，91｝，｛＂GA007＂，72｝，｛＂GA008＂，64｝，｛＂GA006＂，87｝，｛＂GA015＂，85｝，｛＂GA013＂，91｝，｛＂GA012＂，64｝，｛＂GA014＂，91｝，｛＂GA011＂，77｝，｛＂GA017＂，64｝，｛＂GA018＂，64｝，｛＂GA016＂，72｝｝；

STREC h[N]；

int i，n；

n=fun（s，h）；

printf（＂The % d highest score：\n＂，n）；

for（i=0；i＜n；i++）

printf（＂% s % 4d\n ＂，h[i].num，h[i].s）； ／*输出最高分学生的学号和成绩*／

printf（＂\n＂）；

｝

第2套 新增真考试题

一、选择题

（1）设数据结构B=（D，R），其中

D=｛a，b，c，d，e，f}

R=｛（f，A），（d，B），（e，D），（c，e），（a，C）}

该数据结构为（

A）线性结构　　　　B）循环队列　　　　C）循环链表　　　　D）非线性结构

（2）下列叙述中错误的是（　　）。

A）循环队列空的条件是队头指针与队尾指针相同

B）若二叉树没有叶子节点，则为空二叉树

C）带链栈的栈底指针是随栈的操作而动态变化的

D）若带链队列中只有一个元素，则队头指针与队尾指针必定相同

（3）某带链栈的初始状态为 top=bottom=NULL，经过一系列正常的入栈与退栈操作后，top=bottom=20。该栈中的元素个数为（　）。

A）1　　　　B）0　　　　C）20　　　　D）不确定

（4）设一棵度为3的树，其中度为2，1，0的节点数分别为3，1，6。 该树中度为3的节点数为（　　）。

A）1　　　　B）2　　　　C）3　　　　D）不可能有这样的树

（5）下面描述错误的是（　　）。

A）模块的独立性与模块的信息隐蔽和局部化无关　　 B）内聚性和耦合性是模块独立程度的定性度量标准

C）一个模块的内聚性越高则该模块的独立性越强　　 D）一个模块的耦合性越高则该模块的独立性越弱

（6）下面属于黑盒测试方法的是（　　）。

A）错误推测法　　　　B）基本路径测试　　　　C）判定覆盖　　　　D）条件覆盖

（7）下面模型中为概念模型的是（　　）。

A）实体-联系模型　　 B）层次模型　　　　C）关系模型　　　　D）网状模型

（8）学生关系模式中有D（D＃，Dn，Dl，DAddr）（其属性分别为系编号、系名称、系主任和系地址）和S（S＃，Sn，SG，Date，Maj，D＃）（其属性分别为学号、姓名、性别、入学日期、专业和系编号）两个关系，关系S的主键（码）是S＃，关系S的外键（码）是（ ）。

A）D＃　　　　B）Maj　　　　C）Dl　　　　D）Dn

（9）关系的实体完整性要求关系中不能为空的属性是（　　）。

A）主键属性　　　　B）外键属性　　　　C）全部属性　　　　D）候选键属性

（10）学生选修课程的关系模式为：SC（S＃，Sn，Sd，Sa，C＃，G）（其属性分别为学号、姓名、所在系、年龄、课程号和成绩）；C（C＃，Cn，P＃） （其属性分别为课程号、课程名、先选课）。关系模式中包含对主属性部分依赖的是（ ）。

A）S＃→Sd　　　　B）（S＃，C＃）→G　　　　C）C＃→Cn　　　　D）C＃→P＃

（11）以下叙述中错误的是（　　）。

A） main（）是C语言主函数的起始　　　　B） main（）作为主函数必须位于源程序的起始位置行

C）main（）是C程序执行的起始行　　　　D）main 是不可替代的主函数名

（12）以下叙述中错误的是（　　）。

A）在一个程序中，每个模块均可以独立编译运行

B）程序“模块化”有利于任务的分解简化

C）允许对函数单独进行编译，是C语言实现“模块化”的基础

D）采用模块化结构，可以提高编程效率

（13）以下关于注释的叙述中错误的是（　　）。

A）注释的边界符号“/”和“*”之间不允许加入空格

B）C语言允许注释出现在程序中任意合适的地方

C）注释的内容仅用于阅读，对程序的运行不起作用

D）注释的边界符号“/*”和“*/”必须成对出现且可以嵌套

（14）以下是正确C语言标识符的是（　　）。

A）_8_　　　　B）^8^　　　　C）～8～　　　　D）-8

（15）算术运算符和圆括号有不同的运算优先级，对于程序表达式a+b+c*（d+e）的执行顺序，以下说法正确的是（　　）。

A）先执行（d+e）得r2，再执行c*r2得r3，再执行a+b得r1，最后执行r1+r3得表达式最后结果

B）先执行a+b得r1，再执行（d+e）得r2，再执行c*r2得r3，最后执行r1+r3得表达式最后结果

C）先执行（d+e）得r2，再执行c*r2得r3，再执行b+r3得r4，最后执行a+r4得表达式最后结果

D）先执行a+b得r1，再执行r1+c得r5，再执行（d+e）得r2，最后执行r5*r2得表达式最后结果

（16）设有定义语句：

doublex=123.456；

则语句printf（＂%6.2f，%3.0f\n＂，x，x）；的输出结果是（　　）。

A） 123.46，123.0　　　B）123.45，123　　　　C） 123.46，123　　　　D）123.45，123.

（17）有如下程序：

＃include＜stdio.h＞

main（）

｛

intx=072；

printf（＂＞%d＜\n＂，x+1）；

}

程序运行后的输出结果是（　　）。

A） ＞073＜　　　　B） ＞73＜　　　　C） ＞142＜　　　　D） ＞59＜

（18）有以下程序：

＃include＜stdio.h＞

void main（）

｛

doublex=3.14159；

printf（＂%f\n＂，（int）（x*1000+0.5）/（double）1000）；

}

程序运行后的输出结果是（　　）。

A）3.142000　　　　B）3.141000　　　　C）3.143000　　　　D）3.140000

（19）以下选项中错误的是（　　）。

A）printf（＂%s\n＂， ＇s＇）；　　　　B）printf（＂%d %c\n＂， ＇s＇，＇s＇）；

C）printf（＂%c\n＂， ＇s＇-32）；　　　　D）printf（＂%c\n＂，65）；

（20）若有定义：inta，b，c；，想通过语句：scanf（＂%d，%d%d＂，&a，&b，&c）；把1、2、3分别输入给变量a、b、c，则正确的键盘输入是（ ）。

A）1，2，3＜回车＞　　　　B）1，2＜tab＞3＜回车＞

C）1＜回车＞＜tab＞2＜tab＞3　　　　D）1＜回车＞2＜回车＞3

（21）有以下程序：

＃include＜stdio.h＞

main（）

｛ inta=1，b=2，c=3，d=4，r=0；

if（a！=1）r=1；

if（b==2）r=2；

elseif（c！=3）r=3；

elseif（d==4）r=4；

printf（＂%d\n＂，r）；

}

执行后的输出结果是（　　）。

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

（22）若有如下形式的函数：

intfun（inta[]，int*p，intn）

｛……}

调用函数之前需要对函数进行声明，则以下选项中错误的是（　　）。

A）intfun（int，int，int）；　　　　B）intfun（inta[ ]，int*p，intn）；

C）intfun（inta[ ]，int*，int）；　　　　D）intfun（int[ ]，int*，int）；

（23）有以下程序：

＃include＜stdio.h＞

main（）

｛ inti，j=0；

chara[ ] =＂ab123c4d56ef7gh89＂；

for（i=0；a[i]；i++）

if（a[i] ＞=＇0＇&&a[i] ＜=＇9＇）

a[j++] =a[i]；

a[j] =＇\0＇；

printf（＂%s＂，a）；

}

程序执行后的输出结果是（　　）。

A）123456789abcdefgh　 B）abcdefgh　　　　C）123456789　　　　D）1234567896ef7gh89

（24）有以下程序：

＃include＜stdio.h＞

main（）

｛ inta=-2，b=2；

for（；++a&&--b；）

printf（＂%d，%d，＂，a，b）；

}

程序执行后的输出结果是（ ）。

A）0，1，　　　　B） -1，1，0，1，　　　　C） -1，1，0，0，　　　　D） -1，1，

（25）若有以下程序：

＃include＜stdio.h＞

intfun（intx）

｛ inty；

y=x++；

return y；

}

main（）

｛ intk；

for（k=0；k＜3；k++）｛ printf（＂%d，＂，fun（k）+k）；k++；}

}

执行后的输出结果是（　　）。

A） 1，5，　　　　B）0，6，　　　　C） 0，4，　　　　D）1，7，

（26）有以下程序：

＃include＜stdio.h＞

int*f（int*s）

｛ s+=2；

s[1] +=6；

*s=7；

return s；

}

main（）

｛ inta[5] =｛1，2，3，4，5}，*p=a；

p=f（p）；

printf（＂%d，%d，%d，%d＂，a[0]，a[1]，*p，p[1]）；

}

程序执行后的输出结果是（　　）。

A）1，2，7，10　　　　B）7，8，7，8　　　　C）1，2，1，2　　　　D）7，10，7，10

（27）有以下程序：

＃include＜stdio.h＞

main（）

｛ inta=6，i；

for（i=1；i＜=3；i++）

｛ if（a＞=5）break；

if（a%2）｛ a+=2；continue；}

a=（a-3，a+4）；

}

printf（＂%d，%d＂，i，a）；

}

程序执行后的输出结果是（　　）。

A）0，6　　　　B）1，6　　　　C）8，6　　　　D）4，2

（28）以下表达式中，其值不等于数值3的是（　　）。

A）0 +＇3＇　　　　B）＇D＇-＇A＇　　　　C）＇3＇-＇0＇　　　　D）＇d＇-＇a＇

（29）有以下程序：

＃include＜stdio.h＞

void fun（inta[ ]，intn，intflag）

｛ inti=0，j，t；

for（i=0；i＜n-1；i++）

for（j=i+1；j＜n；j++）

if（flag）

｛ if（a[i] ＜a[j]）

｛ t=a[i]；a[i] =a[j]；a[j] =t；}

}

else

｛ if（a[i] ＞a[j]）

｛ t=a[i]；a[i] =a[j]；a[j] =t；}

}

}

main（）

｛ intc[10] =｛7，9，10，8，3，5，1，6，2，4}，i；

fun（c，10，0）；

fun（c，5，1）；

for（i=0；i＜10；i++）

printf（＂%d，＂，c[i]）；

}

程序运行结果正确的是（　　）。

A）6，7，8，9，10，5，4，3，2，1，　　　　B）5，4，3，2，1，6，7，8，9，10，

C）6，7，8，9，10，1，2，3，4，5，　　　　D）1，2，3，4，5，6，7，8，9，10，

（30）下面关于编译预处理的命令行中，正确的是（　　）。

A）＃defineintINT　　　　B）＃＃defineeps0.001

C）＃＃DEFINETRUE　　　　D）＃defineE2.88

（31）有如下程序：

＃include＜stdio.h＞

main（）｛

inti，data；

scanf（＂%d＂，&data）；

for（i=0；i＜5；i++）

｛

if（（i＜data&&i% 2）||（i＞data&&i% 3 ==0））continue；

printf（＂%d，＂，i）；

}

}

程序运行时，从键盘输入：13＜回车＞后，程序输出结果为（　　）。

A）0，2，4，　　　　B）1，3，5，　　　　C）0，1，2，3，4，5，　　　　D）0，1，2，3，

（32）设变量n已正确定义并赋值，以下不能实现自然数1到n累加求和的程序段是（　　）。

A）intsum=1，i=0；

while（i＜=n）

｛ i++； sum+=i； }

B）intsum=0，i=1；

while（i＜=n）

｛ sum+=i； i++； }

C）intsum=0，i=0；

while（i＜n）

｛ i++； sum+=i； }

D）intsum=1，i=1；

while（i＜n）

｛ i++； sum+=i； }

（33）关于数组和指针，以下说法错误的是（　　）。

A）数组名本身就是一个指针，指向数组内存的起始位置

B）既可以读入数据到数组中，也可以读入数据到未赋初值的指针中

C）可以让一个指针指向一个同类型的数组

D）指针可以指向同类型的数组中的任意一个元素

（34）有下列程序：

＃include＜stdio.h＞

int*f（int*s）

｛ s+=1；

s[1] +=6；

*s++ +=7；

return s；

}

main（）

｛ inta[5] =｛1，2，3，4，5}，*p；

p=f（&a[1]）；

printf（＂%d，%d，%d，%d＂，a[1]，a[2]，*p，p[1]）；

}

程序执行后的输出结果是（　　）。

A）3，9，10，5　　　　B）2，16，4，5　　　　C）2，10，10，5　　　　D）10，9，4，5

（35）有以下程序：

＃include＜stdio.h＞

doublefun1（doublea[]，intn）

｛

inti；doublesum=0.0；

for（i=0；i＜n；i++）

sum+=a[i]/n；

return sum；

}

void fun2（doublea[]，intn，double*p，double*q）

｛

inti；

*p=*q=a[0]；

for（i=1；i＜n；i++）

if（a[i] ＞*p）*p=a[i]；

elseif（a[i] ＜*q）*q=a[i]；

}

void main（）

｛

doublea[] =｛1，2，3，4，5}；

doublemx，mn，av；

av=fun1（a，5）；

fun2（a，5，&mx，&mn）；

printf（＂%f%f%f\n＂，av，mx，mn）；

}

程序的运行结果是（　　）。

A）5.000000 3.000000 1.000000　　　　B）3.000000 5.000000 1.000000

C）1.000000 5.000000 3.000000　　　　D）3.000000 1.000000 5.000000

（36）设有函数说明语句：

intfun（int，int）；

以及函数指针定义语句：

int（*f）（int，int）；

若要使函数指针指向函数fun的入口地址，以下选项中正确的是（　　）。

A）f=fun（ ）；　　　　B）*f=fun；　　　　C）f=fun；　　　　D）*f=fun（ ）；

（37）有如下程序：

＃include＜stdio.h＞

structgroup

｛

intfirst，second，third；

}；

structgroup get_min_max_sum（int* array，intlen）

｛

inti；

structgroup res；

res.first=array[0]；

res.second =array[0]；

res.third =array[0]；

for（i=1；i＜len；i++）

｛

if（array[i] ＜res.first）

res.first=array[i]；

if（array[i] ＞res.second）

res.second =array[i]；

res.third +=array[i]；

}

return res；

}

main（）

｛

intarray[5] =｛9，1，3，4}；

structgroup res=get_min_max_sum（array，5）；

printf（＂min=%d，max=%d，sum=%d\n＂，res.first，res.second，res.third）；

}

程序运行后的输出结果是（　　）。

A）min=0，max=9，sum=17　　　　B）min=1，max=9，sum=16

C）min=1，max=4，sum=15　　　　D）min=0，max=4，sum=16

（38）若有语句：void* p=malloc（80）；，则以下叙述错误的是（　　）。

A）可以通过指针p直接访问用malloc开辟的这块内存

B）p所指内存可以通过强制类型转换当作具有20个int型元素的一维数组来使用

C）p所指内存可以通过强制类型转换当作具有10个double型元素的一维数组来使用

D）p所指内存可以通过强制类型转换当作具有80个char型元素的一维数组来使用

（39）设有如下类型说明语句

typedefstruct

｛ intnum；

struct｛ inty，m，d；}date；

} PER；

则以下定义结构体数组并赋初值的语句中错误的是（　　）。

A）PERst[2]=｛｛1001}，2008，8，1，｛1002}，2006，5，20}；

B）PERst[2]=｛1001，｛2008，8，1}，1002，｛2006，5，20}}；

C）PERst[2]=｛｛1001，2008，8，1}，｛1002，2006，5，20}}；

D）PERst[2] =｛1001，2008，8，1，1002，2006，5，20}；

（40）C语言中标准库函数fputs（str，fp）的功能是（　　）。

A）从str指向的文件中读一个字符串存入fp指向的内存

B）把str所指的字符串输出到fp所指的文件中

C）从fp指向的文件中读一个字符串存入str指向的内存

D）把fp指向的内存中的一个字符串输出到str指向的文件

二、程序填空题

下列给定程序中，函数fun的功能是：从形参ss所指字符串数组中，删除所有串长超过k的字符串，函数返回剩余字符串的个数。ss所指字符串数组中共有N个字符串，且串长小于M。

请在程序的下划线处填入正确的内容并将下划线删除，使程序得出正确的结果。

注意：部分源程序给出如下。不得增行或删行，也不得更改程序的结构！

试题程序：

#include ＜stdio.h＞

#include ＜string.h＞

#define N 5

#define M 10

int fun（char（*ss）[M]，int k）

｛int i，j=0，len；

／********found********／

for（i=0；i＜ 【1】；i++）

｛ len=strlen（ss[i]）；

／********found********／

if（len＜=【2】）

／********found********／

strcpy（ss[j++]，【3】）；

｝

return j；

｝

void main（）

｛ char x[N][M] =｛＂Beijing＂，＂Shanghai＂，＂Tianjin＂，＂Nanjing＂，＂Wuhan＂｝；

int i，f；

printf（＂\nThe original string\n\n＂）；

for（i=0；i＜N；i++）puts（x[i]）；

printf（＂\n＂）；

f=fun（x，7）；

printf（＂The string witch length is less than or equal to 7：\n＂）；

for（i=0；i＜f；i++）puts（x[i]）；

printf（＂\n＂）；

｝

三、程序修改题

下列给定程序中函数fun的功能是：逐个比较p、q所指两个字符串对应位置上的字符，并把ASCII值大或相等的字符依次存放到c所指的数组中，形成一个新的字符串。

例如，若主函数中a字符串为“aBCDeFgH”，b字符串为“ABcd”，则c中的字符串应为“aBcdeFgH”。

请改正程序中的错误，使它能得出正确的结果。

注意：不要改动main函数，不得增行或删行，也不得更改程序的结构！

试题程序：

#include ＜stdio.h＞

#include ＜string.h＞

void fun（char*p，char*q，char*c）

｛

／********found********／

int k = 1；

／********found********／

while（*p！= *q）

｛ if（*p＜*q）c[k]=*q；

else c[k] =*p；

if（*p）p++；

if（*q）q++；

k++；

｝

｝

main（）

｛ char a[10] =＂aBCDeFgH＂，b[10] =＂ABcd＂，c[80] =｛＇\0＇｝；

fun（a，b，c）；

printf（＂The string a：＂）；puts（a）；

printf（＂The string b：＂）；puts（b）；

printf（＂The result：＂）；puts（c）；

｝

四、程序设计题

规定输入的字符串中只包含字母和* 号。请编写函数fun，其功能是：除了字符串前导的* 号之外，将串中其他* 号全部删除。在编写函数时，不得使用C语言提供的字符串函数。

例如，字符串中的内容为“**** A* BC* DEF* G*******”，删除后，字符串中的内容应当是“**** ABCDEFG”。

注意：部分源程序给出如下。请勿改动主函数main和其他函数中的任何内容，仅在函数fun的花括号中填入你编写的若干语句。

试题程序：

#include ＜string.h＞

#include ＜stdio.h＞

#include ＜conio.h＞

void fun（char *a）

｛

｝

main（）

｛

char s[81]；

printf（＂Enter astring：\n＂）；

gets（s）；

fun（s）；

printf（＂The string after deleted：\n＂）；

puts（s）；

｝