打印本文 打印本文  关闭窗口 关闭窗口  
计算机等级考试二级C语言模拟练习一[1]
作者:佚名  文章来源:不详  点击数  更新时间:2008/4/18 13:57:43  文章录入:杜斌  责任编辑:杜斌

 (1)算法的空间复杂度是指
   A)算法程序的长度
   B)算法程序中的指令条数
   C)执行算法程序所占的存储空间
   D)算法执行过程中所需要的存储空间
   【答案】D
   【解析】算法的空间复杂度一般是指这个算法执行时所需要的内存空间,其中包括算法程序所占的空间、输入的初始数据所占的存储空间以及算法执行过程中所需要的额外空间,其中额外空间还包括算法程序执行过程的工作单元以及某种数据结构所需要的附加存储空间。

   (2)线性表的链式存储结构是一种
   A)随机结构
   B)顺序结构
   C)索引结构
   D)散列结构
   【答案】B
   【解析】线性表的链式存储结构中的每一个存储结点不仅含有一个数据元素,还包括指针,每一个指针指向一个与本结点有逻辑关系的结点。此类存储方式属于顺序存储。

   (3)设有下列二叉树:对此二叉树先序遍历的结果是
   A)ABCDEF
   B)DBEAFC
   C)ABDECF
   D)DEBFCA
   【答案】C
   【解析】二叉树的遍历分为先序、中序、后序三种不同方式。本题要求先序遍历;遍历顺序应该为:访问根结点->先序遍历左子树->先序遍历右子树。按照定义,先序遍历序列是ABDECF。

   (4)编制一个好的程序,首先要保证它的正确性和可靠性,还应强调良好的编程风格,在书写功能性注释时应考虑
   A)仅为整个程序作注释
   B)仅为每个模块作注释
   C)为程序段作注释
   D)为每个语句作注释
   【答案】C
   【解析】功能性注释是嵌在源程序体中的,用以描述其后的语句或程序段是在做什么工作,或者执行了下面的语句会怎么样。所以它描述的是一段程序,是为程序段做注释,而不是每条语句。

   (5)下列哪个是面向对象程序设计不同于其他语言的主要特点?
   A)继承性
   B)消息传递
   C)多态性
   D)静态联编
   【答案】A
   【解析】继承是一个子类直接使用父类的所有属性和方法。它可以减少相似的类的重复说明,从而体现出一般性与特殊性的原则,这使得面向对象程序设计语言有了良好的重用性,也是其不同于其他语言的主要特点。

   (6)需求分析最终结果是产生
   A)项目开发计划
   B)需求规格说明书
   C)设计说明书
   D)可行性分析报告
   【答案】B
   【解析】需求分析应交付的主要文档就是需求规格说明书。

   (7)在进行单元测试时,常用的方法是
   A)采用白盒测试,辅之以黑盒测试
   B)采用黑盒测试,辅之以白盒测试
   C)只使用白盒测试
   D)只使用黑盒测试
   【答案】A
   【解析】白盒测试是测试程序内部逻辑结构,黑盒测试只依据程序的需求规格说明书,检查程序的功能是否符合它的功能说明。从程序内部的逻辑结构对系统进行测试才是测试的根本,更容易发现和解决程序中的问题,因此单元测试时应该以白盒测试为主,而黑盒测试为辅。

   (8)数据库是()的集合,它具有统一的结构格式并存放于统一的存储介质,可被各个应用程序所共享。
   A)视图
   B)消息
   C)数据
   D)关系
   【答案】C
   【解析】数据库是数据的集合,其中的数据是按数据所提供的数据模式存放的,它能构造复杂的数据结构,以建立数据之间的内在联系与复杂的关系。

   (9)下列叙述中,不正确的是
   A)数据库技术的根本目标是要解决数据共享的问题
   B)数据库系统中,数据的物理结构必须与逻辑结构一致
   C)数据库设计是指设计一个能满足用户要求,性能良好的数据库
   D)数据库系统是一个独立的系统,但是需要操作系统的支持
   【答案】B
   【解析】数据库应该具有物理独立性和逻辑独立性,改变其一而不影响另一个。

   (10)规范化理论中,分解()是消除其中多余的数据相关性。
   A)关系运算
   B)内模式
   C)外模式
   D)视图
   【答案】A
   【解析】数据库规范化的基本思想是逐步消除数据依赖中不合适的部分,根本思想是通过分解关系运算来消除多余的数据相关性。



   (11)以下说法中,不正确的是
   A)C程序中必须有一个main()函数,从main()函数的第一条语句开始执行
   B)非主函数都是在执行主函数时,通过函数调用或嵌套调用而执行
   C)C程序中的main()函数必须放在程序的开始位置
   D)C程序中的main()函数位置可以任意指定
   【答案】C
   【解析】main()函数的作用,以及main()函数在程序中出现的位置。一个完整的C语言程序有且仅有一个主函数(main()函数)。程序总从main()函数的第一条语句开始执行,到main()函数的最后一条语句结束,其他函数都是在执行main()函数时,通过函数调用或嵌套调用而得以执行的。C语言规定,main()函数在程序中的位置是任意的。

   (12)变量a已被定义为整型,下列表达式不正确的是
   A)a='A'+20
   B)a-='a'
   C)a=c+【答案】D
   D)a='c'+'d'
   【答案】C
   【解析】在C语言中,字符变量可参与任何整数运算。本题中只有C有错,因为C选项中c、d如果是字符常量,应有单引号,如果是变量,应该提前定义。

   (13)下面程序的输出结果是
   #include <stdio.h>
   main()
   {int i=010,j=10;
   printf("%d,%d",++i,j--);
   }
   A)11,10
   B)9,10
   C)010,9
   D)10,9
   【答案】B
   【解析】程序中i的值用八进制表示(十进制为8),++i是在变量使用前自身先加1,而j--是在变量使用后自身减1。

   (14)下面可以作为C语言用户标识符的一组是
   A)void define WOR【答案】D
   B)a3_b3 _123 IF
   C)for --abc case
   D)2a D0 sizeof
   【答案】B
   【解析】在C语言中,合法的标识符可以由字母、数字和下划线组成,其中关键字不能作为用户的标识符,且开头的第一个字符必须为字母或下划线。选项A中void为关键字;选项C中for和case为关键字;选项D中sizeof为关键字。

   (15)下面哪一个不是正确的赋值语句?
   A)a++;
   B)a==b;
   C)a+=b;
   D)a=1,b=1;
   【答案】B
   【解析】C语言中赋值语句是由赋值表达式加“;”构成的。赋值表达式的形式为:变量=表达式;。选项A中a++相当于a+1,是赋值语句;选项C和选项D也是赋值语句。只有选项B不是,因为选项B中“==”符号是等于的意思,并不是赋值运算符。

   (16)若有定义:int a=8,b=5,c;执行语句c=a/b+0.4;后,c的值为
   A)1.4
   B)1
   C)2.0
   D)2
   【答案】B
   【解析】在表达式中根据运算的结合性和运算符的优先级,首先计算的是a/b(8/5=1),再将1+0.4赋值给c,由于c为整型变量所以要将1.4转换为整型,即舍弃小数位(c的值变为1)。

   (17)若变量a是int类型,并执行了语句:a='A'+1.6;则正确的叙述是
   A)a的值是字符C
   B)a的值是浮点型
   C)不允许字符型和浮点型相加
   D)a的值是字符'A'的ASCII值加上1。
   【答案】D
   【解析】在C语言中规定允许不同类型的量进行运算,但在运算时需转换成高级的类型进行运算。在表达式中有字符型和实型参加运算时,统一转换为实型再运算,当运算结果存入变量时再转换为该变量的类型。

   (18)以下程序段的输出结果是
   int a=1234;
   printf("%2d\n",a);
   A)12
   B)34
   C)1234
   D)提示出错、无结果
   【答案】C
   【解析】 printf()函数的输出格式,当整数的值超过格式要求输出范围时,原样输出。本题中要求输出两个有效数字,而实际上a有4个有效数字,故原样输出,输出1234。

   (19)以下选项中不属于C语言的类型的是
   A)signed short int
   B)unsigned long int
   C)unsigned int
   D)long short
   【答案】D
   【解析】在选项中很明显选项A为无符号短整型,选项B为无符号长整型,选项C为无符号整型,而选项D的类型在C语言中不存在。

   (20)若有说明语句:int a,b,c,*d=&c;则能正确从键盘读入三个整数分别赋给变量a、b、c的语句是
   A)scanf("%d%d%d",&a,&b,d);
   B)scanf("%d%d%d",&a,&b,&d);
   C)scanf("%d%d%d",a,b,d);
   D)scanf("%d%d%d",a,b,*d);
   【答案】A
   【解析】scanf()函数有两个参数,第一个参数是输入格式字符串,第二个参数是输入变量地址列表。输入格式字符串主要由“%”符号和格式字符组成。地址列表是由多个地址组成的。选项B中d已经为地址,不应在加上求地址符号“&”;选项C中,a和b都为变量不是地址,应该在a和b之前加上求地址符号“&”;选项D中指针d所指向的存储空间的位置为变量c的值,不为地址。



   (21)在16位C编译系统上,若定义long a;,则能给a赋40000的正确语句是
   A)a=20000+20000;
   B)a=4000*10;
   C)a=30000+10000;
   D)a=4000L*10L;
   【答案】D
   【解析】由于20000+20000、4000*10及30000+10000都是整型表达式,故运算的结果仍然是整型,表达式运算的结果超出了整型数据的范围,不正确。而D是长整型运算,不会超出长整型的范围。

   (22)以下叙述正确的是
   A)可以把define和if定义为用户标识符
   B)可以把define定义为用户标识符,但不能把if定义为用户标识符
   C)可以把if定义为用户标识符,但不能把define定义为用户标识符
   D)define和if都不能定义为用户标识符
   【答案】B
   【解析】C语言中的保留字,而define不是保留字。用户标识符不允许使用保留字。

   (23)若定义:int a=511,*b=&a;则printf("%d\n",*b);的输出结果为
   A)无确定值
   B)a的地址
   C)512
   D)511
   【答案】D
   【解析】本题中先定义了一个int型的变量a并赋初值为511,接着定义了一个指向a的指针变量b,在printf()函数的输出格式中,是输出*b,即输出指针所指向变量a的值为511,因此输出511。

   (24)以下程序的输出结果是
   main()
   { int a=5,b=4,c=6,d;
   printf(("%d\n",d=a>b?)(a>c? a:c):(b));
   }
   A)5
   B)4
   C)6
   D)不确定
   【答案】C
   【解析】在C语言中问号表达式(如:a>c?a:c;)的计算规则为:如果a>c为真,那么表达式的值为a的值;否则表达式的值为c的值。本题中的printf()函数中的输出表达式,首先计算括号内的条件表达式,它的值为6(a>c?a:c中a>c即5>6为假故该表达式的值为c的值即为6),然后再计算外面表达式(等价于a>b?6:b)的值,同理可得该表达式的值为6,将值6赋值给d,因此最后输出该表达式的值为6。

   (25)以下程序中,while循环的循环次数是
   main()
   { int i=0;
   while (i<10)
   { if(i<1)continue;
   if(i==5) break;
   i++;
   }
   …
   }
   A)1
   B)10
   C)6
   D)死循环,不能确定次数
   【答案】D
   【解析】break语句只能在循环体和switch语句体内使用,当break出现在switch语句体内时,其作用只是跳出该switch语句体。当break出现在循环体中,但不在switch语句体内时,则在执行break后,跳出本层循环体。而continue语句的作用是结束本次循环,即跳过本次循环中余下尚未执行的语句,接着再一次进行循环的条件判定。本程序中,变量i的初始值为0,判断while后面括号内表达式的值为真,执行循环体内的if语句,判断if后面括号内表达式的值为真,执行“continue;”语句。因continue的作用是结束本次循环,即跳过本次循环体中余下尚未执行的语句,接着再一次进行循环的条件判断,所以i的值未发生变化,循环条件仍然为真,if语句也仍然成立,因此循环将无止境地进行下去。

   (26)以下程序的输出结果是
   main()
   { int a=0,i;
   for(i=1;i<5;i++)
   { switch(i)
   { case 0:
   case 3:a+=2;
   case 1:
   case 2:a+=3;
   default:a+=5;
   }
   }
   printf("%d\n",a);
   }
   A)31
   B)13
   C)10
   D)20
   【答案】A
   【解析】switch语句的执行过程是:在switch后面的表达式的值和case后面常量表达式的值吻合时,就执行该case分支的语句。如果在该语句的后面没有break语句,则按顺序继续执行下一个case分支,直到遇到break语句或switch多分支语句结束,在switch语句中,break语句的作用是使流程跳出switch结构,终止switch语句的执行。在本题中,因为每个case语句后面都没有break语句,所以,第一轮循环(i==1)执行过后a的值为8,第2轮(i==2)执行过后a的值为16,第3轮(i==3)执行过后a的值为26,第4轮(i==4)执行过后a的值为31,然后执行“i++”语句,这时循环条件为假,循环结束。

   (27)以下程序的输出结果是
   main()
   { int a=4,b=5,c=0,d;
   d=!a&&!b‖!c;
   printf("%d\n",d);
   }
   A)1
   B)0
   C)非0的数
   D)-1
   【答案】A
   【解析】由于单目运算符优先级高于“&&”和“||”运算,所以先计算!a、!b和!c分别为“假”、“假”、“真”,然后是&&运算和“||”运算,原表达式就等价于“假”&&“假” ||“真”,又由于“&&”的优先级高于“||”运算符,所以先计算“假”&&“假”,还是为假,最后是“假”||“真”为真。因此最后d被赋值为1,故最后输出为1。

   (28)以下程序的输出结果是
   #include <stdio.h>
   main()
   { int i=0,a=0;
   while (i<20)
   { for(;;)
   { if((i%10)==0) break;
   else i--;
   }
   i+=11;a+=i;
   }
   printf("%d\n",a);
   }
   A)21
   B)32
   C)33
   D)11
   【答案】B
   【解析】break语句只能在循环体和switch语句体内使用。本题程序为在while循环中嵌套for循环。先看内层for循环,该循环的3个表达式全部省略,循环条件始终为真,但循环体内的break语句为终止循环的条件。首先,由初始条件判断外层循环while括号内表达式的值,该值为真,执行本次while循环,即执行循环体内的if语句,判断该表达式后面括号里表达式的值为真,执行break语句,跳出内层循环,执行下面的语句,此时i和a的值均变为11;回到外层循环,判断表达式“i<20”仍为真,执行内层循环语句,此时if条件不满足,执行else语句,i的值为10,继续内层循环,if语句条件满足,执行break语句,跳出内层循环,执行下面的语句后,i和a的值分别是21和32。再判断外层循环的条件为假,结束循环。

   (29)以下程序的输出结果是
   char cchar(char ch)
   {
   if(ch>='A' &&ch<='Z')ch=ch-'A'+'a';
   return ch;
   }
   main()
   { char s[]="ABC+abc=defDEF",*p=s;
   while(*p)
   { *p=cchar(*p);
   p++;
   }
   printf("%s\n",s);
   }
   A)abd+ABC=DEFdef
   B)abc+abc=defdef
   C)abcABCDEFdef
   D)abcabcdefdef
   【答案】B
   【解析】本题首先定义了一个函数cchar(),有一个字符型参数ch。在函数中首先判断该字符是否为大写字母,如果是则把它转换成小写字符再赋值给ch,把ch作为函数值返回。在主函数中定义了一个字符数组s并初始化,然后定义了一个指针变量并使它指向数组s。接着通过一个while循环利用指针变量p,依次取出字符数组的字符(直到遇到字符串结束标志'\0'),并调用cchar()函数,把大写字母转换成小写字母,其他字符不变。最后输出字符数组为s中的内容,结果为“abc+abc=defdef”。

   (30)以下程序的输出结果是
   int f()
   { static int i=0;
   int s=1;
   s+=i;i++;
   return s;
   }
   main()
   { int i,a=0;
   for(i=0;i<5;i++)a+=f();
   printf("%d\n",a);
   }
   A)20
   B)24
   C)25
   D)15
   【答案】D
   【解析】在C语言中声明为static型的变量,在整个程序运行期间,静态局部变量在内存的静态存储区中占据永久性的存储单元。即使退出函数后,下次再进入该函数时,静态局部变量仍使用原来的存储单元。由于并不释放这些存储单元,因此这些存储单元中的值得以保留;因而可以继续使用存储单元中原来的值。本题中函数f()中定义了一个static型变量i,故每调用一次函数f(),i的值加1,返回s的值等于i,在主函数中用了一个for循环,该循环执行了5次,每次都调用f()函数,将其返回值累加到变量a中,故最后a的值为1+2+3+4+5=15。



   (31)以下程序段的输出结果是
   char s[]="\\141\141abc\t";
   printf("%d\n",strlen(s));
   A)9
   B)12
   C)13
   D)14
   【答案】A
   【解析】字符数组中可以存放字符串,但字符数组的长度并不是字符串的长度,字符串的长度是指字符数组中存放的有效字符个数,即'\0',之前的字符数。字符数组s中依次存放的字符是:'\\'、'1'、'4'、'1'、'\141'、'a'、'b'、'c'和'\t',和最后一个字符串结束标记'\0',故字符串的长度是9。

   (32)若有以下程序
   #include <stdio.h>
   void f(int n);
   main()
   { void f(int n);
   f(5);
   }
   void f(int n)
   { printf("%d\n",n);}
   则以下叙述中不正确的是
   A)若只在主函数中对函数f进行说明,则只能在主函数中正确调用函数f
   B)若在主函数前对函数f进行说明,则在主函数和其后的其他函数中都可以 正确调用函数f
   C)对于以上程序,编译时系统会提示出错信息;提示对f函数重复说明
   D)函数f无返回值,所以可用void将其类型定义为无值型
   【答案】C
   【解析】若一个函数定义在主调函数之后,其返回值不是int或char型,则必须对之进行函数说明。可在函数外说明也可以在函数内说明,在函数外说明,在其后的所有函数均可调用该函数,若在函数内说明,则只能在本函数内调用该函数。函数只能定义一次,但函数说明可以出现多次。

   (33)以下程序调用findmax函数返回数组中的最大值
   findmax(int * a,int n)
   { int * p,* s;
   for (p=a,s=a;p-a<n;p++)
   if( ) s=p;
   return(*s);
   }
   main()
   { int x[5]={12,21,13,6,18};
   printf("%d\n",findmax(x,5));
   }
   在下划线处应填入的是
   A)p>s
   B)*p>*s
   C)a[p]>a[s]
   D)p-a>p-s
   【答案】B
   【解析】在main()函数中定义了一个具有5个元素的x数组并赋初值,然后调用findmax()函数求数组中元素的最大值。调用时把数组元素x的首地址,传给了形参指针变量a,把5传给形参n。在函数findmax()中定义了两种指针变量p和s,其中s用来记录最大元素的地址,p作为循环控制变量,表示每个元素的地址。求最大值的算法是先将第5个元素(用s记下它的地址)做为最大值,然后用最大值(*s)与后面的每个元素比较(*p),若后面的元素大,则用s记下它的地址,所以下划线应填“*s<*p”或“*p>*s”。

   (34)以下程序的输出结果是
   main()
   { char ch[3][5]={"AAAA","BBB","CC"};
   printf("\"%s"\n",ch[1]);
   }
   A)"AAAA"
   B)"BBB"
   C)"BBBCC"
   D)"CC"
   【答案】B
   【解析】二维字符数组可以看成由若干个一维字符数组组成,每行是一个一维字符数组。本题首先定义了一个数组ch[3][5],并给它们按行赋初值,即相当于给ch[0]赋值“AAAA”,给ch[1]赋值“BBB”,给ch[2]赋值“BBB”,最后输出转义字符“'\'”、ch[1]和转义字符“\”,因此输出为“BBB”。
  (35)在C语言中,形参的缺省存储类是
   A)auto
   B)register
   C)static
   D)extern
   【答案】A
   【解析】本题考核的知识点是定义函数时形参的缺省存储类。在C语言中,形参的缺省存储类为auto。

   (36)若指针p已正确定义,要使p指向两个连续的整型动态存储单位,不正确的语句是
   A)p=2*(int *)malloc(sizeof(int));
   B)p=(int *)malloc(2*sizeof(int));
   C)p=(int *)malloc(2*2);
   D)p=(int *)malloc(2,sizeof(int));
   【答案】A
   【解析】malloc()函数的调用格式是“malloc(n)”,作用是申请n个字符的存储单元并把该存储区的首地址作为返回值,实际调用的时候可在前面加上“(类型说明符*)”,以转换成需要的类型的地址。选项D多了一个参数,不符合malloc()函数的调用格式;整型变量在有的计算机系统里占4个字节,并不一定在所有的计算机系统里都是两个字节;选项A中是申请一个整型的存储空间并把该存储空间的首地址乘以2,这样的做法是不正确的,其存储空间为没乘以2之前的存储空间的2倍的连续存储空间的地址。

   (37)以下程序的输出结果是
   main()
   { char x=040;
   printf("%o\n",x<<1);
   }
   A)100
   B)80
   C)64
   D)32
   【答案】A
   【解析】首先将八进制040转换成二进制数000100000,再将此二进制数左移一位为001000000,输出时转换成八进制数100。

   (38)若要打开A盘上user子目录下名为abc.txt的文本文件进行读、写操作,下面符合此要求的函数调用是
   A)fopen("A:\user\abc.txt", "r")
   B)fopen("A:\\user\\abc.txt", "r+")
   C)fopen("A:\user\abc.txt", "rb")
   D)fopen("A:\\user\\abc.txt","w")
   【答案】B
   【解析】本题考核的知识点是文件名的表示法以及文件的读写模式。由于“\”是转义字符,所以在文件名中的“\”用“\\”来表示。要打开文本文件进行读写,应使用读写模式“r+”。

   (39)以下不能正确进行字符串赋初值的语句是
   A)char str[5]="good! ";
   B)char str[]="good! ";
   C)char *str="good! ";
   D)char str[5]={'g', 'o', 'o', 'd'};
   【答案】A
   【解析】选项A定义了一个字符数组str,具有5个元素,但赋初值的时候,初值个数却是6个(有一个'\0',);选项B定义了一个字符数组str并给它赋初值,由于省去了长度定义,长度由初值个数确定,相当于str[6];选项C定义了一个字符型指针变量并用一个字符串给它赋初值,使该字符型指针指向了该字符串;选项D是对字符型数组中单个元素依次赋初值。

   (40)若有下面的说明和定义:
   struct test
   { int ml;char m2;float m3;
   union uu{char ul[5];int u2[2];} ua;
   } myaa;
   则 sizeof(struct test)的值是
   A)12
   B)16
   C)14
   D)9
   【答案】A
   【解析】结构体所占用的存储空间是其所有成员占用的存储空间之和,而共用体所占用的存储空间是成员中占用存储空间最大者的空间,共用体类型uu是结构体的成员,它所占的内存长度为最大成员的长度,即字符型数组u1的长度,即1×5=5。每个整型数据占用2个字节,每个字符型数据占用一个字节,单精度型数据占4个字节,myaa为结构体变量,它所占的存储空间为各个成员所占存储空间之和,即2+1+4+5=12。



   (41)若有定义:int aa[8];。则以下表达式中不能代表数组元素aa[1]的地址是
   A)&aa[0]+1
   B)&aa[1]
   C)&aa[0]++
   D)aa+1
   【答案】C
   【解析】在C语言中,数组的地址和数组中的第一个元素的地址相同。数组中第一个元素地址的表示方法为&aa[0],与其等价的有&aa[0]++;选项A为数组的第1个元素的地址下移一位即是第二个元素aa[l]的地址;B也为数组的第二个元素的地址,选项D中aa表示数组的地址,加1表示数组首地址后移一位,即代表数组元素中的第二个元素aa[1]的地址。

   (42)以下程序的输出结果是
   f(int b[],int m,int n)
   { int i,s=0;
   for (i=m;i<n;i=i+2)s=s+b[i];
   return s;
   }
   main()
   { int x,a[]={1,2,3,4,5,6,7,8,9};
   x=f(a,3,7);
   printf("%d\n",x);
   }
   A)10
   B)18
   C)8
   D)15
   【答案】A
   【解析】在main()函数中定义了一个变量x,以及一个有9个元素的数组a,并且每个元素分别赋初值为1、2、3、4、5、6、7、8和9。执行函数调用f(a,3,7),把a的首地址赋给形参b,把3和7分别赋给形参m和n。在f()函数中,for循环执行了2次:第一次,i的值为3,相当于执行了语句“s=s+b[3]”,b[3]的值就是a[3]的值4,故s的值变为4;第二次,i值为5,相当于执行了语句“s=s+b[5];”,b[5]的值为6,故s的值变为10。把s作为函数值返回并赋值给x。

   (43)若有以下定义和语句:
   int s[4][5],(*ps)[5];
   ps=s;
   则对s数组元数的正确引用形式是
   A)ps+1
   B)*(ps+3)
   C)ps[0][2]
   D)*(ps+1)+3
   【答案】C
   【解析】本题首先定义了一个4行5列的数组s,又定义了一个指向由5个元素组成的一维数组的指针变量ps,通过赋值让ps指向了数组s的首地址。此时数组元素s[i][j]的地址为“*(ps+i)+j”,数组元素s[i][j]可表示为*(*(ps+i)+j)。选项B表示的是数组元素a[3][0]的地址;选项D表示的是数组元素s[1][3]的地址;选项A中“ps+1”为指向下一行(第二行)的地址;选项C中ps[0][2]无条件等价于“*(ps[0]+2)”又无条件等价于“*(*(ps+0)+2)”,即是数组元素s[0][2]。

   (44)以下程序的输出结果是
   main()
   { int b[3][3]={0,1,2,0,1,2,0,1,2},i,j,t=1;
   for (i=0;i<3;i++)
   for(j=i;j<=i;j++)t=t+b[i][b[j][j]];
   printf("%d\n",t);
   }
   A)3
   B)4
   C)1
   D)9
   【答案】B
   【解析】本题中定义了一个二维数组b并初始化,定义了一个变量t并赋初值1。接着通过一个二重循环将若干个元素的值加到变量t中。循环的执行步骤是:外层循环变量i=0时,内层循环变量j=i执行语句“t=t+b[i][b[j][j]]”,相当于t=t+b[0][b[0][0]],由于b[0][0]的值为0,得到t的值为1;依次类推,循环共执行了3次,最后输出t的值为4。

   (45)以下程序的输出结果是
   #include <stdio.h>
   #include <string.h>
   main()
   { char b1[8]="abcdefg",b2[8],*pb=b1+3;
   while(--pb>=b1)strcpy(b2,pb);
   printf("%d\n",strlen(b2));
   }
   A)8
   B)3
   C)1
   D)7
   【答案】D
   【解析】strcpy()函数的作用是把第二个参数代表的字符串,复制到第一个参数指向数组中。首先定义了两个字符数组b1和b2,并用一个字符串给b1赋初值,然后定义了一个字符型指针变量pb,通过赋初值使它指向b1[3]。接着执行while循环,该循环执行了3次:第一次判断条件“--pb>=b1”,使pb的值为“b1+2”,执行“strcpy(b2,pb);”后,b2中的内容为“cdefg”;第二次判断条件“--pb>=b1”,使pb的值为“b1+1”,执行“strcpy(b2,pb);”后b2的内容为“bcdefg”第三次判断条件“--pb>=b1”使pb的值为“b1”,执行“strcpy(b2,pb);”后b2的内容为“abcdefg”。最后输出b2数组中存放的字符串长度,显然是7。(这里还有一个关键点:就是每当执行一次while循环判断条件,就执行一次“--pb”,使得指针pb自减1,即前移一位)。

   (46)在说明语句:int *f();中,标识符f代表的是
   A)一个用于指向整型数据的指针变量
   B)一个用于指向一维数组的行指针
   C)一个用于指向函数的指针变量
   D)一个返回值为指针型的函数名
   【答案】D
   【解析】定义指向整型元素的指针变量形式为:int*指针变量名。定义指向整型一维数组的行指针形式为:int(*指针变量名[长度],定义指向返回值为整型的函数的指针变量的形式为:int(*函数名)(),定义返回值为指向整型的指针型函数的形式为:int *函数名()。本题定义的是一个返回值为指针型的函数f()。

   (47)不合法的main函数命令行参数表示形式是
   A)main(int a,char *c[])
   B)main(int arc,char **arv)
   C)main(int argc,char *argv)
   D)main(int argv,char *argc[])
   【答案】C
   【解析】main()函数可以带有参数,并且参数只能有两个,第一个参数类型为整型,用来记下命令行的参数个数;第二个参数为一个字符型指针数组,或字符型二级指针变量(指向一个数组,数组元素又是一个一级字符指针),其各个元素用来记下从命令行各参数字符串的首地址。故本题只有C选项不符合要求。

   (48)以下程序的输出结果是
   int x=3;
   main()
   { int i;
   for(i=1;i<x;i++)incre();
   }
   incre()
   { static int x=1;
   x*=x+1;
   printf("%d",x);
   }
   A)3 3
   B)2 2
   C)2 6
   D)2 5
   【答案】C
   【解析】本题首先定义一个全局变量x并赋初值为3,主函数中使用这个全局变量控制循环次数,循环执行了2次,调用两次incre()函数。第一次调用incre(),定义一个静态变量x并赋初值1,然后执行“x*=x+1”,使x的值变为2;第二次调用incre()函数时,静态变量将保留上一次退出时的值即2,执行语句“x*=x+1”后,x的值变成6,输出x的值为6。

   (49)若有以下定义:
   struct link
   { int data;
   struct link *next;
   }a,b,c,*p,*q;
   且变量a和b之间已有如下图所示的链表结构:指针p指向变量a,q指向变量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;
   【答案】D
   【解析】在本题中指针p指向变量a,q指向变量c。要把c插入到变量a和变量b之间,就应该首先让变量a的指针域指向变量c,即(*p).next=q,然后让变量c的指针域指向变量b,即(*q).next=&b。

   (50)设有以下说明语句
   typedef struct
   { int n;
   char ch[8];
   } PER;
   则下面叙述中正确的是
   A)PER是结构体变量名
   B)PER是结构体类型名
   C)typedef struct是结构体类型
   D)struct是结构体类型名
   【答案】B
   【解析】本题通过typedef在定义一个结构体类型的同时,把它自定义成类型名PER,故PER是结构体类型名。


  二、填空题。

   (1)算法的复杂度主要包括空间复杂度和【1】复杂度。
   【解析】算法的复杂度主要指时间复杂度和空间复杂度。

   (2)在线性结构中,队列的操作顺序是先进先出,而栈的操作顺序是【2】 。
   【解析】队列和栈都是线性结构,但是不同之处在于队列的操作顺序是先进先出,而栈的操作顺序是先进后出。

   (3)数据流图的类型有【3】和事务型。
   【解析】典型的数据流图有两种,即变换型和事务型。

   (4)在数据库理论中,数据物理结构的改变,如存储设备的更换、物理存储的更换、存取方式等都不影响数据库的逻辑结构,从而不引起应用程序的变化,称为【4】 。
   【解析】数据的物理结构改变,不影响数据库的逻辑结构,从而不引起应用程序的变化,这种性质叫做物理独立性。

   (5)数据库管理系统是位于用户与【5】之间的软件系统。
   【解析】数据库管理系统是帮助用户创建和管理数据库的应用程序的集合。因此,数据库管理系统需要操作系统的支持,为用户提供服务。

   (6)若从键盘输入58,则以下程序的输出结果是【6】 。
   main()
   { int a;
   scanf("%d",&a);
   if(a>50) printf("%d",a);
   if(a>40) printf("%d",a);
   if(a>30) printf("%d",a);
   }
   【解析】在程序中,执行scanf()语句后,a被赋值为58。接着执行第一个if语句,因为,a=58>50,执行第一个if语句后面的输出语句,输出58;接着执行第二个if语句,因为,a=58>40,执行第二个if语句后面的输出语句,输出58;接着执行第三个if语句,因为,a=58>30,执行第三个if语句后面的输出语句,输出58,所以最后的输出为585858。

   (7)以下程序的输出结果是【7】 。
   main()
   { int a=177;
   printf("%o\n",a);
   }
   【解析】在控制格式符中“o”代表的是将数据按八进制数输出,十进制数的177代表的八进制数是261。

   (8)以下程序的输出结果是【8】 。
   main()
   { int a=0;
   a+=(a=8);
   printf("%d\n",a);
   }
   【解析】在程序中首先将8赋值给变量a,然后再进行复合赋值运算。即a=a+a=8+8=16,所以该空格处应该填16。

   (9)以下程序的输出结果是【9】 。
   main()
   { int a=5,b=4,c=3,d;
   d=(a>b>c);
   printf("%d\n",d);
   }
   【解析】关系运算符“>”的结合方式是从左向右的,所以在本题中的表达式a>b>c;从左向右开始计算,a>b的结果为“1”,接着1和c比较假,该空格处应该填0。

   (10)以下定义的结构体类型包含两个成员,其中成员变量info用来存放整型数据;成员变量link是指向自身结构体的指针。请将定义补充完整。
   struct node
   { int info;
   【10】link;
   };
   【解析】link是指向结构体自身的指针,因此link是指针,指向struct node类型的数据,可定义成“struct node *link”。



   (11)以下程序的输出结果是【11】 。
   main()
   { int s,i;
   for(s=0,i=1;i<3;i++,s+=i);
   printf("%d\n",s);
   }
   【解析】此程序中,for循环语句后面直接跟了一个“;”,表明循环体为空。输出语句不在for循环体内,所以在循环执行完毕后才输出s的值。s、i的初值分别为0和1,判断循环条件,表达式“1<3”成立,执行“i++,s+=i”后,i和s的值分别为2和1,继续判断循环条件,表达式“2<3”成立,执行“i++,s+=i”后,i和s的值分别为3,再次判断循环条件,表达式“3<3”不成立,循环结束。

   (12)以下程序的输出结果是【12】 。
   main()
   { char *p="abcdefgh",*r;
   long *q;
   q=(long *)p;
   q++;
   r=(char *)q;
   printf("%s\n",r);
   }
   【解析】本题定义了一个字符型指针变量p并通过赋初值让它指向了一个字符串,定义了另一个字符型指针变量r和一个长整型指针变量q。首先通过语句“q=(long*)p;”把p的地址值强制转换为长整型地址值并赋值给q,然后执行“q++;”,地址值增加了4,执行语句“r=(char*)q;”,把长整型指针变量q的值再强制转换成字符型地址值并赋给r,r的值应为字符串中字符“e”的地址,最后输出r指向的字符串,是“efgh”。

   (13)以下程序的输出结果是【13】 。
   main()
   { char s[]="abcdef";
   s[3]='\0';
   printf("%s\n",s);
   }
   【解析】字符串的结束标记'\0',当输出一个存放在字符数组中的字符串时,只需输出到'\0'为止,而不管其后有什么数据。本题给字符数组s的元素s[3]赋值为'\0',故只能输出3个字符“abc”。

   (14)以下程序的输出结果是【14】 。
   main()
   { int x=0;
   sub(&x,8,1);
   printf("%d\n",x);
   }
   sub(int *a,int n,int k)
   { if(k<=n)sub(a,n/2,2*k);
   *a+=k;
   }
   【解析】在主函数中定义了一个变量x并赋初值0,然后执行函数调用语句,该语句的执行过程为sub(&x,8,1)调用sub(&a,4,2),sub(&a,4,2)调用sub(&a,2,4),sub(&a,2,4)中由于2<4,所以if后面括号里的判断为假,递归结束,执行其后的*a+=k;语句此时x=x+k=0+4=4,回退到上一层调用函数sub(&x,4,2)中,执行后面的语句,x=x+k=4+2=6,再回推到最上一层调用函数sub(&x,8,1)执行后面的语句,x=x+k=6+1=7,所以最后输出7。

   (15)设有如下宏定义
   #define MYSWAP(z,x,y) {z=x;x=y;y=z;}
   以下程序段通过宏调用实现变量a、b内容的交换,请填空。
   float a=5,b=16,c;
   MYSWAP(【15】,a,b);
   【解析】本题关键在考生是不是了解宏的基本运用,在使用宏的时候明显少了一个实参。在定义宏的时候变量z是用来做中间变量的,题目中缺的变量就是一个中间变量c。

   (16)以下程序用来统计文件中字符的个数。请填空。
   #include "stdio.h"
   main()
   { FILE * fp; long num=0L;
   if((fp=fopen("fname.dat", "r"))==NULL);
   { printf("Open error\n");exit(0);}
   while(【16】)
   { fgetc(fp);num++;}
   printf("num=%1d\n",num-1);
   fclose(fp);
   }
   【解析】统计文件中字符个数的算法可描述如下:首先判断文件位置指针是否指向了文件尾,如果不是则读出一个字符,同时字符的个数加1,再判断文件位置指针是否位于文件尾,如此循环,直到文件位置指针位于文件尾为止。本题首先以读文件的方式打开了文件“fname.dat”,如果打开成功则把返回的文件型指针赋值给fp,然后通过循环求文件中的字符数。首先判断文件位置指针是否位于文件尾,如果不是则循环读取字符,每次字符数加1。所以下划处应填循环条件,文件位置指针不是指向文件尾,即“!feof(fp)”。

   (17)以下程序中,select函数的功能是:在N行M列的二维数组中,选出一个最大值作为函数值返回,并通过形参传回此最大值所在的行下标。请填空。
   #define N 3
   #define M 3
   select(int a[N][M],int *n)
   { int i,j,row=1,colum=1;
   for(i=0;i<N;i++)
   for(j=0;j<M;j++)
   if(a[i][j]>a[row][colum]){row=i;colum=j;}
   *n=【17】;
   return(【18】);
   }
   main()
   { int a[N][M]={9,11,23,6,1,15,9,17,20},max,n;
   max=select(a,&n);
   printf("max=%d,line=%d\n",max,n);
   }
   【解析】指针变量作为函数参数及二维数组的一个典型算法—求最大值及其下标。通过对题意的分析,在select()函数中,变量row的作用是用来记录最大元素的行下标,colum的作用是用来记录最大元素的列下标。程序中通过一个循环求得数组元素中最大值的行列下标,分别存放在变量row和colum中,根据题意,应该把行下标赋值给形参指针变量n指向的变量,把最大值a[row][colum]作为函数值返回。

   (18)mystrlen函数的功能是计算str所指字符串的长度,并作为函数值返回。请填空。
   int mystrlen(char *str)
   { int i;
   for(i=0;【19】!= '\0';i++);
   return(【20】);
   }
   【解析】求str指向的字符串长度的算法是:用一个变量i表示字符串中字符的位置,一开始赋值为0,取出i位置的字符,判断是否为“\0”,若不是,则i的值加1,如此循环直到取出的字符是“\0”为止,此时i的值就是字符串的长度。由此可知,第一个空处应填第i位置上的字符*(str+i);第二个空格应该填字符串的长度i。

打印本文 打印本文  关闭窗口 关闭窗口