全国计算机二级C语言 # 选择题:指针(1-46)
1. 有以下程序
#include <stdio.h>
main()
{
int a[10] = { 11,12,13,14,15,16,17,18,19,20 },*p=a,i=9 ;
printf( “%d,%d,%d “,a[ p-a ], p[i],*( &a[i] ) );
}
程序运行后的输出结果是答案：A
A）11,20,20
B）12,20,20
C）12,19,20
D）11,19,19
题目解析:a表示数组a的第一个元素的地址，*p=a则将p指向了数组a的第一个元素的地址，p-a=0，所以a[p-a]即为a[0]，p[i]相当于a[i]即a[9]，输出第一个结果为11、第二个结果为20。取地址运算符&和取值运算符*互为逆运算，所以*( &a[i] ) )的值仍为a[i]即a[9]，输出第三个结果为20。
2. 有以下程序
#include <stdio.h>
void fun( int *s, int t, int *k )
{ int p;
for( p=0, *k=p; p<t; p++ )
if( s[p]>s[*k] ) *k = p;
}
main()
{
int a[10] = { 11,12,13,14,15,16,20,18,19,10 },k ;
fun( a,10,&k );
printf( “%d,%d “,k, a[k] );
}
程序运行后的输出结果是答案：B
A）10,10
B）6,20
C）10,9
D）7,20
题目解析:该代码段的逻辑是循环判定s中的值，如果大于s[*k]则用*k记录当前的元素下标，所以k为数组a中值最大的元素的下标。
3. 有以下说明语句
char *s = “”Name\Address “;
指针s所指字符串的长度是答案：B
A）说明语句不合法
B）14
C）15
D）17
题目解析:该字符串中有三个转义字符′ ” ′、′\ ′、′′，分别代表一个字符，并且字符串长度不包含结束标识符，所以该字符串的长度为14。
4. 有以下程序
#include <stdio.h>
main()
{
char *s[6] = { “ABCD”, “EFGH”,”IJKL”,”MNOP”,”QRST”,”UVWX” }, **p ;
int i;
p = s;
for( i = 0; i<4; i++ ) printf( “%s”, p[i] );
printf( ” ” );
}
程序运行后的输出结果是答案：C
A）ABCDEFGHIJKL
B）ABCD
C）ABCDEFGHIJKLMNOP
D）AEIM
题目解析:语句”p=s”，将p指向指针数组s的首地址，则p[i]与s[i]等价，均是指向第i+1个字符串的首地址，输出语句” printf(“%s”,p[i]);”会将该字符串整体输出。所以main()函数输出的为字符串数组s的前4个字符串。
5. 若有以下程序段
char str[4][12] = {“aaa”,”bbbb”,”ccccc”,”dddddd”},*strp[4];
int i;
for( i=0; i<4; i++) strp[i]=str[i];
则以下错误引用字符串的选项是（其中0≤k<4）答案：A
A）strp
B）str[k]
C）strp[k]
D）*strp
题目解析:指针strp为一个指针数组，str为一个二维数组名。语句”strp[i] = str[i];”将str数组中第i+1个字符串的首地址赋值给strp[i]，所以str[i]与strp[i]、*(strp+i)、*(str+i)等价，而strp为指针数组所占内存的首地址，不能引用字符串。
6. 若有以下定义和语句
struct st{ int n; struct st *next; };
struct st a[3] = { 5,&a[0], 6,&a[1], 7,&a[2] }, *p;
p=&a[0];
则值为6的表达式是(提示：运算符->的优先级高于++)答案：C
A）p++ ->n
B）(*p).n++
C）(++p)-> n
D）p ->n++
题目解析:语句”p=&a[0];”表示将指针p指向了结构体数组a的首地址，所以(++p)->n值为6，p++->n相当于p->n,p++，值为5，p->n++值为5，(*p).n++相当于p->n++，值为5。
7. 以下选项中，不能对主函数中变量i和j的值进行交换的程序是答案：C
A）#include <stdio.h>
void swap( int *p,int *q)
{ int t;
t=*p; *p=*q; *q=t;
}
main()
{
int i=10,j=20, *a=&i, *b=&j;
swap(a,b); printf(“i=%d j= %d “, i,j );
}
B）#include <stdio.h>
void swap( int *p,int *q)
{ int t;
t=*p; *p=*q; *q=t;
}
main()
{
int i=10,j=20 , *x=&i, *y=&j;
swap(x,y); printf(“i=%d j= %d “, i,j );
}
C）#include <stdio.h>
void swap( int *p,int *q)
{ int *t;
*t=*p; *p=*q; *q=*t;
}
main()
{
int i=10,j=20, *a=&i, *b=&j;
swap(a,b); printf(“i=%d j= %d “, i,j );
}
D）#include <stdio.h>
#include <stdlib.h>
void swap( int *p,int *q)
{ int *t;
t=(int *)malloc(sizeof(int));
*t=*p; *p=*q; *q=*t;
free(t);
}
main()
{
int i=10,j=20;
swap(&i,&j); printf(“i=%d j= %d “, i,j );
}
题目解析:选项C）中，虽然函数swap()进行的是地址传参，但只是改变了指针的指向，对原指向的数据并没有改变。并且若以指针作为操作单元，不涉及其指向的数据时，该函数仍然可以看做是值传递，即形参指针指向的变化不会影响到实参指针的指向，所以并不能将主函数中的变量i和j互换数值。
8. 有以下程序
#include <stdio.h>
main()
{
int *p, x=100;
p=&x; x=*p+10;
printf(“%d “, x);
}
程序运行后的输出结果是答案：A
A）110
B）100
C）120
D）90
题目解析:语句”p=&x;”表示将p指向变量x的地址，用取值运算符*对指针p取值能够得到p指向的变量x的值，所以输出的结果为100+10=110。
9. 若有定义语句：char str1[]=”string”,str2[8],*str3, str4[10]=”string”;，库函数strcpy的功能是复制字符串，以下选项中错误的函数调用是答案：D
A）strcpy(str4, “HELLO!”)
B）strcpy(str1, “HELLO!”)
C）strcpy(str2, “HELLO!”)
D）strcpy(str3, “HELLO!”)
题目解析:字符指针必须指向一个地址，没有指向具体内存地址的指针不能作为strcpy()的参数。
10. 若有说明和语句：char str[]=”Hello”, *p; p=str;，则此时*(p+5)中的值为答案：C
A）’o’
B）不确定的值
C）’
题目解析:语句”p=str;”将指针p指向了数组str的首地址，所以str[i]与p[i]、*(p+i)、*(str+i)等价。*(p+5)即等价于str[5]，为”。
11. 有以下程序
#include <stdio.h>
struct link{
int data;
struct link* next;
};
main()
{ struct link *h,a ,b;
h=&a; a.data=10; a.next=&b; b.data=20;
________
}
放在下划线处,不能正确输出10,20的语句是答案：B
A）printf(“%d,%d “,a.data,a.next->data);
B）printf(“%d,%d “,h->data,a.next.data);
C）printf(“%d,%d “,a.data,(*a.next).data);
D）printf(“%d,%d “,h->data,(*a.next).data);
题目解析:语句”h=&a; “将指针h指向了链表结点a的地址，所以h->data与(*h).data、a.data等价为10，语句”a.next=&b;”将结点b连接到了结点a的后面，a.next->data与b.data等价为20，选项B）中引用语句不正确，应该为a.next->data。
12. 以下涉及字符数组、字符指针的程序段，不会产生编译错误的是答案：C
A）char head_line[]; head_line = “=============”;
B）char* str, name[10]; name = “Hello World”;
C）char* str, name[10]; str = “Hello World”;
D）char str1[10] = “prog.c”, str2[10]; str2 = str1;
题目解析:数组名表示该数组的首地址，是一个地址常量，不能对它重新赋值。
13. 有如下程序
#include <stdio.h>
main()
{
char* p1 = 0;
int* p2 = 0;
double* p3 = 0;
printf(“%d,%d,%d “, sizeof(p1), sizeof(p2), sizeof(p3));
}
程序运行后的输出结果是答案：C
A）1,2,4
B）0,0,0
C）4,4,4
D）1,4,8
题目解析:指针变量存放的只是对应变量的地址，所以其占用的字节数都是一样的，在32位的计算机上规定一个指针变量占用的内存为32位，即4个字节。
14. 有如下程序
#include <stdio.h>
main()
{
int a = 0, *ptr;
ptr = &a;
*ptr = 3;
a = (*ptr) ++;
printf(“%d,%d “, a, *ptr);
}
程序运行后的输出结果是答案：A
A）4,4
B）0,1
C）0,4
D）1,4
题目解析:ptr = &a;表明将指针ptr指向变量a，所以*p与a等价，语句”a = (*ptr) ++;”相当于”a=a++;”。
15. 有如下程序
#include <stdio.h>
main()
{
char name[10] = {‘S’, ‘T’, ‘R’, ‘I’, ‘N’, ‘G’};
name[3] = ‘E’; name[5] = 0;
printf(“%s “, name);
}
程序运行后的输出结果是答案：C
A）STREN0
B）STRENG
C）STREN
D）STRIEG
题目解析:语句”name[3] = ′E′;”将数组name第四个字符′I′变为字符′E′，语句”name[5] = 0;”则将数组name的第六个字符′G′变为′′，这两句执行完毕后，字符数组前六位元素为”STREN”。
16. 设有定义：int a,b[10],*c=NULL,*p;，则以下语句错误的是答案：B
A）p=&b[0];
B）p=a;
C）p=b;
D）p=c;
题目解析:p为一个指针，只能把一个地址赋值给它。
17. 有以下程序
#include <stdio.h>
main()
{ int s[3][2]={ 1,2,3,4,5,6},*ps[3],k;
for(k=0;k<3;k++)
{ ps[k]=s[k];
printf(“%d “,*(ps[k]+1));
}
}
程序的运行结果是答案：C
A）1 2 3
B）1 3 5
C）2 4 6
D）4 5 6
题目解析:考查行指针。(*ps)[3]表示一个能存放三个整型元素首地址的一维数组的首地址。”ps[k]=s[k];”表示将ps指向s的第k行数据，所以”printf(“%d “,*(ps[k]+1));”输出的是二维数组s中的第二列数据。
18. 有以下程序
#include <stdio.h>
int fun(char *s)
{ char *p=s;
while( *p++ != ‘
19. 有以下程序
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
main()
{ char *p1,*p2;
p1=p2=(char *)malloc(sizeof(char)*10);
strcpy(p1,”malloc”);
strcpy(p2,p1+1);
printf(“%c%c “,p1[0],p2[0]);
}
程序的运行结果是答案：B
A）mm
B）aa
C）am
D）ma
题目解析:语句”p1=p2=(char *)malloc(sizeof(char)*10);strcpy(p1, “malloc”);”将指针p1和p2指向同一块新分配的内存并存入字符串”malloc”，所以p1[i]与p2[i]永远相等，语句”strcpy(p2,p1+1);”即将字符串第2个字符往后的字符串赋值给该p2指向的地址，执行结束后该内存块内的数据为”alloc”。
20. 有以下程序
#include <stdio.h>
struct S{ int a; int *b;};
main()
{ int x1[ ]={3,4},x2[ ]={6,7};
struct S x[ ]={1,x1,2,x2};
printf(“%d,%d “,*x[0].b,*x[1].b);
}
程序的运行结果是答案：B
A）变量的地址值
B）3,6
C）4,7
D）1,2
题目解析:数组名为一个指针常量，指向该数组的首地址，所以*x[0].b与*x1即x1[0]等价，值为3，*x[1].b与*x2即x2[0]等价，值为6。
