全国计算机二级C语言 # 选择题:数组(1-35)
1. 若有说明语句: int *ptr[10]; 以下叙述正确的是答案：B
A）ptr是一个指向具有10个整型元素的一维数组的指针
B）ptr是一个具有10个指针元素的一维数组
C）ptr是指向整型变量的指针
D）ptr是一个指向10个整型变量的函数指针
题目解析:考查指针数组的定义。说明语句”int *ptr[10];”定义了一个具有10个元素的一维数组，每个元素都只能存放指针，这些指针的基类型必须为字符型。故本题答案选B）。
2. 若有定义语句:int a[10]={0,1,2,3,4,5,6,7,8,9},*p=a;,以下选项中错误引用a数组元素的是(其中 0≤i<10)答案：C
A）*( &a[i] )
B）p[i]
C）*(*(a+i))
D）a[ p-a ]
题目解析:数组名表示该数组的首地址，*(a+i)表示的是数组a中第二个元素的值，取值运算符*只能对地址取值，不能作用于变量上，选项A）错误；a表示数组a的第一个元素的地址，*p=a则将p指向了数组a的第一个元素的地址，p-a=0，所以a[p-a]即为a[0]，p[i]相当于a[i]，取地址运算符&和取值运算符*互为逆运算。
3. 有以下程序
#include <stdio.h>
main()
{
int a[10] = { 1,3,5,7,11,13,17 }, *p=a;
printf(“%d,”, *( p++ ));
printf(“%d “, *( ++p ));
}
程序运行后的输出结果是答案：A
A）1,5
B）1,3
C）3,5
D）3,7
题目解析:在该程序中，a是int类型的一维数组，p为基本类型为int的指针变量，指向数组a的第一个元素。输出*(p++)时，自加运算符后置即先输出p指向的值后p再向后移动一位，所以第一次输出的结果为1，p指向数组a中的第二个元素。输出*(++p)时，自加运算符前置即先将p向后移动一位后再输出p指向的值，所以第二次输出的结果为5。
4. 以下程序中给数组所有元素输入数据，请从选项中选择正确的答案填入下划线处
#include <stdio.h>
main()
{
int a[10], i=0;
while( i<10 ) scanf(“%d”, _________ );
for (i=0; i<10; i++)
printf(“%d “, a[i]);
}答案：A
A）&a[i+1]
C）&a(i++)
题目解析:选项A）、C）会造成死循环，选项D）的写法有误。数组名是一个地址常量，a+i表示数组a中第i个元素的地址，选项B）的使用正确。
5. 以下选项中叙述正确的是答案：B
A）若有数组定义 float array[4]; 则语句 printf(“%f”, array[3.12]);是合法的
B）char c1, c2, *c3, c4[40]; 是合法的变量定义语句
C）数组说明符的一对方括号中只能使用整型常量，而不能使用表达式
D）数组下标的下限可以是负值
题目解析:数组说明符的方括号中可以用整型常量或者整型表达式；数组的下限只能为0，不能为负值；引用数组元素的时候只能用整型数据而不能用浮点数据。
6. 若有函数声明
void fun(float array[], int *ptr);
以下叙述正确的是答案：A
A）函数参数 array, ptr 都是指针变量
B）调用函数时，array是按值传送，ptr是按地址传送
C）函数参数 array 不是指针变量，ptr 是指针变量
D）调用函数时，实参数组的值将一一复制给array数组
题目解析:数组名表示该数组的首地址，是一个地址常量，作为函数参数时传递的是数组的首地址，属于地址传参。
7. 有如下程序
#include <stdio.h>
main()
{
int i, k;
int array[4][2] = {{1,2}, {4,9}, {6}};
for (i=0; i<2; i++)
for (k=0; k<4; k++)
{
printf(“%d,”, array[k][i]);
}
printf(” “);
}
程序运行后的输出结果是答案：B
A）2,9,6,1,4,
B）1,4,6,0,2,9,0,0,
C）1,2,4,9,6,
D）2,9,0,0,1,4,6,0,
题目解析:定义语句”int array[4][2] = {{1,2}, {4,9}, {6}};”的作用是使array[0][0]=1，array[0][1]=2，array[1][0]=4，array[1][1]=9，array[2][0]=6，其余元素均为0。
8. 有如下程序
#include <stdio.h>
main()
{
int i, *ptr;
int array[3] = {8,2,4};
for (ptr=array, i=0; i<2; i++)
printf(“%d,”, *ptr++);
printf(” “);
}
程序运行后的输出结果是答案：B
A）4,8,
B）8,2,
C）2,4,
D）8,8,
题目解析:考查指针与一维数组。语句”ptr=array”将指针ptr指向了数组array的首地址，所以*ptr与a[0]等价。输出语句中”*ptr++”自加运算符后置，所以先输出ptr指向的变量的值，再让ptr自加1，即指向数组array中下一个元素的地址，该程序输出数组前两个元素的值。
9. 有如下程序
#include <stdio.h>
main()
{
int i, *ptr;
int array[5] = {5,3,1};
for (ptr=array, i=0; i<5; i++, ptr++)
{
if (*ptr == 0)
putchar(‘X’);
else
putchar(‘A’ + *ptr);
}
printf(” “);
}
程序运行后的输出结果是答案：A
A）FDBXX
B）FFFXX
C）FDBBB
D）ABCDE
题目解析:定义语句”int array[5] = {5,3,1};”使得数组前三个元素的值分别为5、3、1，其余元素为0，所以输出的结果分别为′A′ + 5、′A′ +3、′A′ + 1对应的字符以及两个′X′。
10. 有如下程序
#include <stdio.h>
main()
{
int i, array[5] = {3, 5, 10, 4};
for (i=0; i<5; i++)
printf(“%d,”, array[i] & 3);
printf(” “);
}
///
程序///运行后的输出结果是答·案：A
A）3,1,2,0,0,
B）3,2,2,2,0,
C）3,3,3,3,0,
D）3,5,10,4,0,
题目解析:按位与，即：相应的位值同为1时结果为1，否则结果为0；array[0]=3,3&3=3，依次类推得出结果。
11. 有以下程序
#include <stdio.h>
void fun(int *x,int s,int e)
{ int i,j,t;
for(i=s,j=e; i<j; i++,j–)
{ t=*(x+i); *(x+i)=*(x+j); *(x+j)=t;}
}
main()
{ int m[]={0,1,2,3,4,5,6,7,8,9},k;
fun(m,0,3); fun(m+4,0,5); fun(m,0,9);
for(k=0; k<10;k++)
printf(“%d”,m[k]);
}
程序的运行结果是答案：C
A）0987651234
B）3210987654
C）4567890123
D）9876543210
题目解析:函数fun()的功能是将数组x中下标为s和e之间的元素逆序，所以调用函数fun(m,0,3)后，m={3,2,1,0,4,5,6,7,8,9}；调用函数fun(m+4,0,5)后，m={3,2,1,0,9,8,7,6,5,4}；调用函数fun(m,0,9)后，m={4,5,6,7,8,9,0,1,2,3}。
12. 设有n个数按从大到小的顺序存放在数组x中，以下能使这n个数在x数组中的顺序变为从小到大的是答案：D
A）for(i=0;i<n;i++)
{ t=x[i];
x[i]=x[n-i-1];
x[n-i-1]=t;
}
B）for(i=0;i<n/2;i++)
{ t=x[i];
x[i]=x[n-i+1];
x[n-i+1]=t;
}
C）for(i=0;i<n/2;i+=2)
{ t=x[i];
x[i]=x[n-i-1];
x[n-i-1]=t;
}
D）for(i=0;i<n/2;i++)
{ t=x[i];
x[i]=x[n-i-1];
x[n-i-1]=t;
}
题目解析: 要将这n个数逆序排列，需将前半部分和后面部分对应的元素（如x[i]与x[n-1-i]）对调，选项A）执行结束后，数组没有变化，选项B）数组越界，选项C）只将下标为偶数的元素逆序排列，只有选项D）实现了该算法。
13. 设有一个M*N的矩阵已经存放在一个M行N列的数组x中，且有以下程序段
sum=0;
for(i=0;i<M;i++) sum+=x[i][0]+x[i][N-1];
for(j=1;j<N-1;j++) sum+=x[0][j]+x[M-1][j];
以上程序段计算的是答案：B
A）矩阵两条对角线元素之和
B）矩阵周边所有元素之和
C）矩阵非周边所有元素之和
D）矩阵所有元素之和
题目解析:查二维数组的引用，元素x[i][0]、x[i][N-1]分别表示二维数组中的第一列和最后一列的元素，元素x[0][j]、x[M-1][j]分别表示二维数组第一行和最后一行的元素。
14. 有以下程序
#include <stdio.h>
main()
{ char a[4][4]={‘ ‘};
int i,j;
for(i=0;i<4; i++)
{ a[i][0]=a[i][3]=’#’;
for(j=1; j<3; j++)
{ a[0][j]=a[3][j]=’#’;
if((i!=0)&&(i!=3)) a[i][j]=’o’;
}
}
for(i=1;i<3; i++)
{ for(j=0; j<4;j++)
printf(“%2c”,a[i][j]);
printf(” “);
}
}
程序的运行结果是答案：C
A）# # # #
# o o #
B）# o o #
# # # #
C）# o o #
# o o #
D）# # # #
# # # #
题目解析:两重循环的作用是将二维数组a[4][4]的第一列和最后一列的字符设为’#’（见语句”a[i][0]=a[i][3]= ′# ′;”），同时将第一行和最后一行的其他元素设为′# ′（见语句”a[i][0]=a[i][3]= ′# ′;”），其余元素设为′o′（见语句”if((i!=0)&&(i!=3)) a[i][j]= ′o′;”），输出的为第二三行的元素。
15. 若有定义语句：int m[ ][3]={1,2,3,4,5,6,7};，则与该语句等价的是答案：C
A）int m[ ][3]={{1,2},{3, 4 },{5, 6,7}};
B）int m[ ][3]={{1},{2,3,4},{5,6,7}};
C）int m[ ][3]={{1,2,3},{4,5,6},{7}};
D）int m[ ][3]={{1,2,3},{4,5},{6,7}};
题目解析:考查二维数组的初始化。初始化二维数组的时候若给数组的全部元素均赋初值，此时第一维的元素个数可以不指定，部分赋值时，最后一行元素不写完整，此时数组第一维元素个数仍然可以不指定。题中为按行给数组m赋值，最后一行只有部分赋初值
16. 有以下程序
#include <stdio.h>
main()
{ char s[10]=”verygood”, *ps=s;
ps+=4;
ps=”nice”;
puts(s);
}
程序的运行结果是答案：C
A）nice
B）verynice
C）verygood
D）nicegood
题目解析:数组名s为一个指针常量，始终指向该数组的首地址，语句”ps=”nice”;”将字符指针ps指向了另一个字符串的首地址，并不能对字符数组s中的数据造成影响，所以输出结果为”verygood”。
17. 有以下程序
#include <stdio.h>
main( )
{ char b[3][10],c;
int i;
for (i=0; i<2; i++) scanf(“%s”, b[i]);
i=0;
while ((c=getchar())!=’ ‘) b[2][i++] = c;
b[2][i] = ”
18. 有以下程序
#include <stdio.h>
main( )
{ char w[20], a[5][10] = {“abcdef”, “ghijkl”, “mnopq”, “rstuv”, “wxyz”};
int i,j;
for (i=0; i<5; i++)
{ j=0;
while (a[i][j]!=’
19. 有以下程序
#include <stdio.h>
void f(int x[], int n)
{ if (n > 1)
{ printf(“%d,”, x[n-1]);
f(x, n-1);
printf(“%d,”, x[n-1]);
}
else
printf(“%d,”, x[0]);
}
main( )
{ int z[3] = {1, 2, 3};
f(z,3);
printf(” “);
}
程序运行后的输出结果是答案：D
A）3,1,3,
B）1,2,3,1,2,3,
C）1,2,3,2,1,
D）3,2,1,2,3,
题目解析:分析程序段可知，f函数是将数组x进行输出，依次输出为z(2)，z(1)，z(0)，z(1)，z(2)，即3,2,1,2,3，。
20. 有以下程序
#include <stdio.h>
#include <string.h>
typedef struct stu {
char name[10];
char gender;
int score;
} STU;
void f(STU *c)
{ strcpy(c->name, “Qian”);
c->gender = ‘f’;
c->score = 350;
}
main( )
{ STU a = {“Zhao”, ‘m’, 290}, b;
b = a;
f(&b);
printf(“%s,%c,%d,”, a.name, a.gender, a.score);
printf(“%s,%c,%d “, b.name, b.gender, b.score);
}
程序运行后的输出结果是答案：C
A）Zhao,m,290,Zhao,m,290
B）Zhao,m,290,Qian,m,350
C）Zhao,m,290,Qian,f,350
D）Zhao,m,290,Qian,m,290
题目解析:b = a;将a中的值赋值给b；函数f的功能是定义了一个数组c，那么就会将这个数组赋予给a、b中的空值，也即最后输出的是两个数组的值，一个是c的值，一个是a的值。
21. 有以下程序
#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(” “);
}
程序运行后的输出结果是答案：B
A）17,17,17,17,
B）16,6,11,16,
C）1,6,11,16,
D）4,7,10,13,
题目解析:fun函数的作用是：通过for循环将a[3][3]的值赋于a[0][0]，将a[3][2]的值赋于a[0][1]……fun函数执行完成后，数组a第1行的值变为16，15，14，13，其他行的值没有变化。而主函数中的for循环的作用是输出最终数组对角线上的值，即16，6，11，16，故本题答案选B）。
22. 有以下程序
#include <stdio.h>
main( )
{ char b[4][10], c;
int i,j;
for (i=0; i<4; i++)
{ j = 0;
while ((c=getchar())!=’ ‘ && c!=’ ‘) b[i][j++] = c;
b[i][j] = ‘
23. 有以下程序
#include <stdio.h>
void f(int x[], int n)
{ if ( n > 1)
{ printf(“%d,”, x[0]);
f(&x[1], n-1);
printf(“%d,”, x[0]);
}
else
printf(“%d,”, x[0]);
}
main( )
{ int z[3] = {4, 5, 6};
f(z, 3);
printf(” “);
}
程序运行后的输出结果是答案：B
A）6,5,4,6,5,4,
B）4,5,6,5,4,
C）6,5,4,5,6,
D）4,5,6,4,5,6,
题目解析:分析程序可知，第一次：传值{4,5,6}，先执行第一个printf，然后运行第二遍，再执行第二个printf，输出 4 (第二次) 4；第二次：传值{5,6}，先执行第一个printf，然后运行第三遍，再执行第二个printf，输出 4 5 (第三次) 5 4；第三次，传值{6}，因为if语句条件不符合，直接执行第三个，输出 4 5 6 5 4。
24. 有以下程序
#include <stdio.h>
main( )
{
char name[10] = {‘S’, ‘T’, ‘R’};
name[2] = ‘#’; name[6] = 0;
printf(“%s “, name);
}
程序运行后的输出结果是答案：B
A）STR#0
B）ST#
C）STR#
D）STR0
题目解析:%s格式符表示输出的是字符串。由于name中定义元素个数为10，但是只有前3个元素进行了指定，而后的赋值语句中，替换了name[2]和name[6]，输出为ST#。
25. 有以下程序
#include <stdio.h>
main()
{ int a[3][3]={0,1,2,3,4,5,6,7,8},(*p)[3],i;
p=a;
for(i=0;i<3;i++)
{ printf(“%d “,(*p)[i]); p++; }
}
程序的运行结果是答案：D
A）1 4 7
B）0 3 6
C）0 1 2
D）0 4 8
题目解析: 分析可知，a数组为一3*3的矩阵，输出的(*p)[i])为其对角线上的数值，即0,4,8。
26. 有以下程序
#include <stdio.h>
main()
{ char b[ ]=”abcdefg”,*chp=b;
while(*chp)
{ if((chp-b)%3==0)
putchar(*chp);
++chp;
}
}
程序的运行结果是答案：C
A）defg
B）aceg
C）adg
D）cf
题目解析: 程序求出的是数组下标能整除3的对应的元素，即b[0]、b[3]、b[6]，分别为adg。
27. 有下列程序
#include <stdio.h>
void fun(int a[ ], int n, int flag)
{ int i=0,j, t;
for (i=0; i<n-1; i++)
for (j=i+1; j<n; j++)
if (flag ? (a[i] < a[j]) : (a[i] > a[j]))
{ t = a[i]; a[i] = a[j]; a[j] = t;}
}
main( )
{ int c[10]={7,9,10,8,3,5,1,6,2,4},i;
fun(c, 10, 1);
fun(c, 5, 0);
for (i=0;i<10; i++)
printf(“%d,”, c[i]);
}
程序执行后的输出结果是答案：B
A）10,9,8,7,6,1,2,3,4,5,
B）6,7,8,9,10,5,4,3,2,1,
C）6,7,8,9,10,1,2,3,4,5,
D）5,4,3,2,1,6,7,8,9,10,
题目解析: if语句中根据flag是否为0进行判断，如果为0，进行a[i] < a[j]，如果为非0，进行a[i] > a[j]，下一语句是赋值。在fun(c, 10, 1)中，flag=1为非0，即进行的是a[i] > a[j]，由于j=i+1，即a[i]和a[j]表示数组a中相邻的两个值，即将大值放在左边，小值放在右边，数组c变为10,9,8,7,6,5,4,3,2,1。在fun(c, 5, 0)中，flag=0，类推得出，是将小值放在左边，大值放在右边，数组从变为6,7,8,9,10,5,4,3，2,1。
28. 有下列程序
#include <stdio.h>
main( )
{ int i,j=0;
char a[]=”ab123c4d56ef7gh89″;
for (i=0; a[i]; i++)
if (!(a[i] >= ‘0’ && a[i] <= ‘9’))
a[j++] = a[i];
a[j] = ‘
29. 有下列程序
#include <stdio.h>
main( )
{ char v[4][10]; int i;
for (i=0; i<4; i++)
scanf(“%s”, v[i]);
printf(“%c,%s,%s,%c”, **v, *(v+1), v[3]+3, *(v[2]+1));
}
程序执行时若输入: welcome you to beijing<回车>，则输出结果是答案：A
A）w,you,jing,o
B）welcome,you,jing,to
C）w,xelcome,eeijing,u
D）w,you,eeijing,u
题目解析: %c,%s分别是输出字符，输出字符串；**v输出v的首字母, *(v+1)v中第二个字符串, v[3]+3从beijing中的第4个字符再输出, *(v[2]+1)第3个字符串中的第二个字符。
30. 有下列程序
#include <stdio.h>
void f(int x[], int n)
{ if (n>1)
{ printf(“%d”, x[n-1]);
f(x, n-1);
printf(“%d”, x[n-1]);
}
else
printf(“%d”, x[n-1]);
}
main( )
{ int a[4] = {1,2,3,4};
f(a, 4);
}
程序执行后的输出结果是答案：D
A）43211234
B）12344321
C）1234321
D）4321234
题目解析:由于满足if的判断条件，即先输出的是x[n-1]，接着运行的是f(x,n-1) ，也即输出的是4321，直到输出完毕以后跳出if再次输出x[n-1]，即234。
31. 有如下程序
#include <stdio.h>
void change(int* array, int len)
{
for (; len>=0; len–)
array[len]++;
}
main()
{
int i, array[4] = {0,1};
change(array, 3);
for (i=0; i<4; i++)
printf(“%d,”, array[i]);
}
程序运行后的输出结果是答案：A
A）1,2,1,1,
B）3,4,5,6,
C）1,2,0,0,
D）0,1,2,3,
题目解析: len=3，i=0时，满足for语句中len大于等于0的条件，即执行array[0]++，即输出为1，i=1时，满足for语句中len大于等于0的条件，即执行array[1]++，依次类推得出结果。
32. 下面说法正确的是答案：D
A）方括号数组说明符中不能使用带有运算符的表达式
B）对于数组元素是浮点值的数组float array[3]，array[1.5]是合法的
C）数组下标的下限在定义数组时设置，可以设定为负数
D）char c1 = ‘A’, c2, *c3; 是合法的变量定义语句
题目解析:数组的说明符可以用表达式进行计算，由于限制了浮点值，那么必须与限制的浮点一样，数组下标最小为0，不能为负数。
33. 设有如下程序段
int a[2] = {0};
int b[] = {0};
char c[2] = “ABC”;
char d = “ABC”;
则以下叙述正确的是答案：B
A）只有c的定义是合法的
B）只有a, b的定义是合法的
C）只有c,d的定义是合法的
D）a,b,c,d的定义都是合法的
题目解析:char c[2] = “ABC”中数组长度为2，但是出现了3个字符；char d = “ABC”改为char d[] = “ABC”;
34. 有如下程序
#include <stdio.h>
struct person
{
char Name[10];
int Age;
};
main()
{
struct person room[4] = {{“Zun”, 11}, {“Liu”, 10}, {“He”, 12}, {“Zhao”, 13}};
printf(“%s:%d”, (room+3)->Name, (room+1)->Age);
}
程序运行后的输出结果是答案：B
A）Zun:12
B）Zhao:10
C）He:11
D）Liu:10
题目解析:room初始值为0，即输出的是room[3]的Name和room[1]的Age，即Zhao:10。
35. 有如下程序
#include <stdio.h>
struct pair
{
int a, b;
};
struct pair get_min_max(int* array, int len)
{
int i;
struct pair res;
res.a = array[0];
res.b = array[0];
for (i=1; i<len; i++)
{
if (res.a > array[i])
res.a = array[i];
if (res.b < array[i])
res.b = array[i];
}
return res;
}
main()
{
int array[5] = {6, 4, 1, 7};
struct pair mm = get_min_max(array, 5);
printf(“min=%d,max=%d”, mm.a, mm.b);
}
程序运行后的输出结果是答案：B
A）min=1,max=4
B）min=0,max=7
C）min=6,max=4
D）min=1,max=7
题目解析:因为array[5]数组中长度为5，但是只定义了4个数据，即隐含一个数据为0，输出的是最大值和最小值，即最小值为0，最大值为7。
本章结束。。。。
