全国计算机二级C语言 # (11)选择题:函数(1-71)

全国计算机二级C语言 # 选择题:函数(1-71)


1. 函数调用语句:fun( ( exp1, exp2 ), ( exp1, exp2, exp3) ); 含有的实参个数是答案:D
A)4
B)5
C)1
D)2
题目解析:函数调用的参数之间用逗号分隔,表达式”exp1, exp2″和”exp1, exp2, exp3″为逗号表达式,各为一个参数,总共参数个数为2。


2. 有以下程序
#include <stdio.h>
#include <string.h>
main()
{
char  str[12] = { ‘s’,’t’ , ‘r’ , ‘i’ , ‘n’ , ‘g’} ;
printf(“%d “, strlen( str ) );
}
程序运行后的输出结果是答案:C
A)12
B)11
C)6
D)7
题目解析:strlen()函数的功能是计算字符串的实际长度(不包含结束标志),所以求得的字符串长度为6。


3. 有以下程序

#include <stdio.h>
void  fun( int x, int y, int *z )
{   *z = y-x;  }
main()
{
int   a, b, c;
fun(10,5,&a ); fun(7,a,&b ); fun(a,b,&c );
printf(“%d,%d,%d “, a,b,c );
}
程序运行后的输出结果是答案:B
A)5,2,3
B)-5,-12,-7
C)5,-2,-7
D)-5,-12,-17
题目解析:函数fun()返回的是y-x的值并存放在指针变量z指向的变量中。所以函数fun(10,5,&a );调用结束后,a=-5;函数fun(7,a,&b );调用结束后,b=-5-7=-12;函数fun(a,b,&c );调用结束后,c=-12-(-5)=-7。


4. 有以下程序

#include <stdio.h>
void  fun( int *s, int n1, int n2 )
{  int  i,j,t;
i=n1;  j=n2;
while( i<j )
{  t=*(s+i);  *(s+i)=*(s+j);  *(s+j)=t;
i++;   j–;
}
}
main()
{
int  a[10] = { 1,2,3,4,5,6,7,8,9,0} ,i, *p = a;
fun( p,0,3 ); fun( p,4,9 ); fun( p,0,9 );
for( i=0; i<10; i++ )printf(“%d “, *( a+i ) );
printf(” ” );
}
程序运行后的输出结果是答案:B
A)0 9 8 7 6 5 1 2 3 4
B)5 6 7 8 9 0 1 2 3 4
C)0 9 8 7 6 5 4 3 2 1
D)4 3 2 1 0 9 8 7 6 5
题目解析:函数fun()的功能是将数组s中下标为n1和n2之间的数据逆序,所以调用语句fun( p,0,3 ); fun( p,4,9 ); fun( p,0,9 );结束后,是先将数组p中下标为0至3之间的元素逆序,然后将下标为4至9之间的元素逆序,再将整个数组逆序。


5. 当没有指定C语言中函数形参的存储类别时,函数形参的存储类别是答案:A

A)自动(auto)
B)寄存器(register)
C)外部(extern)
D)静态(static)
题目解析:C语言中,当省略变量的存储类型时,局部变量的存储类别默认为auto。


6. 有如下程序

#include <stdio.h>
int sum(int a, int b)
{
return a + b – 2;
}
main()
{
int i;
for (i=0; i<5; i++)
printf(“%d”, sum(i, 3));
printf(” “);
}
程序运行后的输出结果是答案:D
A)54321
B)01234
C)45678
D)12345
题目解析:函数fun()的作用是返回a+b-2的值,所以循环依次输出sum(0,3)、sum(1,3)、sum(2,3)、sum(3,3)、sum(4,3)。


7. 有如下程序

#include <stdio.h>
int change(int* data)
{
return (*data) ++;
}
main()
{
int data = 123;
change(&data);
printf(“%d,”, data);
data = change(&data);
printf(“%d,”, data);
printf(” “);
}
程序运行后的输出结果是答案:B
A)123,124,
B)124,124,
C)123,123,
D)124,123,
题目解析:函数change()为中先获取指针data指向的变量的数值并返回之后该数值再自增。函数为地址传参,形参与实参的变化保持同步,所以调用语句”change(&data);”执行完毕后,data的值为123+1=124,调用语句”data = change(&data);”,函数change()将返回值赋值给data,返回的是变化之前的数据,所以输出结果仍然是124。


8. 有如下程序

#include <stdio.h>
void change(int* array, int len)
{
for (; len>=0; len–)
array[len] += 2;
}
main()
{
int i, array[5] = {1,2};
change(array, 4);
for (i=0; i<4; i++)
printf(“%d,”, array[i]);
printf(” “);
}
程序运行后的输出结果是答案:D
A)2,3,4,5,
B)3,4,5,6,
C)1,2,0,0,
D)3,4,2,2,
题目解析:函数change()的功能是把数组array中前len个元素均加2,数组定义语句”array[5] = {1,2};”定义数组的前两个元素分别为1、2,其余元素为0,调用change()函数结束后,array={3,4,2,2,2}。


9. 有如下程序

#include <stdio.h>
void convert(char ch)
{
if (ch < ‘D’) convert(ch+1);
printf(“%c”, ch);
}
main()
{
convert(‘A’);  printf(” “);
}
程序运行后的输出结果是答案:A
A)DCBA
B)ABCD
C)A
D)ABCDDCBA
题目解析:函数conver()的作用是输出ASCII码在字母’D’到字母ch之间的字符。


10. 有如下程序

#include <stdio.h>
void get_put()
{
char ch;
ch = getchar();
if (ch != ‘ ‘) get_put();
putchar(ch);
}
main()
{
get_put();  printf(” “);
}
程序运行时,输入1234<回车>,则输出结果是答案:D
A)1234
B)4444
C)1111
D)4321
题目解析:函数get_put()的作用是利用递归调用,优先输出最后一个输入的字符,即逆序输出输入的字符串。


 

11. 有如下程序

#include <stdio.h>
int sub(double  a, double  b)
{
return (int)(a – b);
}
main()
{
printf(“%d “, sub(3.8, 2.1));
}
程序运行后的输出结果是答案:C
A)2
B)2.0
C)1
D)1.7
题目解析:函数sub()返回的是a与b差的取整值,所以sub(3.8,2.1)的计算结果为(int)1.7=1。


12. 有如下程序

#include <stdio.h>
int sum(int* array, int len)
{
if (len == 0)
return array[0];
else
return array[0] + sum(array+1, len-1);
}
main()
{
int array[5] = {1,2,3,4,5};
int res = sum(array, 4);
printf(“%d “, res);
}
程序运行后的输出结果是答案:B
A)10
B)15
C)1
D)8
题目解析:函数sum()的作用是计算数组array中元素下标为len到0的所有元素的和。


13. 以下关于函数的叙述中正确的是答案:A

A)函数形参的类型与返回值的类型无关
B)函数必须要有形参
C)函数必须要有返回值
D)函数调用必须传递实参
题目解析:函数分为有参函数和无参函数,所以一个函数定义时可以有形参也可以没有形参,调用函数时必须和被调函数的参数列表保持一致,所以选项B)、D)错误;函数调用时可以没有返回值,此时函数的类型用void标识,选项C)错误;选项A)描述正确。


14. 有以下程序

#include <stdio.h>
main()
{   char *mm[4]={“abcd”,”1234″,”mnop”,”5678″};
char **pm=mm;
int i;
for(i=0; i<4; i++) printf(“%s”,pm[i]+i);
printf(” “);
}
程序的运行结果是答案:C
A)abcd1234mnop5678
B)a1m5
C)abcd234op8
D)a2o8
题目解析:输出语句”printf(“%s”,pm[i]+i);”表明输出以pm[i]+i为首地址的之后的字符串,输出语句共执行4次,输出以p[0],p[1]+1,p[2]+2,p[3]+3为起始位置的字符串,分别为”abcd”, “234”, “op”, “8”。


15. 有以下程序

#include <stdio.h>
void fac2(int );
void fac1(int n)
{   printf(“*”);
if(n>0) fac2(n-1);
}
void fac2(int n)
{   printf(“#”);
if(n>0) fac2(–n);
}
main()
{  fac1(3); }
程序的运行结果是答案:A
A)*###
B)**##
C)*#*#
D)*##*
题目解析:考查函数的嵌套调用,嵌套调用顺序分别为:fac1(3)、fac2(2)、fac2(1)、fac2(0),每调用fac1()输出一个”*”,调用fac2()输出一个”#”。


16. 有以下程序

#include <stdio.h>
int fun(int n)
{  static int t=1;   int i=1;
for( ; i<=n; i++)  t*=i;
return t;
}
main()
{  int t=1,i;
for(i=2;i<4; i++)
t+=fun(i);
printf(“%d “,t);
}
程序的运行结果是答案:B
A)4
B)15
C)8
D)11
题目解析:函数fun()调用两次,fun(2)中计算出的结果为2,由于函数fun()中有一个静态变量t,静态变量在定义时的初始化只运行一次,并且其值在程序运行过程中一直存在,所以第二次调用fun(3)时t=3,计算结果为12。主函数main()用局部变量t累加两次调用结果,t初始值为1,所以最终t=15。


17. 有以下程序

#include <stdio.h>
int m1(int x,int y)
{ return x<=y ? x :y; }
int m2(int x,int y)
{ return x<=y ? y :x; }
int fun(int a,int b)
{ return a+b; }
main()
{  int x=2,y=3,z=1;
printf(“%d “, fun(m1(x,y),m2(y,z)));
}
程序的运行结果是答案:C
A)4
B)3
C)5
D)6
题目解析:函数m1()返回两个参数中较小的数值,函数m2()返回两个参数中较大的数值,函数fun()返回两个参数之和,所以fun(m1(x,y),m2(y,z))=fun(m1(2,3),m2(3,1))=fun(2,3)=5。


18. 设有函数定义:void sub(int k,char ch){ … } 则以下对函数sub的调用语句中,正确的是答案:B

A)sub(2,’97’);
B)sub(1,97);
C)sub(4,”a”);
D)n=sub(3,’a’);
题目解析:字符常量与其ASCII码值一一对应,在计算的时候,可以用字符数据对应的ASCII码代表该字符参与运算,另外,该函数的函数类型为void,没有返回值。


19. 有以下程序

#include <stdio.h>
void fun(int *x,int s,int n)
{  int i;
for(i=s; i>=n; i–)
*(x+i+3) = *(x+i);
}
main()
{  int m[]={0,1,2,3,4,5,6,7,8,9},k;
fun(m,10-4,3);
for(k=0; k<10;k++)
printf(“%d”,m[k]);
}
程序的运行结果是答案:A
A)0123453456
B)0123456666
C)0123456345
D)0123454569
题目解析:函数fun()的功能是将数组x下标为n+3至s+3的元素被下标为n到s的元素覆盖,所以调用函数fun(m,10-4,3);结束后数组m中第7到10个元素被数组m的第4到7个元素覆盖,数组中的元素为{0,1,2,3,4,5,3,4,5,6}


20. 以下不能将键盘输入的字符串:This is a string<回车>读入到str中的程序段是答案:A

A)char str[80];  scanf(“%s”,str) ;
B)char str[80], *ps=str;  do{ scanf(“%c”,ps); } while(*ps++ !=’ ‘); *(–ps)=0;
C)char str[80];  gets(str);
D)char str[80];  int i=0;  while((str[i++]=getchar())!=’ ‘);  str[i-1]=0;
题目解析:scanf()函数输入字符串时,空格和回车都会作为分隔符,所以选项A)只能把字符串”This”记录到str中,不能读入完整的字符串。


21. 有以下程序

#include <stdio.h>
main()
{  int findmax(int,int,int),m;

m=findmax(a,b,c);

}
int findmax(int x,int y,int z)
{       …          }
则以下叙述正确的是答案:B
A)在main函数中定义了findmax函数
B)在main函数中声明了findmax函数
C)在main函数中两次调用了findmax函数
D)在main函数内、外重复定义了findmax函数
题目解析:函数不能嵌套定义,但是可以在一个函数体内对另一个函数进行声明,函数声明的一般形式为”类型说明符 被调函数名( 类型 形参, 类型 形参…)”,所以语句”int findmax(int,int,int)”为对函数findmax()的声明,语句”m=findmax(a,b,c);”为调用函数findmax(),在main()函数外是函数findmax()的定义。


22. 有以下程序

#include <stdio.h>
#define N 4
void fun(int a[][N])
{
int i;
for(i=0; i<N; i++)
a[0][i] += a[N-1][N-1-i];
}
main( )
{  int x[N][N]={ {1, 2, 3, 4},
{5, 6, 7, 8},
{9,10,11,12},
{13,14,15,16}}, i;
fun(x);
for (i=0;i<N; i++) printf(“%d,”, x[i][i]);
printf(” “);
}
程序运行后的输出结果是答案:D
A)4,7,10,13,
B)5,13,21,29,
C)1,6,11,16,
D)17,6,11,16,
题目解析:fun函数的作用是:通过for循环将a[0][0]的值加上a[3][3]的结果赋值于a[0][0],将a[0][1]的值加上a[3][2]的结果赋值于a[0][1]……fun函数执行完成后,数组a第1行的值变为17,17,17,17,其他行的值没有变化。而主函数中的for循环的作用是输出最终数组对角线上的值,即17,6,11,16,故本题答案选D)。


23. 有以下程序

#include <stdio.h>
void fun(int a[ ], int n)
{  int i=0;
for (i=0; i<n; i++)
{
if (i % 2 == 0)
a[i] += n;
else
a[i] -= n;
}
}
main( )
{  int c[5] = {5,4,3,2,1}, i;
fun(c, 5);
for (i=0;i<5; i++) printf(“%d,”, c[i]);
printf(” “);
}
程序运行后的输出结果是答案:D
A)5,4,3,2,1,
B)5,-1,3,-3,1,
C)10,2,8,4,6,
D)10,-1,8,-3,6,
题目解析:fun函数的作用是:通过for循环对主函数中传递过来的数组元素进行遍历,同时将下标为偶数的元素值加上n并赋值给自己,下标为奇数的元素值减去n并赋值给自己。fun函数执行完成后,数组中的元素值变为10,-1,8,-3,6,故本题答案选D)。


24. 有以下程序

#include <stdio.h>
main( )
{  int i,j = 0;
char a[] = “How are you”, b[10] = {0};
for (i=0; a[i]; i++)
if (a[i] == ‘ ‘)
b[j++] = a[i+1];
printf(“%s “,b);
}
程序运行后的输出结果是答案:D
A)Hay
B)we
C)Howareyou
D)ay
题目解析:该程序的含义是将空格以后的第一个字符输出,输出格式为字母直接相连,中间没有空格。即ay。


25. 有以下程序

#include <stdio.h>
char *a = “you”;
char *b = “Welcome you to Beijing!”;
main( )
{  char  *p;
p = b;
while (*p != *a) p++;
printf(“%s “, p);
}
程序运行后的输出结果是答案:C
A)Beijing!
B)to Beijing!
C)you to Beijing!
D)Welcome you to Beijing!
题目解析:程序的功能是在字符串中查找空格,如果找到,就用空格后面的字符串覆盖原来的字符串。本程序中最后一次覆盖是最后一个空格后面的串“ Beijing! ”覆盖原来的串存储在b中。


26. 有以下程序

#include  <stdio.h>
int a=2;
int f(int  k)
{  static int  n=0;
int   m=0;
n++;  a++;  m++;  k++;
return n+m+a+k;
}
main( )
{  int  k;
for (k=0; k<2; k++)   printf(“%d,”, f(k));
printf(” “);
}
程序运行后的输出结果是答案:D
A)6,10,
B)6,6,
C)6,7,
D)6,9,
题目解析:当k=1时,f(k)=6,k=2时,f(k)=9,k=3时,f(k)=12。题目中k<2,即输出为6,9。


27. 若有定义:

char s[30] = {0};
运行时输入:
This is a string.<回车>
则以下不能正确读入上述字符串到字符数组 s 中的选项是答案:B
A)for (i=0; (c=getchar()) != ‘ ‘; i++) s[i] = c;
B)scanf(“%s”, s);
C)i = 0;
while ((c=getchar())!=’ ‘) s[i++] = c;
D)gets(s);
题目解析: scanf(“%s”,s);读入时,遇到空白字符,包括空格,制表符,换行符时均会停止输入。


28. 有以下程序

#include <stdio.h>
main( )
{  char c;
c=getchar();
do {
putchar(c++);
} while((c=getchar()) != ‘#’);
}
程序运行时从第一列开始输入:abcdefg##<回车>,则输出结果是答案:C
A)abcdefg#
B)bcdefgh$
C)abcdefg
D)bcdefgh
题目解析:程序的逻辑是:用getchar()函数获取屏幕输入的字符赋值给c,并输出该字符,之后判定do-while循环条件,即如果当前输入的字符不为”#”则继续循环,也就是当输入一个‘#’字符时,循环结束,该字符会被输出。即输出结果为abcdefg。


29. 关于C语言函数说明的位置,以下叙述正确的是答案:B

A)函数说明可以出现在源程序的任意位置,在程序的所有位置对该函数的调用,编译时都不会出现错误信息
B)在函数说明之后对该函数进行调用,编译时不会出现错误信息
C)函数说明只是为了美观和编译时检查参数类型是否一致,可以写也可以不写
D)函数说明只能出现在源程序的开头位置,否则编译时会出现错误信息
题目解析:函数说明不等同于注释,注释写在任意位置均可,函数说明只能写在函数之前,对函数功能进行说明定义。


30. 有以下程序

#include <stdio.h>
int k=5;
void f(int  *s)
{  s=&k;
*s=k;
}
main( )
{  int m=3;
f(&m);
printf(“%d,%d “, m, k);
}
程序运行后的输出结果是答案:A
A)3,5
B)3,3
C)5,3
D)5,5
题目解析:函数f的功能是将k的值传递给s;考查函数传参。C语言中,数据只能从实参单向传递给形参,指针作为函数参数时,形参仍然作为实参的副本被赋值。输入m=3,f交换以后m仍旧为3,输入k=5,输出k=5。


31. 有以下程序

#include <stdio.h>
#include <string.h>
char *a = “you”;
char *b = “Welcome you to Beijing!”;
main( )
{  char *p;
p = b;
while (*p != *a) p++;
p += strlen(a) + 1;
printf(“%s “, p);
}
程序运行后的输出结果是答案:B
A)Welcome you to Beijing!
B)to Beijing!
C)Beijing!
D)you to Beijing!
题目解析:while语句是将a在b中首次出现的位置找出来,即是&b[8],strlen(a)求得为字符串a的实际长度为3,计算得的p与&b[12]等价,即输出为to Beijing!


32. 有以下程序

#include <stdio.h>
int  a = 2;
int f(int k)
{  static int  n;
int m;
m = n = 0;
n++;  a++;  m++; k++;
return  n+m+a+k;
}
main( )
{  int k;
for (k=0; k<2; k++)  printf(“%d,”, f(k));
printf(” “);
}
程序运行后的输出结果是答案:B
A)6,9,
B)6,8,
C)6,6,
D)6,7,
题目解析:k=0时,f(0)=n+m+a+k=1+1+3+1=6,k=1时,f(1)=1+1+4+2=8。即输出结果为6,8。


33. 有以下程序

#include <stdio.h>
#define S(x) x*x/x
main( )
{  int k = 6, j = 3;
printf(“%d,%d “, S(k+j+2), S(j+k+2));
}
程序运行后的输出结果是答案:A
A)29,29
B)26,29
C)121,121
D)11,11
题目解析:S(k+j+2)=k+j+2*k+j+2/k+j+2=6+3+2*6+3+2/6+3+2=29+1/3,取整以后为29,S(j+k+2)=j+k+2*j+k+2/j+k+2=3+6+2*3+6+2/3+6+2=29+2/3,取整以后也为29.即输出结果为29,29。


34. 有以下程序

#include <stdio.h>
#include <string.h>
typedef struct stu {
char  name[10];
char  gender;
int  score;
} STU;
void f(char  *name, char  *gender, int  *score)
{  strcpy(name, “Qian”);
*gender = ‘f’;
*score = 350;
}
main( )
{  STU  a = {“Zhao”, ‘m’, 290}, b;
b = a;
f(b.name, &b.gender, &b.score);
printf(“%s,%c,%d,”, a.name, a.gender, a.score);
printf(“%s,%c,%d “, b.name, b.gender, b.score);
}
程序运行后的输出结果是答案:D
A)Zhao,m,290,Zhao,m,290
B)Zhao,m,290,Qian,m,290
C)Zhao,m,290,Qian,m,350
D)Zhao,m,290,Qian,f,350
题目解析:b = a,把a中的值赋值给b,a中的值没有改变,调用函数f以后又给b重新定义了值,即Qian,f,350,所以最终输出的时候,a、b的值分别为Zhao,m,290,Qian,f,350。


35. 有如下程序

#include   <stdio.h>
main( )
{
int  i, data;
scanf(“%d”, &data);
for (i=0; i<5; i++)
{
if (i < data) continue;
printf(“%d-“, i);
}
}
程序运行时,从键盘输入:3<回车>后,程序输出结果为答案:C
A)0-1-2-3-
B)1-2-3-
C)3-4-
D)0-1-2-
题目解析:i=3时,3<5,输出为3-,i=4时,4<5,输出为4-,i=5时,5<5不成立,跳出,即输出为3-4-


36. 有如下程序

#include   <stdio.h>
main( )
{
char  a = ‘0’, b = ‘a’;
int  i;
for (i=0; i<4; i++)
{
if (i % 3)    putchar(a + i);
else    putchar(b + i);
}
}
程序运行后的输出结果是答案:D
A)11ac
B)ab3d
C)10ab
D)a12d
题目解析: b = ‘a’;是将字母表示为b,从a开始; a = ‘0’是将数字表示为a,从0开始;for循环中i的值从0取到3,i=4就跳出了循环,i=0时,i%3成立,字母a挪动0位,即a;i=1时,i%3不成立,数字0挪动1位,即1;i=2时,i%3不成立,数字0挪动2位,即2;i=3时,i%3成立,字母a挪动3位,即d,所以输出为a12d。


37. 有如下程序

#include   <stdio.h>
int convert(int*  data)
{
return (*data) ++;
}
main( )
{
int  data = 56;
convert(&data);
printf(“%d,”, data);
data = convert(&data);
printf(“%d, “, data);
}
程序运行后的输出结果是答案:C
A)55,57,
B)57,58,
C)57,57,
D)56,57,
题目解析:convert函数是对data进行++运算,主函数中data=56,调用第一次后data为57,输出为57,第二个输出之前把调用convert函数形成的data又赋值给了data,所以输出也为57。


38. 有如下程序

#include   <stdio.h>
void change(int*  array, int  len)
{
for (; len>=0; len–)
array[len] -= 1;
}
main( )
{
int  i, array[5] = {2,2};
change(array, 4);
for (i=0; i<5; i++)
printf(“%d,”, array[i]);
printf(” “);
}
程序运行后的输出结果是答案:B
A)1,-1,1,-1,1,
B)1,1,-1,-1,-1,
C)1,1,1,1,1,
D)1,0,-1,1,-1,
题目解析:array函数就是将前len个元素均减1,array[5]={2,2},前1,2个元素为2,2,其余元素为0,减1即为1,1,-1,-1,-1。


39. 对于函数声明
void fun(float array[], int *ptr);
以下叙述正确的是答案:A

A)函数参数 array, ptr 都是指针变量
B)函数声明有语法错误,参数 array 缺少数组大小定义
C)调用函数时,array数组的元素和ptr都是按值传送
D)调用函数时,array数组中将存储从实参中复制来的元素值
题目解析:当数组名作为实参时,对应的形参除了应该是指针之外,形参还可以用数组形式,但这种形式虽然说明的形式与数组的说明相同,但C编译程序都将把它处理成指针形式。调用fun函数时,通过相应的指针变量来引用实参数组元素的值。调用fun函数时,array和ptr都是指针,都是地址传送。


40. 有如下程序

#include   <stdio.h>
#include   <string.h>
main( )
{
printf(“%d “, strlen(“0 A011”));
}
程序运行后的输出结果是答案:D
A)10
B)9
C)7
D)8
题目解析:strlen所作的仅仅是一个计数器的工作,它从内存的某个位g置(可以是字符串开头,中间某个位置,甚至是某个不确定的内存区域)开始扫描,直到碰到第一个字符串结束符”为止,然后返回计数器值(长度不包含”)。


41. 有如下程序

#include <stdio.h>
void convert(char  ch)
{
if (ch < ‘X’) convert(ch+1);
printf(“%c”, ch);
}
main( )
{
convert(‘W’);
printf(” “);
}
程序运行后的输出结果是答案:B
A)XY
B)XW
C)YZ
D)VW
题目解析:convert函数是将字符和X作比较,如果输入字符小于X,则输出该字符,且字符向X移动一位;如果输入字符大,则结束判断,即当字符移至X时,立即输出,所以该程序是将输入字符与X之间的字符倒序输出。


42. 有如下程序

#include   <stdio.h>
#include   <string.h>
main( )
{
char  a[] = “1234”, *b = “ABC”;
printf(“%d,%d,%d,%d “, strlen(a), sizeof(a), strlen(b), sizeof(b));
}
程序运行后的输出结果是答案:D
A)4,3,2,1
B)4,5,3,3
C)4,5,1,3
D)4,5,3,4
题目解析:strlen(char*)函数求的是字符串的实际长度,直到遇到第一个”,然后就返回计数值,且不包括”。而sizeof()函数返回的是变量声明后所占的内存数,不是实际长度。


43. 有如下程序

#include   <stdio.h>
void get_put()
{
char  ch;
ch = getchar();
if (ch != ‘ ‘) get_put();
if (ch != ‘ ‘) putchar(ch);
}
main( )
{
get_put();
}
程序运行时,输入ABCD<回车>,则输出结果是答案:D
A)ABCD
B)BABA
C)DCDC
D)DCBA
题目解析:分析该程序段可知,其作用是将输入内容倒序输出。


44. 有如下程序

#include   <stdio.h>
struct pair
{
int  first, second;
};
struct pair  get_min_max(int* array, int len)
{
int  i;
struct pair  res;
res.first = array[0];
res.second = 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];
}
return  res;
}
main( )
{
int  array[6] = {19, 21, 3, 4};
struct pair  min_max = get_min_max(array, 6);
printf(“min=%d,max=%d “, min_max.first, min_max.second);
}
程序运行后的输出结果是答案:C
A)min=1,max=20
B)min=0,max=6
C)min=0,max=21
D)min=1,max=19
题目解析:函数get_min_max()的作用是计算数组array中前n个数据的最大值和最小值,将其记录在结构体变量res中并返回。数组array[6]不完全赋值,没有赋初值的默认值为0,所以计算得的最小值和最大值分别为0和21。


45. 有以下程序

#include   <stdio.h>
int sub(double  a, double  b)
{
return (int)(a – b – 1.3);
}
main( )
{
printf(“%d “, sub(3.2, 4.1));
}
程序运行后的输出结果是答案:C
A)2.0
B)-3
C)-2
D)1.7
题目解析:sub函数进行整数相减的运算,代入数据得3.2取整为3,4.1取整为4,3-4-1.3=-2.3,输出时取整为-2。


46. 有以下程序

#include   <stdio.h>
#include   <string.h>
main( )
{
char  name[9] = “c##line”;
char*  str = name;
printf(“%d,%d,%d,%d “, sizeof(name), strlen(name), sizeof(str), strlen(str));
}
程序运行后的输出结果是答案:A
A)9,7,4,7
B)8,6,9,6
C)10,8,5,8
D)8,6,3,6
题目解析:sizeof获得是所占的字节数,所分配的空间的字节数。strlen获得是长度(实际字符的个数)。


47. 有以下程序

#include   <stdio.h>
int disp(char*  str)
{
while (*str) putchar(*str++);
putchar(‘#’);
return *str;
}
main()
{
printf(“%d “, disp(“C##123”));
}
程序运行后的输出结果是答案:D
A)C##1230
B)C##0
C)C##123#
D)0
题目解析:函数disp()的功能是不断输出str指向的字符串中的字符,直到指针str指向该字符串的尾部′′,并返回当前字符的ASCII码值。main()函数中会输出该ASCII码值,字符′′的ASCII码值为0。


48. 有以下程序

#include   <stdio.h>
main( )
{
int  password;
char  *p, old_str[10] = “wind”;
scanf(“%d”, &password);
p = old_str;
while (*p)
{
printf(“#%c”, *p + password);
p++;
}
printf(” “);
}
程序运行时,从键盘输入2<回车>,输出结果是答案:D
A)#wi#nd#
B)xj#oe
C)#2222#
D)#y#k#p#f
题目解析:这段代码的作用是给一个字符串加密,加密的方式是将原先字符串的每个字符的ASCII码加上password,即相当于在ASCII码表上取距离当前字符为password的字符作为加密后的字符,输出的时候前面又加了一个#。


49. 有以下程序

#include   <stdio.h>
int sum(int*  array, int  len)
{
if (len == 1)
return array[1];
else
return array[1] + sum(array+1, len-1);
}
main( )
{
int  array[5] = {0,9,1,2}, res;
res = sum(array, 3);
printf(“%d “, res);
}
程序运行后的输出结果是答案:C
A)27
B)11
C)12
D)8
题目解析:函数sum()的作用是计算数组array中元素下标为len到1的所有元素的和。


50. 有以下程序

#include<stdio.h>
#include<math.h>
main()
{
int s; float n,t,pai;
t=1,pai=0,n=1.0,s=1;
while(fabs(t)>1.0e-6)
{
pai+=t;
n+=2; s=-s;t=s/n;
}
printf(“total=%f “,pai);
}
程序所计算的是答案:C
A)1+1/3+1/5+1/7+1/9-…
B)1+1/2+1/3+1/4+1/5-…
C)1-1/3+1/5-1/7+1/9-…
题目解析:分析程序段可知,每一次循环将pai的值对t进行累加求和并将结果赋于pai,其中t的值为“s/n”(每次s的值固定为1,但符号会发生变化,而n的值是在初值1的基础上每次加2,即为奇数),通过上述分析我们可知,本题答案选C)


51. 以下选项中,能够正确利用随机函数rand(),产生一个英文字母的表达式是答案:B

A)rand()%26+’A’|| rand()%26+’a’
B)rand()%2==0 ? rand()%26+’A’: rand()%26+’a’
C)rand()%2==0 ? rand()%’A’ : rand()%’a’
D)rand()%26+’A’ && rand()%26+’a’
题目解析:|| 表示 或 满足其中一个,整个表达式就为真;&&两个条件均为真时,表达式的值才为真;a?b:c;相当于if(a)b;else c;因为英文字母有大小写区分,首先判断是否为偶数,即rand()%2==0,如果是偶数,即该字母被判定是大写字母,取其和26的余数,和A的值相加取对应字母;如果是奇数,即该字母被判定是小写字母,取其和26的余数,和a的值相加取对应字母。


52. 以下选项中表示空函数的是答案:B

A)void fun();
B)void fun(){ }
C)int fun(int a,int b) { return 1;}
D)int fun() { return 0; }
题目解析:空函数不是执行过程没有的函数,而是执行过程为空的函数。


53. 以下程序拟调用getmax函数,找出四个变量中最大的一个,但程序不完整:

#include<stdio.h>
int getmax(int x,int y)
{  return x>y?x:y; }
void main()
{
int a,b,c,d,mx;
scanf(“%d%d%d%d”,&a,&b,&c,&d);
printf(“max=%d “,___________________________);
}
以下选项若填入下划线处,不能实现上述功能的是答案:B
A)getmax( getmax(getmax(a,b),c ),d)
B)mx=( getmax(a,b),getmax(c,d) )
C)getmax(a, getmax(b,getmax(c,d) ))
D)getmax ( getmax(a,b),getmax(c,d) )
题目解析:x>y?x:y;相当于if x>y;x;else y;即getmax函数是取出x和y中的最大值。该程序是将四个变量中的最大值输出,需要把最大值赋值给mx。


54. 有以下程序

#include<stdio.h>
int f1(int a)
{  return a*3;}
int f2(int *b)
{  return *b*5;}
main()
{
int x=3,y=5;
printf(“%d ,%d “,f1(x),f2(&y));
}
程序的运行结果是答案:C
A)9,125
B)3,15
C)9 ,25
D)3,45
题目解析:分析程序段可知,求出的是输入两数的平方值。


55. 有以下程序

#include<stdio.h>
int *fun()
{
static int a[2]={0,1};
a[0]+=a[1];
a[1]+=a[0];
return a;
}
void main()
{
int i,*b;
for(i=1;i<5;i++)
{
b=fun();
printf(“%d  %d  “,b[0],b[1]);
}
printf(” “);
}
程序的运行结果是答案:A
A)1  2  3  5  8  13  21  34
B)0  1  0  1  0  1  0  1
C)1  2  1  2  1  2  1  2
D)1  2  3  4  5  6  7  8
题目解析:fun函数是对两数之和的递归函数,初始值为0和1。


56. 有以下程序

#include<stdio.h>
#include<string.h>
char *p[10];
int n=0;
int fun(char *q)
{
int len=strlen(q);
n=0;p[n]=q;
if(len>1) p[++n]=q+1;
if(len>3) p[++n]=q+3;
if(len>5) p[++n]=q+5;
return n;
}
void main()
{
char s[100];
gets(s);
n=fun(s);
for(–n;n>=0;n–)
printf(“%s “,p[n]);
}
程序运行时输入:HELLO WORLD!<回车>,则输出结果是答案:C
A)     ELLO WORLD!
LO WORLD!
WORLD!
B)     WORLD!
LLO WORLD!
HELLO WORLD!
C)     LO WORLD!
ELLO WORLD!
HELLO WORLD!
D)     HELLO WORLD!
ELLO WORLD!
LO WORLD!
题目解析:分析本题程序段可知:主函数传给fun函数的q是指针,用于指向字符串的开始位置,然后数组p填入了3项(q+1、q+3和q+5),分别指向了字符串的不同位置,函数返回了3,然后通过主函数中的for循环(循环初始变量是2,–n),因此,依次输出了数组p的下标为2、1、0的对应的值。故本题答案为C)。


57. 有以下程序

#include<stdio.h>
#include<string.h>
void fun(char *s)
{
int len;
len=strlen(s);
if(len>2) fun(s+2);
putchar(*s);
}
void main()
{
char *p=”abcdefg”;
fun(p);
putchar(‘ ‘);
}
程序的运行结果是答案:D
A)gfedcba
B)aceg
C)abcdefg
D)geca
题目解析:分析该程序段可知,当*s取值为abcdefg时,strlen(s)=7,即len=7;len=7时len大于2成立,执行fun(s+2),即字母向右移动两位,储存第一个字母,此时s=cdefg,len=5,依次类推。依次递减,即数组中存储的字母依次为aceg,由于第一个存储的最后一个输出,所以输出为geca。


58. 有以下程序

#include<stdio.h>
typedef struct book
{
char name[50];
double price;
} BOOK;
void fun(BOOK*pd,int num,int size);
void main()
{
BOOK data[10]={“photoshop”,26.8,”计算机原理”,15.00,”数据结构”,35.6};
int n=3,m=10;
fun(data,n,m);
printf(“%s , %s “,data[8].name,data[9].name);
}
void fun(BOOK*pd,int num,int size)
{
int i,j,t;
double mx,mn;
mx=mn=pd[0].price;
j=t=0;
for(i=1;i<num;i++)
{
if(pd[i].price>mx)
{  mx=pd[i].price;j=i;  }
if(pd[i].price<mn)
{  mn=pd[i].price;t=i;  }
}
pd[size-2]=pd[j];
pd[size-1]=pd[t];
}
程序的运行结果是答案:B
A)计算机原理 , 数据结构
B)数据结构 , 计算机原理
C)Photoshop , 计算机原理
D)数据结构 , Photoshop
题目解析:分析该程序可知,输出的是书价格的最大值和最小值对应的书名,即数据结构,计算机原理。


59. 以下叙述中错误的是答案:C

A)不同函数中的形式参数可以同名
B)返回基本数据类型的库函数的调用,均可以出现在赋值号右边的表达式中
C)凡是带有返回值的库函数,都不能通过加分号而作为独立的语句出现
D)在同一源程序文件中,函数名必须唯一
题目解析: 库函数调用有两种方式,一是作为表达式的一部分参与运算,即其返回值参与运算;二是作为独立的语句,例如输出函数printf。


60. 若有如下函数定义

double fun(int x,int y)
{  return (x+y); }
return语句中表达式值的类型与说明的类型不一致,则以下叙述中正确的是答案:C
A)运行时出错
B)编译出错
C)函数返回的值为double型
D)函数返回的值为int型
题目解析: 因为fun函数在输入时被定义为了double型,所以运算以后也是double型,即输出为double型。


61. 有以下程序

#include <stdio.h>
int fun(int *a,int *b,int n)
{  int i=0,j=0,sum=0;
for( ; i<n; i++)
{   sum += a[i];
if ((i+1)%2 == 0)
{  b[j++]=sum;
sum=0;
}
}
return j;
}
main()
{   int a[8]={1,0,2,3,5,4,2,1},b[8],k,i;
k=fun(a,b,8);
for(i=0;i<k;i++)
printf(“%d “,b[i]);
}
程序的运行结果是答案:A
A)1 5 9 3
B)1 3 5 1
C)0 2 4 2
D)2 8 6
题目解析: sum += a[i]和sum=sum+a[i]等价;根据fun函数的程序分析可知,k=fun(a,b,8)=4,即需要输出的是b[1]、b[2]、b[3]、b[4]。代入程序中计算得出,分别为1,5,9,3。


62. 有以下程序

#include <stdio.h>
#include <string.h>
main()
{    char  s[5][8]={“red”,”yellow”,”green”,”blue”,”white”};
int i,j;  char t[8];
for(i=0; i<4; i++)
for(j=i+1;j<5; j++)
if(strlen(s[i])<strlen(s[j]))
{  strcpy(t,s[i]); strcpy(s[i],s[j]); strcpy(s[j],t); }
printf(“%s “,s[0]);
}
程序的运行结果是答案:A
A)yellow
B)white
C)red
D)green
题目解析: 如果strlen(s[i])<strlen(s[j])成立,那么将s[i]赋值给t,将s[j]赋值给s[i],将t赋值给s[j],输出的是s[0]的值;i=0时,j=1,s[0]=”red”,s[1]=”yellow”,满足题设条件,进行相互赋值,赋值以后s[0]=yellow。


63.  关于函数返回值,以下说法错误的是答案:A

A)函数返回值可以是整个数组
B)函数返回值可以是一个函数的入口地址
C)函数返回值可以是一个数
D)函数返回值可以是一个指针
题目解析:函数不能返回整个数组。


64.  有下列程序

#include  <stdio.h>
#define  N  4
int  fun(int a[][N])
{  int i, y=0;
for(i=0; i<N; i++)
y += a[0][i] + a[N-1][i];
for(i=1; i<N-1; i++)
y += a[i][0] + a[i][N-1];
return y;
}
main( )
{  int y, x[N][N] = {{1, 2, 3, 4},
{2, 1, 4, 3},
{3, 4, 1, 2},
{4, 3, 2, 1}};
y = fun(x);
printf(“%d”, y);
}
程序执行后的输出结果是答案:A
A)30
B)35
C)40
D)32
题目解析:fun函数中需要注意的是第一个for循环是i从0取值,取到3,计算得出y的值,这个循环结束以后,第二个for循环是将i从1取值,取到2,累加得出y的值。弄清楚这一点,就很好计算了。


65.  有下列程序

#include <stdio.h>
#include <string.h>
main( )
{  char v[4][10], *p[4], *t;
int i,j;
for (i=0; i<4; i++)
{  p[i] = v[i];
scanf(“%s”, p[i]);
}
for (i=0; i<3; i++)
for (j=i+1; j<4; j++)
if (strcmp(p[i], p[j]) > 0)
{  t = p[i]; p[i] = p[j]; p[j] = t; }
for (i=0; i<4; i++)
printf(“%s “, p[i]);
}
程序执行时若输入: Welcome you to Beijing<回车>,则输出结果是答案:C
A)Welcome you to Beijing
B)to you Beijing Welcome
C)Beijing Welcome to you
D)Beijing to Welcome you
题目解析: strcmp比较两个字符串,设这两个字符串为str1,str2,若str1==str2,则返回零;若str1<str2,则返回负数;若str1>str2,则返回正数。计算规则是从左至右依次比较字符串1和字符串2对应位置的字符的ASCII码,分析程序可知,是将ASCII码值按大小进行排序,最小的是B,其次是W,再次是t,最大的是y。</str2,则返回负数;若str1>


66.  有下列程序

#include  <stdio.h>
#include  <string.h>
main( )
{  char a[5][10]={“China”, “beijing”, “very”, “welcome”,  “you”};
char *p[5];
int i, len;
for(i=0;i<5;i++)
{  p[i]=*(a+i);
len = strlen(p[i]);
printf(“%s”, p[i] + len – 1);
printf(“%c”, *(p[i] + len – 1));
}
}
程序执行后的输出结果是答案:A
A)aaggyyeeuu
B)uueeyyggaa
C)yywwvvbbCC
D)CCbbvvwwyy
题目解析:len = strlen(p[i]),i从0取值取到4,分别对应的len值为5,7,4,7,3。输出中两种输出方式效果等同,即出现重复字符,p[i] + len – 1等价于p[i] + strlen(p[i])-1,等价于输出最后一个字符,即agyeu。


67.  有下列程序

#include <stdio.h>
int a = 1;
int func(int a)
{ int b = 1;
static int c = 1;
a++; b++; ++c;
return a + b + c;
}
main( )
{  int k, a = 4;
for (k=0; k<3; k++)
printf(“%d,”, func(a));
}
程序执行后的输出结果是答案:D
A)9,9,9,
B)6,7,8,
C)6,8,10,
D)9,10,11,
题目解析: k=0时,进行递归运算,返回值为a+b+c=5+2+2=9;k=1时,进行递归运算,返回值为a+b+c=6+2+2=10;k=2时,进行递归运算,返回值为a+b+c=7+2+2=11。输出为9,10,11。


68.  有如下程序

#include <stdio.h>
int change(int* data)
{
return ++(*data);
}
main()
{
int data = 0;
change(&data);
printf(“%d,”, data);
data = change(&data);
printf(“%d,”, data);
}
程序运行后的输出结果是答案:B
A)0,0,
B)1,2,
C)1,1,
D)0,1,
题目解析: change函数是对data加1,输入的data=0,运行一次change,得到data=1,输出1,再次运行change函数后,data=2,即输出2,所以输出为1,2。


69.  对于函数声明

void fun(float array[], int *ptr);
以下叙述中正确的是答案:B
A)调用函数时,array按值传送地址,ptr是按地址传送数值
B)函数参数 array, ptr 都是指针变量
C)函数参数 array 是数组名,不是指针变量,ptr 是指针变量
D)调用函数时,调用处的实参数组的所有值都会自动复制到array数组中
题目解析:调用函数时,ptr按值传送地址,array是按地址传送数值;array, ptr 都是指针变量;实参数值不一定会全部进入array数组中。


70.  有如下程序

#include <stdio.h>
void convert(char ch)
{
printf(“%c”, ch);
if (ch < ‘5’) convert(ch+1);
}
main()
{
convert(‘0’);
}
程序运行后的输出结果是答案:A
A)012345
B)5
C)123456
D)01234
题目解析:convert函数是对字符ASCII码值小于5的值进行对应输出。从0到5,即0,1,2,3,4,5。


71.  有如下程序

#include <stdio.h>
#include <string.h>
main()
{
char a[6] = “0123”, *b = “++”;
printf(“%d,%d”, strlen(a), sizeof(b));
}
程序运行后的输出结果是答案:C
A)5,4
B)4,2
C)4,4
D)6,2
题目解析:a中共4个字符,所以strlen(a)=4;指针变量用sizeof取值时,32位计算机中必定为4。


本章结束。。。。
 

32 Views
分享你的喜爱
默认图片
linwute

我要像梦一样自由,像大地一样宽容;
在艰辛放逐的路上,点亮生命的光芒;
我要像梦一样自由,像天空一样坚强;
在曲折蜿蜒的路上,体验生命的意义;

留下评论