复习题五答案及详细分析

1.以下能正确定义一维数组的选项是

A int num[];

B #define N 100

C int num[0......100];

D int N=100;

int num[N];int num[N]

B 此题考察一维数组的定义，一维数组的说明中，下标必须为正的整型常量，

不能为变量，在一维数组的初始化中，指出在单纯的定义时不能省略数组的长度。

2.有以下程序：

main()

{ int p[8]={11,12,13,14,15,16,17,18},i=0,j=0;

while(i++<7) if (p[i]%2) j+=p[i];

printf("%d\n",j);

}

程序运行后的输出结果是

A 42

B 45

C 56

D 60

B 首先i=0时，判断i++〈7 成立，进入循环体，但此时i=1,p[1]=12不满足if 语句，不执行j+=p[i]。按照此方法，得到j=p[2]+p[4]+p[6]=45,即B正确。

3.有以下程序：

main()

{ int p[7]={11,13,14,15,16,17,18},i=0,k=0;

while(i<7&&p[i]%2){ k=k+p[i];i++;}

printf("%d\n",k);

}

程序运行后的输出结果是

A 58

B 56

C 45

D 24

D 首先i=0<7&&p[0]%2!=0，满足循环条件，执行k=k+p[0],即k=11, 然后执行i++,再进行判断，满足循环条件，k=11+p[1],所以k=24,执行i++,i=2,，再进行判断，此时不满足循环条件，循环结束，输出k值，为24。

4.有以下程序：

main()

{ int x[]={ 1,3,5,7,2,4,6,0},i,j,k;

for(i=0;i<3;i++)

for(j=2;j>=i;j--)

if(x[j+1]>x[j]) {k=x[j];x[j]=x[j+1];x[j+1]=k;}/*从小到大排序*/ for(i=0;i<3;i++)

for(j=4;j<7-i;j++)

if(x[j+1]

printf("\n");

}

程序运行后的输出结果是

A 75310246

B 01234567

C 76310462

D 13570246

A 此题主要考察循环嵌套，第一个循环体执行完是将x[0]，x[1]，x[2]，x[3]，

进行从大到小排序，第二个循环体执行完是将x[4]，x[5]，x[6]，x[7]进行从小到大排序。

5.以下能正确定义二维数组的是

A int a[ ][3];

B int a[ ][3]={2*3};

C int a[ ][3]={};

D int a[2][3]={{1},{2},{3,4}};

B 此题考察二维数组的定义，在第八章第二节中（76页），指出单纯定义时，行和列都不能缺省。在初始化过程中，列不能缺省，赋值的行数和列数不能超过数组的行数和列数

6.以下不能正确定义二维数组的选项是

A int a[2][2]={{1},{2}};

B int a[][2]={1,2,3,4};

C int a[2][2]={{1},2,3};

D int a[2][ ]={{1,2},{3,4}};

D 同上题分析一样。

7.以下能正确定义数组并正确赋初值的语句是

A int N=5,b[N][N];

B int a[1][2]={{1},{3}};

C int c[2][ ]={{1,2},{3,4}};

D int d[3][2]={{1,2},{3,4}};

D 同上题分析一样。

8.有以下程序：

main()

{ int m[][3]={1,4,7,2,5,8,3,6,9};

int i,j,k=2;

for(i=0;i<3;i++)

{ printf("%d",m[k][i]);}

}

执行后输出结果是

A 4 5 6

B 2 5 8

C 3 6 9

D 7 8 9

C 此题分别输出m[2][0],m[2][1],m[2][2]。

9.有以下程序：

main()

{ int a[][3]={{1,2,3},{4,5,0}},i;

for (i=0;i<3;i++)

if(i<2) a[1][i]=a[1][i]-1;

else a[1][i]=1;

printf("%d\n",a[0][1]+a[1][1]+a[1][2]);

}

执行后输出结果是

A 7

B 6

C 8

D 无确定值

A 此题考察在for循环后，i=0,i=1时，执行if语句，使得a[1][0],a[1][1] 的

值分别减1，而当i=2时，执行else语句，a[1][2]=1。因此输出a[0][1]+a[1][1]

+a[1][2]=2+4+1=7；

10.有以下程序：

main()

{ int aa[4][4]={{1,2,3,4},{5,6,7,8},{3,9,10,2},{4,2,9,6}};

int i,s=0;

for(i=0;i<4;i++) s+=aa[i][1];

printf("%d",s);

}

程序运行后的输出结果是

A 11

B 19

C 13

D 20

B 此题考察for循环，计算aa[0][1],aa[1][1],aa[2][2],aa[3][1]的和，即为19。

11.以下程序的输出结果是

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][i]];

printf("%d\n",t);

}

A 3

B 4

C 1

D 9

B 此题是嵌套循环，外层循环一次，内层计算到结束。本题内层循环为j=i,，j<=i

故每次内存循环只需要计算一次。也当i=0时，此时由于j<=i，因此只计算j=0，b[j][j]=b[0][0]=0，t=1+b[0][0]=1，依次类推，可以得到t=1+b[0][0]+b[1][1]+b[2][2]=4。

12.有以下程序：

main()

{ int num[4][4]={{1,2,3,4},{5,6,7,8},{9,10,11,12},{13,14,15,16}},i,j;

for(i=0;i<4;i++)

{ for(j=1;j<=i;j++) printf("%c",' ');

for(j= ; j<4;j++) printf("%4d",num[i][j]);

printf("\n");

}

}

若按以下形式输出数组右上半三角

1 2 3 4

6 7 8

11 12

16

则在程序下划线处应填入的是

A i-1

B i

C i+1

D 4-i

B 嵌套循环，外层循环控制行，内层循环控制列，在此题中，i=0时，第一行需要输出4个数，因此只有j=0,j<4才能输出4个数，故很简单地可以知道只有B满足。

13 以下程序的输出结果是

main()

{ int i,j,row,col,min;

int a[3][3]={{100,200,400},{30,80,-15},{-50,6,7}};

min=0;

for( i=0;i<3;i++)

for(j=0;j<3;j++)

if(min>a[i][j])

{ min=a[i][j];

row=i;

col=j;

}

printf("%d,%d,%d",min,row,col);

}

A -50,2,0

B 400,0,2

C 0,0,0

D -50,3,1

A 此题是求出整个二维数组的最小值，并输出最小值所在的行和列。因此，很容易得到答案。

14.以下程序运行后的输出结果是24

main()

{ int p[7]={11,13,14,15,16,17,18};

int i=0;j=0;

while(i<7&&p[i]%2==1) j+=p[i++];

printf("%d\n",j);

}

此题分析过程同选择题3。

15.以下程序运行后的输出结果是1111

main()

{ int i,n[]={0,0,0,0,0};

for(i=1;i<=4;i++)

{ n[i]=n[i-1]*2;

printf("%d",n[i]+1);

}

}

16.以下程序运行后的输出结果是30

main()

{ int a[3][3]={{1,2,9},{3,4,8},{5,6,7}},i,s=0;

for(i=0;i<3;i++) s+=a[i][i]+a[i][3-i-1];

printf("%d\n");

}

计算s=a[0][0]+a[0][2] +a[1][1] +a[1][1] +a[2][2] +a[2][0]=30

17.以下程序运行后的输出结果是 1 2 3

main() 0 5 6

{ int i,j,a[][3]={1,2,3,4,5,6,7,8,9}; 0 0 9 for(i=0;i<3;i++)

for(j=i+1;j<3;j++) a[j][i]=0;

for(i=0;i<3;i++)

{ for(j=0;j<3;j++) printf("%d ",a[i][j]);

printf("\n");

}

}

18.以下程序运行后的输出结果是92

main()

{ int a[4][4]={{1,2,3,4},{5,6,7,8},{11,12,13,14},{15,16,17,18}};

int i=0,j=0,s=0;

while(i++<4)

{ if(i==2||i==4) continue;

j=0;

do{ s+=a[i][j];j++; }while(j<4);

}

printf("%d\n",s);

}

i=0时，首先判断i++<4成立，执行循环体，此时i=1,在do-while内层循环中，得到s=a[1][0]+a[1][1]+a[1][2]+a[1][3]=26；然后再进行条件判断i++<4,进入循环体，此时i=2，执行continue，再一次进行条件判断，进入循环体，此时i=3，因此计算s=a[3][0]+a[3][1]+a[3][2]+a[3][3]得到s=92。

19.以下程序运行后的输出结果是58

main()

{ int a[4][4]={{1,2,-3,-4},{0,-12,-13,-14},{-21,23,0,-24},{-31,32,-33,0}};

int i,j,s=0;

for(i=0;i<4;i++)

{ for(j=0;j<4;j++)

{ if(a[i][j]<0) continue;

if(a[i][j]==0) break;

s+=a[i][j];

}

}

printf("%d\n",s);

}

i=0时，s=a[0][0]+a[0][1]=3；

i=1时，由于a[1][0]= =0。因此跳出内层循环；

i=2时，得到s=s+a[2][1]=3+23=26；

i=3时，得到s=s+a[3][1]=26+32=58。

1.若有定义：int aa[8];则以下表达式中不能代表数组元素aa[1]的地址是

A &aa[0]+1;

B &aa[1]

C &aa[0]++

D aa+1

C. &和++的优先级是一样的，但是它们的结合方式是从右至左的，先执行aa[0]++，得到的结果是aa[0]的值加1，然后&（aa[0]++）&取的是前面所得结果的地址，不是aa[1]的地址，并且获得的地址是不确定的。

A、+的优先级比&的优先级高D、aa数组名代表数组的首地址

2.若有定义：int a[]={1,2,3,4,5,6,7,8,9},*p=a,i;其中i为0~8之间的数，则对a数组元素引用不正确的是

A a[p-a]

B *(&a[i])

C p[i]

D *(*(a+i))

D. *（a+i）已经实现了对数组元素a[i]的引用

指针P指向数组的首地址，p-a=0,A答案实现了对数组元素a[0]的引用，B答案*（&a[i]）中*代表取值，&代表取址，整个表达式相当于a[i]

3.有以下程序：

main()

{ int a[10]={1,2,3,4,5,6,7,8,9,10},*p=a;

printf("%d\n",*(p+2));

}

程序运行后的输出结果是

A 3

B 4

C 1

D 2

A．指针P指向数组的首地址，p+2即p[2]的地址，*（p+2）即取p[2]的值，由于数组元素下标是从零开始的，故p[2]=3

4.有以下程序：

main()

{ int a[10]={1,2,3,4,5,6,7,8,9,10},*p=&a[3],*q=p+2;

printf("%d\n",*p+*q);

}

程序运行后的输出结果是

A 16

B 10

C 8

D 6

B.指针p指向数组元素a[3]的地址，即p指向元素4的地址,q指向的地址即为p 指向的地址下移四个字节，指向的为a[5]的地址，故答案为a[3]+a[5]=4+6=10 5.有以下程序：

main()

{ int a[]={2,4,6,8,10},y=0,x,*p;

p=&a[1];

for(x=1;x<3;x++) y+=p[x];

printf("%d\n",y);

}

程序运行后的输出结果是

A 10

B 11

C 14

D 15

C．第二条语句表示p指向数组元素a[1]的地址，即p[0]=4,第三条for循环语句实现的是y=p[1]+p[2]=6+8=14。

6.有以下程序：

main()

{ int a[]={1,2,3,4,5,6,7,8,9,0},*p;

for(p=a;p

printf("%d",*p);

}

程序运行后的输出结果是

A 1,2,3,4,5,6,7,8,9,0,

B 2,3,4,5,6,7,8,9,10,1,

C 0,1,2,3,4,5,6,7,8,9,

D 1,1,1,1,1,1,1,1,1,1,

A．p指向数组首地址，for循环实现的是从p指向首地址开始取元素输出，依次指针p下移，指向数组元素a[1],输出a[1]，指向数组元素a[2]输出a[2]，直至a[9]。

7.设有定义语句：int x[6]={2,4,6,8,5,7},*p=x,i;要求依次输出x数组6个元素中的值，不能完成此操作的语句是

A for(i=0;i<6;i++) printf("%2d",*(p++));

B for(i=0;i<6;i++) printf("%2d",*(p+i));

C for(i=0;i<6;i++) printf("%2d",*p++);

D for(i=0;i<6;i++) printf("%2d",(*p)++); （D）

解析：这四个选项，不同的地方是printf的输出数据列表，对于A，C选项，*和++的优先级相同，而结合方式是自右向左，故表达式*p++跟*（p++）是等价的，是对的。对于D选项，（*p）++等价于x[0]++,而不再是p指针自加，所以输出的结果是 2 3 4 5 6 7，故D是错误的。

8.有以下程序：

main()

{ int a[]={1,2,3,4,5,6,7,8,9,10,11,12,},*p=a+5,*q=NULL;

*q=*(p+5);

printf("%d%d\n",*p,*q);

}

程序运行后的输出结果是

A 运行后出错

B 6 6

C 6 11

D 5 10

（A）

解析：int *q=NULL,表示q指针没有指向任何变量，它里面存放的内容是NULL值，所以不能将*(p+5)的值赋给q所指向的变量，因为q指针没有指向任何变量，所以答案是报错。

9.已有定义：int i,a[10],*p;则合法的赋值语句是

A p=100;

B p=a[5];

C p=a[2]+2;

D p=a+2;

（D）

解析：（A）不能给指针用整型常数来赋值。（B）a[5]是数组的元素，不是数组元素的地址，所以不能赋值给指针p。（C）错误的地方与B选项相同。（D）是正确的，a是数组的首地址，a+2表示数组元素a[2]存放的地址，可以将它赋值给指针p。

10.有以下程序段：

int a[10]={1,2,3,4,5,6,7,8,9,10},*p=&a[3],b;

b=p[5];

b中的值是

A 5

B 6

C 8

D 9

（D）

解析：int *p=&a[3]表示指针p指向数组元素a[3]，可以使用p[0]来表示p指针指向的内存单元，所以p[0]可以表示a[3]。则p[5]可以表示a[8]，故b的值为9.

11.有以下程序：

main()

{ int x[8]={8,7,6,5,0,0},*s;

s=x+3;

printf("%d\n",s[2]);

}

执行后的输出结果是

A 随机值

B 0

C 5

D 6

（B）

解析：s=x+3表示指针s指向数组元素x[3]。可以用s[0]来表示x[3]，则s[2]表示x[5]，故输出结果是0.

12.有以下程序：

main()

{ int i,s=0,t[]={1,2,3,4,5,6,7,8,9};

for(i=0;i<9;i+=2) s+=*(t+i);

printf("%d\n",s);

}

程序执行后的输出结果是

A 45

B 20

C 25

D 36

（C）

解析：*（t+i）等价于t[i]，故s+=*(t+i)等价于s=s+t[i] ，在FOR循环语句中，每次执行i=i+2，s=s+t[i]，实现的功能是将i为偶数的数组元素t[i]相加的结果给s，s计算出的值为25，答案是C。

13.有以下程序：

main()

{ int a[3][3],*p,i;

p=&a[0][0];

for(i=0;i<9;i++) p[i]=i+1;

printf("%d\n",a[1][2]);

}

程序执行后的输出结果是

A 3

B 6

C 9

D 2

（B）

解析：二维数组在内存中是连续顺序存放的，故p[0]=0+1等价于a[0][0]=1,p[1]=1+1等价于a[0][1]=2,依次类推，故for循环语句执行后，二维数组a[3][3]={1，2，3，4，5，6，7，8，9}，所以a[1][2]的值为6.

14.有以下程序：

main()

{ int a[3][3],*p,i;

p=&a[0][0];

for(i=0;i<9;i++)

p[i]=i;

for(i=0;i<3;i++)

printf("%d",a[1][i]);

}

程序运行后的输出结果是

A 0 1 2

B 1 2 3

C 2 3 4

D 3 4 5

（D）

解析：第一个for循环语句执行后，二维数组a[3][3]={0,1,2,3,4,5,6,7,8}。第二个for语句的功能是输出数组元素a[1][0],a[1][1],a[1][2]的值，结果是3 4 5，故选D。

15.有以下程序：

main()

{ int a[3][2]={0},(*ptr)[2],i,j;

for(i=0;i<2;i++)

{ ptr=a+i;

scanf("%d",*ptr);

ptr++;

}

for(i=0;i<3;i++)

{ for(j=0;j<2;j++)

printf("%2d",a[i][j]);

printf("\n");

}

}

若运行时输入1 2 3<回车>，则输出结果为

A 产生错误信息

B 1 0

C 1 2

D 1 0

2 0

3 0 2 0

0 00 0 3 0

解析：int (*ptr)[2]表示定义了一个指针变量p，p只能存放含有两个整型元素的一维数组的首地址。在第一个for语句中，ptr=a+i，当i=0时，ptr=a，则a[0][0]被赋值为1，当i=1时，ptr=a+1,此时指针ptr将移动两个整型大小，故a[1][0]被赋值为2。此时当i=时不满足循环条件，退出循环，故键盘上输入的第三个数3，没有被计算机接受。所以二维数组a[3][2]={1,0,10,0,0},答案为B.

16.若有定义：int *p[3];则以下叙述中正确的是

A 定义了一个基类型为int的指针变量p,该变量具有三个指针。

B 定义了一个指针数组p，该数组含有三个元素，每个元素都是基类型为int的指针。

C 定义了一个名为*p的整形数组，该数组含有三个int类型元素。

D 定义了一个可指向一维数组的指针变量p，所指一维数组应具有三个int类型元素。（B）

解析：int *p[3]表示定义了一个指针数组p,数组中包含三个指向整型数据的指针，故答案是B

17.若有以下说明和语句：int c[4][5],(*p)[5];p=c;能正确引用c数组元素的是

A p+1

B *(p+3)

C *(p+1)+3

D *(p[0]+2)

（D）

解析：（A）p是一个指针，所以p+1是指针移动，所以还是指针。

（B）（C）p是数组指针，可以看做是指针的指针。所以*P是指针，**P才是值。所以*(p+3)，*(p+1)+3都是指针。故答案选D，*（P[0]+2）等价于C[0][2]。18.若有以下定义和语句：int a[4][3],(*p)[3]=a,*q=a[0];则能够正确表示数组元素a[1][2]的表达式是

A *((*p+1)[2])

B *(*(q+5))

C (*p+1)+2

D *(*(a+1)+2)

（D）

解析：*(a+1)和a[1]是等价的，故*(a+1)代表了a[1][0]的地址，*(*(a+1)+2)就表示数组元素a[1][2],答案为D。

19.有以下定义和语句:

int a[3][2]={1,2,3,4,5,6,},*p[3];

p[0]=a[1];

则*(p[0]+1)所代表的数组元素是

A a[0][1]

B a[1][0]

C a[1][1]

D a[1][2]

（C）

解析：由于p[0]=a[1];*(p(0)+1)等价于*（a[1]+1），*（a[1]+1）又等价于a[1][1]，故答案为C。

20.若有以下定义和语句：

int s[4][5],(*ps)[5];

ps=s;

则对s数组元素的正确引用形式是

A ps+1

B *(ps+3)

C ps[0][2]

D *(ps+1)+3

（C）

解析：同17题。

21.有以下程序：

main()

{ int a[][3]={{1,2,3},{4,5,0}},(*pa)[3],i;

pa=a;

for(i=0;i<3;i++)

if(i<2) pa[1][i]=pa[1][i]-1;

else pa[1][i]=1;

printf("%d\n",a[0][1]+a[1][1]+a[1][2]);

}

执行后输出结果是

A 7

B 6

C 8

D 无确定值

（A）

解析：由于pa=a,所以pa[1][i]等价于a[1][i],在第一个for循环中，当i=0时，执行pa[1][0]=pa[1][0]-1，a[1][0]=3.当i=1时，执行pa[1][1]=pa[1][1]-1，a[1][1]=4。当i=2时，执行pa[1][2]=1,a[1][2]=1.第一个for循环结束后，二维数组a[2][3]={{1,2,3},{3,4,1}},最后输出的结果是7。

22.以下程序的输出结果是： 6

main()

{ int a[]={2,4,6}，*p=&a[0],x=8,y,z;

for(y=0;y<3;y++)

z=(*(p+y)

printf("%d\n",z);

}

第一个语句：声明一个有三个元素的数组a，让指针p指向数组a的第一个元素，初始化x,声明了两个整型变量y, z。for循环的执行语句是一个条件表达式，即如果?前面括号内的表达式如果成立，则z的值是：前面表达式的值，若不成立，则是后面x的值。第一次循环和第二次循环的结果并没有输出，因为输出语句不属于for循环体语句，输出语句输出的只是最后一次循环的出的结果，即当y=2时，*(p+y)=6

23.以下程序的输出结果是：19

main()

{ int a[]={2,4,6,8,10},y=1,x,*p;

p=&a[1];

for(x=0;x<3;x++)

y+=*(p+x);

printf("%d\n",y);

}

第一个语句是声明了一个有5个元素的数组a，初始化整型变量y为1，并定义了整型变量x和指针p，第二个语句是让指针p指向数组的第二个元素，即p[0]=a[1]=4,第三个for循环语句是实现y=1+p[0]+p[1]+p[2]=1+a[1]+a[2]+a[3]=1+4+6+8=19,最后输出语句输出y的值。24.以下程序的输出结果是： 6

main()

{ int a[]={2,4,6,8},*p=a,i;

for(i=0;i<4;i++)

a[i]=*p++;

printf("%d\n",a[2]);

}

第一个语句声明了一个有4个元素的数组a,定义指针p指向数组a的首地址，并定义了一个循环变量i.第二个循环语句实现的是将p所指向的元素赋给a[o], p下移一个位置，再将p指向的元素赋给a[1],依次循环直至将数组a[]里面的元素依

次赋给数组a[i]，最后输出语句输出a[2],a[2]=6,所以最后的输出结果为6。

25.以下程序中若第一个printf语句输出的是5732，则第二个printf语句的输出结果是：5756 main()

{ int a[]={ 1,2,3,4,5,6,7,8,9,0},*p;

p=a;

printf("%x\n",p);

printf("%x\n",p+9);

}

第一个语句声明一个有10个元素的数组a,和一个指针p,第二个语句让p指向数组首地址。

第一个输出语句输出p指向的地址值，是以十六进制表示出来的5732,p+9表示p 后移了9个元素的位置，由于一个整型数据占用4个字节，则p移动了18个字节，表示成十六进制就是24，则最后一个输出语句的结果为5732+24=5756。26.以下程序的输出结果是：2<换行>4

main()

{ int a[5]={2,4,6,8,10},*p,**k;

p=a;

k=&p;

printf("%d\n",*(p++));

printf("%d\n",**k);

}

第一个语句定义了一个5个元素的数组a，和一个指针p，一个指向指针元素的指针k，第二个语句让p指向数组的首地址，第三个语句将指针p的地址赋给指针k，则第一个输出语句输出p指向的a[0]的值2并换行,p再自加，第二个输出语句中*k代表的即是p,因为k指向的是p的地址，**k即为*p，而此时的*p指向的是a[1]即为4。故此行输出结果为4。