全国计算机二级C语言 # 选择题:函数(1-71)
A）4
B）5
C）1
D）2
题目解析:函数调用的参数之间用逗号分隔，表达式”exp1, exp2″和”exp1, exp2, exp3″为逗号表达式，各为一个参数，总共参数个数为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。
本章结束。。。。
