[PTA选择/基础夯实/期末复习】指针（二）

2-36

以下程序段的输出结果为（ ）。

int m=20,*p=&m; 
*p=10;
printf("%d,%d",m,*p);

A.20,10

B.10,10

C.20,20

D.10,20

2-37

若变量已正确定义并且指针p已经指向某个变量x，则(*p)++相当于____。

A.p++

B.x++

C.*(p++)

D.&x++

2-38

若p1、p2都是整型指针，p1已经指向变量x，要使p2也指向x, ____是正确的。

A.p2=p1

B.p2=**p1

C.p2=&p1

D.p2=*p1

2-39

下列程序段的输出是____。

int c[]={1, 3, 5};
int *k=c+1;
printf("%d", *++k);

A.3

B.4

C.5

D.6

解析： 在程序段中，首先定义了一个整型数组c，包含元素1、3、5。 然后定义了指针变量k，并将其初始化为c+1，即指向数组c的第二个元素。

在printf函数中，使用*++k的方式对k进行操作。 ++k表示先将k的值自增1，指向c的第三个元素。然后，*k表示取出指针k所指向的值，即c的第三个元素的值。

2-40

对于如下说明，语法和语义都正确的赋值是_____。

int c, *s, a[]={1, 3, 5};

A.c=*s;

B.s[0]=a[0];

C.s=&a[1];

D.c=a;

2-41

设变量定义为 int a[2]={1,3}, *p=&a[0]+1;，则*p的值是( )。

A.2

B.3

C.4

D.&a[0]+1

2-42

根据声明int a[10], *p=a; ，下列表达式错误的是（ ）。

A.a[9]

B.p[5]

C.a++

D.*p++

2-43

若定义pf为指向float类型变量f的指针，下列语句中__是正确的。

A.float f, *pf = f;

B.float f, *pf = &f;

C.float *pf = &f, f;

D.float f, *pf =0.0;

2-44

以下选项中，对基本类型相同的指针变量不能进行运算的运算符是（）。

A.+

B.-

C.=

D.==

解析：

A选项因为两个地址相加无意义也可能越界，所以规定不允许指针相加。

B选项，可以求出两个数据元素储存位置之间的相隔同数据类型的元素个数

C选项，赋值。

D选项，判断两指针所指向的是否是同一数据元素

2-45

若有以下说明，且0<=i<10，则对数组元素的错误引用是（）。

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

A.*(a+i)

B.a[p-a+i]

C.p+i

D.*(&a[i])

2-46

下列程序的输出结果是（）。

int main(void)
{
      int a[10] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }, *p = a+3;

      printf(“%d”, *++p);

      return 0;
}

A.3

B.4

C.a[4]的地址

D.非法

2-47

对于下列程序，正确的是（） 。

void f(int *p)
{
      *p = 5;
}
int main(void)
{
      int a, *p;

      a = 10;
      p = &a;
      f(p);
      printf(“%d”, (*p)++);

      return 0;
}

A.5

B.6

C.10

D.11

2-48

存在定义int a[10], x, *pa; , 若pa=&a[0], 下列的哪个选项和其他3个选项不是等价的?

A.x=*pa;

B.x=*(a+1);

C.x=*(pa+1);

D.x=a[1];

2-49

对a数组元素不正确的引用是
int a [ ]={ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9}, * p=a, i;
其中0≤i≤9。

A.a[p-a]

B.*(&a[i])

C.p[i]

D.a[10]

2-50

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

#include<stdio.h>
int main()
{
 int  *a, b=3;
 *a=b;
 printf("%d",*a) ;
}

A.0

B.3

C.不确定

D.程序无法正常运行。

解析：指针变量 a 没有被正确初始化，它是一个野指针（未指向有效的内存地址），因此在执行 *a=b; 时会导致未定义的行为。这可能会导致程序崩溃或产生意想不到的结果。

2-51

int *p 的含义是

A.p是一个指针, 用来存放一个整型数

B.p是一个指针, 用来存放一个整型数据在内存中的地址

C.p是一个整型变量

D.以上都不对

2-52

有如下程序段

int *p,a=10,b=1;
p=&a; a=*p + b;

执行该程序段后,a的值是

A.12

B.11

C.10

D.编译出错

2-53

若有如下定义，则（ ）的值是34。

int a[] = {5, 15, 34, 54, 14, 2, 52, 72};

int *p = &a[1];

A.p[1]

B.p[2]

C.p[0]

D.p[3]

2-54

如果有定义：int m, n = 5, *p = &m; 与m = n 等价的语句是 （） 。

A.m = *p;

B.*p = *&n;

C.m = &n;

D.m = **p;

2-55

下面程序的输出结果是( )。

# include <stdio.h> 
void fun (int *x, int *y)
{
    printf("%d%d", *x, *y);
    *x = 3;
    *y = 4;
} 
int main(void)
{
    int x=1, y=2;  
    
    fun(&x, &y);  
    printf("%d%d", x, y);

    return 0;
}

A.2134

B.1212

C.1234

D.2112

2-56

下面程序的输出结果是( )。

#include <stdio.h>

void fun (int *x,  int y)
{
    printf("%d%d", *x, y);
    *x=3;  
    y=4;
}
int main(void)
{
    int x = 1, y = 2;
        
    fun(&y, x);
    printf("%d%d", x, y);
        
    return 0;
}

A.1234

B.1221

C.2131

D.2113

2-57

下列程序的输出结果是( )。

# include <stdio.h> 
int main(void)
{
    int a[10] = {0,1,2,3,4,5,6,7,8,9}, *p = a+3;
        
    printf("%d", p[2]);
        
    return 0;
}

A.3

B.4

C.5

D.非法

2-58

已有定义int k=2; int *ptr1, *ptr2; 且ptr1和ptr2均已指向变量k，下面不能正确执行的赋值语句是( )。

A.k = *ptr1 + *ptr2;

B.ptr2 = k;

C.ptr1 = ptr2;

D.k = *ptr1 *(*ptr2);

2-59

请选出以下程序的输出结果

#include<stdio.h>
void sub(int *,int );
int main()
{
  int a[ ]={ 1,2,3,4 },i;
  int x=0;
  for(i=0; i<4; i++)
  { sub(a,x);
    printf("%d ",x);
  }
  printf("\n");
  return 0;
}
void sub(int *s,int y)
{ static int t=3;
  y=s[t];
  t--;
}

A.1 2 3 4

B.4 3 2 1

C.0 0 0 0

D.4 4 4 4

解析：

在主函数中，定义了一个整型数组a，包含元素1、2、3、4，并初始化变量x为0。然后使用for循环遍历数组a的每个元素，并将数组a和变量x传递给函数sub。

在函数sub中，定义了静态变量t并初始化为3。在每次调用sub函数时，将数组s中索引为t的元素赋值给形参y，然后将t自减1。因为t是静态变量，它的值在多次调用sub函数时保持不变。

回到主函数，在每次调用sub函数后，输出变量x的值。但注意，在函数sub中，形参y的值只是被赋值为数组s中索引为t的元素，并不会影响到主函数中的变量x。

由于循环中的sub函数并没有改变变量x的值，所以每次输出都是0。

因此，程序的输出结果是：0 0 0 0。

2-60

int a=5,*ap=&a ;则下列表达式错误的是：

A.&*ap 相当于&a

B.*&a 相当于ap

C.(*ap)++ 相当于a++

D.*ap++ 是合法访问

2-61

以下程序段给数组所有的元素输入数据， 请选择正确答案填入：

#include <stdio.h>
int  main()
{
  int a[10]={0},i=0;
  while(i<10)
   scanf("%d",＿?＿);
  return 0;
}

A.a+(i++)

B.&a[i+1]

C.a+i

D.&a[++i]

2-62

若有以下说明，且0<=i<10，则____是对数组元素地址的正确表示：

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

A.&(a+1)

B.a++

C.&p

D.&p[i ]

2-63

执行如下程序段，打印输出的内容是：

#include <stdio.h>
void fun (int c, int *d) {
    c++;
    (*d)++;
}
int main ( ){
    int a=1, b=2;
    fun(a, &b);
    printf("%d, %d", a, b);
    return 0;
}

A.1, 3

B.2, 1

C.1, 2

D.2, 2

2-64

有如下定义，则下列符号中均正确地代表x的地址选项是

int x,*p;
p=&x;

A.&x, p, &*x

B.*&x, p

C.*p, &p, x

D.&x, &*p, p

2-65

当调用函数时，实参是一个数组名，则向函数传送的是_____ 。

A.数组的长度

B.数组的首地址

C.数组每一个元素的地址

D.数组每个元素中的值

2-66

以下程序的运行结果是______。

#include <stdio.h>
int 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);
return 0;
}

A.16

B.10

C.8

D.6

2-67

若有以下定义，int a[5],*p=a; 则对a数组元素的正确引用是（ ）。

A.*&a[5]

B.*(a+2)

C.*(p+5)

D.a+2

2-68

若有以下定义，int a[10],*p=a; 则p+5表示（ ）。

A.元素a[5]的地址

B.元素a[5]的值

C.元素a[6]的地址

D.元素a[6]的值

2-69

若有说明：int n=2,*p=&n,*q=p;则以下非法的赋值为（ ）。

A.p=q;

B.*p=*q;

C.n=*q;

D.p=n;

2-70

下列程序的输出结果是（）。

void f(int *p)
{   
    *p = 5;
}
int main(void)
{    
    int  x = 10, *px = &x;

    f(px);
    printf("%d#", (*px)++);
    printf("%d\n", x);

   return 0;
}

A.5#6

B.6#6

C.10#11

D.11#11