练习题8及参考答案

1. 单项选择题

（1）有以下定义和赋值语句中，正确的是。

A. static char str[8]="Good morning";

B. char str[20];str="Good morning";

C. char *p="Good morning";

D. char *p;*p="Good morning";

【答】选项在定义字符指针变量的同时初始化为指向字符串常量的第一个字符。本题答案为C。

（2）已知变量a已定义为int型变量，以下定义并初始化指针变量p的语句中正确的是。

A. int *p=a;

B. int *p=*a;

C. int p=&a;

D. int *p=&a;

【答】D

（3）以下叙述正确的是。

A. 数组名实际上是此数组的首地址，所以数组名相当于一个指针变量

B. 若定义数组 a[2][3]，则a+1和*(a+1)完全相等

C. 若定义数组 a[2][3]，则++a和a[1]完全等价

D. 某函数的形参为一个数组，则调用此函数时只能将数组名作为对应的实参

【答】选项A是错误的，数组名的确是数组的首地址，但它的值是一个常量，不可改变；选项B是正确的，在二维数组中，若a为数组名，则a+i和*(a+i)同样表示此数组第i行的首地址，所以完全相等，参见《C程序设计教程》的表8.1；选项C是错误的，数组名是数组的首地址，是一个常量，不能执行++运算；选项D是错误的，某函数的形参为一个数组，调用此函数时可将数组名作为对应的实参，也可以将相应的指针变量作为对应的实参。本题答案为B。

（4）有这样的定义float *p[4]；则下面的叙述中正确的是。

A. 此定义不正确，形如char *p[4]；的定义才是正确的

B. 此定义正确，p是指向一维实型数组的指针变量，而不是指向单个实型变量的指针变量

C. 此定义不正确，C语言中不允许类似的定义

D. 此定义正确，定义了一个指针数组

【答】其中正确答案为D。该语句中，“[]”的优先级最高，所以p是一个数组，其次是float *，进一步表示p数组中每个元素为指向float型数的指针。

（5）若有以下定义语句：

static int a[2][3]={1,3,5,7,9,11};

int m,n;

且0≤m≤1，0≤n≤2，则是对数组元素的正确引用。

A. a[m]+n

B. *(a+5)

C. *(*(a+m)+3)

D. *(*(a+m)+n)

【答】*(*(a+m)+n)等价于a[m][n]。本题答案为D。

（6）有如下函数：

fun(int *p1,int *p2)

{

int *p;

*p=*p1;

*p1=*p2;

*p2=*p;

}

其功能为。

A. 正确，但无法改变*p1和*p2的值

B. 能够成功交换*p1和*p2的值

C. 能够成功交换*p1和*p2的地址

D. 能够成功交换p1和p2的值

【答】该函数交换了*p1和*p2的值，若以fun(&a,&b);语句调用该函数，则交换了a和b的值。本题答案为B。

（7）下面各语句行中，能正确进行字符串赋值操作的是。

A. char st[4][5]={"ABCDE"};

B. char s[5]={'A','B','C','D','E'};

C. char *s;s="ABCDE";

D. char *s;scanf("%s",s);

【答】首先可以排除选项A，因其形式不对。也可以排除选项B，因为字符数组的长度不够，没有考虑字符串结束符。选项D也是错误的，其错误的原因是：在这两条语句中，只确定了指针变量p本身在内存中的地址，但p所指的值没有确定。所以，只有选项C是正确的，C语言中规定可以给字符指针单独赋值。本题答案为C。

（8）执行以下程序段后，m的值为。

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

int m,*ptr=&a[0][0];

m=(*ptr)*(*ptr+2)*(*ptr+4);

A. 15

B. 48

C. 24

D. 无定值

【答】*ptr=1，*ptr+2=3，*ptr+4=5，m=1*3*5=15。本题答案为A。

（9）设有定义：

static a[4][3]={1,2,3,4,5,6,7,8,9,10,11,12};

int (*prt)[3]=a,*p=a[0];

则以下能够正确表示数组元素a[1][2]的表达式是。

A. *((*prt+1)[2])

B. (2)*(*(p+5))

C. (*prt+1)+2

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

【答】a是一个二维数组。int (*prt)[3]=a定义中，由于有括号，“*”优先级高，即prt是一个指针，后面有“[3]”，表示prt是一个包含三个元素的数组的指针。int *p=a[0]的初始化中，表示p是一个整数指针变量，指向a数组的第一行的第一个元素即a[0][0]。

用prt表示a[1][2]的各种方式如下：

*(prt[1]+2)

*(*(prt+1)+2)

(*(prt+1))[2]

prt[1][2]

再看以上各种表达式：

选项A、C显然是错误的；选项B中，p+5指向a[0][5]，执行两次“*”肯定是错误的；选项D是正确的，因为a是常量，是数组的首地址，*(a+1)指向第二行， *(*(a+1)+2)表示第二行的第三个元素，即a[1][2]。本题答案为D。

（10）若有定义char s[3][4]；以下对数组元素s[i][j]的各种引用形式中正确的是。

A.*(s+i)[j]

B.*(&s[0][0]+4*i+j)

C.*((s+i)+j)

D.*(*(s+i)[j])

【答】选项A是错误的，*(s+i)[j]表达式中，运算符[]的优先级最高，故此表达式相当于*(*(s+i+j))，显然这是此数组第i+ j行的第 0个元素的值，而不是s[i][j]；选项B是正确的，*(&s[0][0]+4*i+j)是直接使用偏移量法来引用数组元素，根据二维数组在内存中的行优先顺序存放规则，*(&s[0][0]+4*i+j)等价于s[i][j]；选项C是错误的，*((s+i)+j)等价于*(s+i+j)，是数组第i+j行首地址；选项D是错误的，*(*(s+i)[j])等价于

***(s+i+j)，是错误的表达方式。本题答案为B。

（11）有如下程序：

#include

main()

{

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

int (*p)[4]=a;

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

}

则下列说法中正确的是。

A. 输出结果为：0

B. 输出结果为：6

C. 输出结果为：0,6

D. 将输出数据元素的地址而不是数据元素的值

【答】程序中先给静态数组a的前两行元素赋了初值，第三行元素取默认值0。在语句int (*p)[4]=a;中，定义了一个二维数组指针，并将a的首地址赋给它。在表达式*(p+1)[1]中，[]的优先级最高，*(p+1)[1]等价于*(*(p+1+1))=*(*(p+2))，即为a数组第三行的第一个元素。所以输出为0。因此，只有A是正确的。（12）以下程序的运行结果是。

#include

main()

{

static int a[]={5,3,7,2,1,5,4,10};

int s=0,k;

for (k=0;k<8;k+=2)

s+=*(a+k);

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

}

A. 17

B. 27

C. 13

D. 无定值

【答】A

（13）以下程序的运行结果是。

#include

main()

{

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

int x,y,*p;

p=&a[0];

x=*(p+2);

y=*(p+4);

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

}

A. 1,3,5

B. 2,4,6

C. 1,1,1

D. 3,3,3

【答】A

（14）以下程序的运行结果是。

#include

main()

{

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

int *p=a;

printf("%d,",*p);

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

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

printf("%d,",*(p--));

p+=3;

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

}

A. 1,2,3,3,2,1

B. 1,2,3,3,5,4

C. 1,3,5,3,3,3

D. 1,3,5,5,3,1 【答】B

（15）以下程序的运行结果是。

#include

main()

{

char str[2][5]={"7045","9265"},*a[2];

int i,j,s=0;

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

a[i]=str[i];

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

for (j=0;a[i][j]>'0' && a[i][j]<='9';j+=2)

s=10*s+a[i][j]-'0';

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

}

A. 7496

B. 70936

C. 74936

D. 704936 【答】A

（16）以下程序的运行结果是。

#include

main()

{

static char c[]="china";

char *p=c;

while (*p)

printf("%c",*p++-32);

printf("\n");

}

A. china

B. CHINA

C. ch

D. 陷入死循环【答】B

（17）以下程序的运行结果是。

#include

main()

{

char *pp[2][3]={"abc","defgh","ijkl","mnopqr","stuvw","xyz"};

printf("%c",***(pp+1));

printf("%c",**pp[0]);

printf("%c",(*(*(pp+1)+1))[4]);

printf("%c",*(pp[1][2]+2));

printf(",%s\n",**(pp+1));

}

A. mawz,defgh

B. mawz,mnopqr

C. adim,defgh

D. adim,mnopqr

【答】B

（18）以下程序的运行结果是。

#include

int fun(int x,int y)

{

return(y-x);

}

main()

{

int a=5,b=6,c=2;

int (*g)(int,int);

g=fun;

c=(*g)(a,b);

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

}

A. 1

B. 2

C. 3

D. 以上都不对

【答】A

2. 填空题

（1）有以下定义：

char s[3]="AB";

char *p;

在执行了语句p=s;之后，*(p+2)的值是。

【答】字符数组s长度为2，但在内存中占有3个字节，第3个字节是字符串结束符'\0'，所以*(p+2)的值是'\0'。

（2）以下程序的运行结果是。

#include

main()

{

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

p=&a[2];

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

}

【答】p指向a[2]，对于表达式*--p，先计算--p，返回a[1]的指针，再计算*运行，返回a[1]。本题答案为：1。

（3）以下程序的运行结果是。

#include

main()

{

static char s[]={"abcdef"};

char *p=s;

*(p+2)+=3;

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

}

【答】执行语句char *p=s;后，指针p将指向数组s的起始地址；再执行*(p+2)+=3;，将数组元素s[2]的值增加 3，s[2]的值由'c'变为'f'，指针 p自身的值并未改变，依然指向数组s的始址，此时执行

printf("%c，%c\n"，*p，*(p+2))；将输出字符s[0]和s[2]，即'a'和'f'。本题答案为：a,f

（4）以下程序的运行结果是。

#include

main()

{

static int a[]={1,3,4,5,7,8};

int y,x,*ptr;

y=1;

ptr=&a[1];

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

y*=*(ptr+x);

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

}

【答】整型指针变量ptr指向整型数组a第2个元素存放的地址位置，即*ptr=3，执行循环y的值即为3*4*5=60。本题答案为：60。

（5）以下程序的运行结果是。

#include

main()

{

static char s[]="Program",*ptr;

for (ptr=s;ptr

putchar(*ptr);

putchar('\n');

}

【答】Porm

（6）以下程序的运行结果是。

#include

main()

{

char *p="abcdefghijklmnopq";

while (*p++!='e')

printf("%c",*p);

printf("\n");

}

【答】bcde

（7）以下程序的运行结果是。

#include

main()

{

int m[12],k;

int *p[3],sum=0;

for (k=0;k<12;k++)

{

m[k]=2*k;

if (k<3)

p[k]=m+2*k*k;

}

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

sum+=(*(p+k))[4-k];

printf("sum=%d\n",sum);

}

【答】数组p为一个指针数组，在使用第一个for循环进行赋值以后，p中各指针的指向分别是：p[0]指向m[0]，p[1]指向m[2]，p[2]指向m[8]。表达式(*(p+k))[4-k]等价于p[k][4-k]，当k=0时，即为m[4]，k=1时，即为m[5]，k=2时，即为 m[10]。本题答案为：sum=38。

（8）以下程序的运行结果是。

#include

main()

{

int **k,*j,i=100;

j=&i;

k=&j;

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

}

【答】本程序中，执行语句j=&i;k=&j;之后，j的值是i的地址，k的值是j的地址，经过两次取内容操作，**k的值就是变量i的值0。本题答案为：100。

（9）以下程序的运行结果是。

#include

void g(int **p);

main()

{

int line[100],i;

int *p=line;

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

{

*p=i;

g(&p);

}

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

printf("%d ",line[i]);

printf("\n");

}

void g(int **p)

{

(*(*p))++;

(*p)++;

}

【答】在本程序中添加相应的注释，用于说明程序设计思路。

main()

{

int line[100],i;

int *p=line; /*p是line数组的指针,此时p=line的首地址*/

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

{

*p=i; /*p所指向的值设为i,即line[0]=0,…*/

g(&p); /*p为line数组指针的指针,即line[i]指针的地址*/

}

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

printf("%d ",line[i]);

printf("\n");

}

void g(int **p) /*p为二级指针,调用时p为line[i]指针的地址*/

{

(*(*p))++; /*p所指的变量值增1,即将line[i]之值增1*/

(*p)++; /*p为line[i+1]指针的地址,对执行结果无影响*/

}

本程序的运行结果是：1 2 3 … 100。

（10）以下程序的运行结果是。

#include

main()

{

static int a[]={1,3,5,7};

int *p[3]={a+2,a+1,a};

int **q=p;

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

}

【答】指针数组p有3个元素，分别指向数组a的第3、2、1个元素。二级指针q指向指针数组p，则p[0]指向a[2]，p[0]+1指向a[3]，*(p[0]+1)=7；q指向p，q+2指向p[2]，*(p[2])指向a[0]，**(p[2])=1。本题答案为：8。

（11）以下程序的运行结果是。

#include

main()

{

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

p=a;

printf("%d,%d,%d,%d\n",*(p[2]+1),*(*(p+2)+1),(*(p+2))[1],

p[2][1]);

}

【答】*(p[2]+1),*(*(p+2)+1),(*(p+2))[1],p[2][1]都对应a[2][3]即6。本题答案为：6,6,6,6。

（12）以下程序的运行结果是。

#include

main()

{

int a[3][4]={1,3,5,7,9,11,13,15,17,19,21,23};

int (*p)[4]=a,i,j,k=0;

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

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

k+=*(*(p+i)+j);

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

}

【答】*(*(p+i)+j)等价于a[i][j]，k=1+3+9+11+17+19=60。本题答案为：60。

（13）以下程序的运行结果是。

#include

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

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

int **pp=p;

main()

{

pp++;