当前位置:   article > 正文

【C语言】8道经典指针笔试题(深度解剖)_c语言题目深层

c语言题目深层

上一篇我们也介绍了指针的笔试题,这一篇我们趁热打铁继续讲解8道指针更有趣的笔试题,,让大家更加深刻了解指针,从而也拿下【C语言】指针这个难点!
本次解析是在x86(32位)平台下进行

所需储备知识

  1. sizeof(数组名),这里的数组名表示整个数组,计算的是整个数组的大小。
  2. &数组名,这里的数组名表示整个数组,取出的是整个数组的地址。
  3. 除此之外所有的数组名都表示首元素的地址。
  4. 指针关系运算

笔试题1

以下代码结果是什么!?

int main()
{
    int a[5] = { 1, 2, 3, 4, 5 };
    int *ptr = (int *)(&a + 1);
    printf( "%d,%d", *(a + 1), *(ptr - 1));
    return 0;
}
//程序的结果是什么?
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

解析:

int *ptr = (int *)(&a + 1); (&a = int( *)[5]) &a取出了整个数组地址,&a+1跳过整个数组(ptr并没有解引用,所以不会造成越界访问)
在这里插入图片描述

*(a + 1) ,a是数组名,数组名代表首元素地址,首元素地址+1,跳到下一个元素2的地址,在解引用。 第一个输出结果答案是->2

*(ptr - 1),ptr此时指向了组最后一个元素地址的下一个地址, -1又回到了最后一个元素地址,解引用。第二个输出结果答案是->5


笔试题2

以下代码结果是什么!?

struct Test
{
 int Num;
 char *pcName;
 short sDate;
 char cha[2];
 short sBa[4];
}*p;
假设p 的值为0x100000。 如下表表达式的值分别为多少?
已知,结构体Test类型的变量大小是20个字节
int main()
{
 printf("%p\n", p + 0x1);
 printf("%p\n", (unsigned long)p + 0x1);
 printf("%p\n", (unsigned int*)p + 0x1);
 return 0;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17

解析:
0x1 就是十六进制 1

printf(“%p\n”, p + 0x1);

p是一个结构体指针类型,结构体类型+1 跳过一个结构体大小,单位是字节。
所以p+1跳过20个字节,答案是-> 0x100014 .(十六进制14 代表十进制20)

printf(“%p\n”, (unsigned long)p + 0x1);

p 强制类型转换成(无符号整形),整型+1就是+1.
所以整型p+1跳过一个字节 .答案是->0x100001

printf(“%p\n”, (unsigned int*)p + 0x1);

p 强制类型转换成(整型指针类型),整型int指针+1,跳过一个整型。
答案是->0x100004


笔试题3

以下代码结果是什么!?

int main()
{
    int a[4] = { 1, 2, 3, 4 };
    int *ptr1 = (int *)(&a + 1);
    int *ptr2 = (int *)((int)a + 1);
    printf( "%x,%x", ptr1[-1], *ptr2);
    return 0;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

代码可能在x64位平台下编译不过 ,请换成x86(32)位平台

解析:

int *ptr1 = (int *)(&a + 1);
&a取出整个数组的地址,+1跳过整个数组

int *ptr2 = (int *)((int)a + 1);
a强制类型转换成 (整型),整型+1就是+1,跳过一个字节

printf( “%x,%x”, ptr1[-1], *ptr2);
图析:在这里插入图片描述

所以ptr1[-1]答案->是 4
*ptr2 答案是-> 02 00 00 00


笔试题4

以下代码结果是什么!?

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

解析:

大家看清楚了! {}括号里面的()是逗号表达式,逗号表达式只算最后一个元素,所以int a【3】【2】 实际放的是 {1,3,5,0,0,0}

p = a[0] p是一个指针变量,a【0】 (a没有单独放在sizoef内部,代表的是二维数组首元素地址,二维数组首元素是第一行的地址, 那a是第一行了,a[0] 又是 第一行第一个元素a【0】【0】)。
所以 p[0] 是第一个元素,答案是->1


笔试题5

以下代码结果是什么!?

int main()
{
    int a[5][5];
    int(*p)[4];
    p = a;
    printf( "%p,%d\n", &p[4][2] - &a[4][2], &p[4][2] - &a[4][2]);
    return 0;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

解析:

图析:
该内存代码布局:
在这里插入图片描述
答案是->-4 FFFFFFFC


笔试题6

以下代码结果是什么!?

int main()
{
    int aa[2][5] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
    int *ptr1 = (int *)(&aa + 1);
    int *ptr2 = (int *)(*(aa + 1));
    printf( "%d,%d", *(ptr1 - 1), *(ptr2 - 1));
    return 0;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

解析:

int *ptr1 = (int *)(&aa + 1);
&aa取出整个数组的地址,+1跳过aa数组,来到10元素后面的位置。

int * ptr2 = (int *)( *(aa + 1));
aa代表首元素地址(二维数组首元素地址是第一行地址),首元素地址+1就是第二个行的地址,在解引用。

在这里插入图片描述

*(ptr1 - 1)
ptr1-1 指向了元素10(&a[1][4])的地址, 解引用找到10,答案是->10

*(ptr2 - 1)
ptr2-1 指向了后面5(&a[0][4])的地址,在解引用。答案是->5


以下代码结果是什么!?

笔试题7

#include <stdio.h>
int main()
{
 char *a[] = {"work","at","alibaba"};
 char**pa = a;
 pa++;
 printf("%s\n", *pa);
 return 0;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

解析:

*pa

其实该题把代码内存部图画出来就很容易解出来了,如下
在这里插入图片描述


笔试题8

以下代码结果是什么!?

int main()
{
 char *c[] = {"ENTER","NEW","POINT","FIRST"};
 char**cp[] = {c+3,c+2,c+1,c};
 char***cpp = cp;
 printf("%s\n", **++cpp);
 printf("%s\n", *--*++cpp+3);
 printf("%s\n", *cpp[-2]+3);
 printf("%s\n", cpp[-1][-1]+1);
 return 0;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11

该题比较复杂,要先画出内存部图才分析,不然很难做对

解析:

内该代码存部图(一步步画图分析)
在这里插入图片描述

  • 1

printf(“%s\n”, * * ++cpp);

  1. 先加加cpp,此时cpp指向了c+2
  2. 在解引用找到c+2
  3. 在解引用找到ROINT
    答案是->ROINT. 内存部图如下(1)
    在这里插入图片描述
  • 2:

printf(“%s\n”, * - - * ++cpp+3);

  1. 先++cpp ,此时cpp指向了c+1
  2. 在解引用找到了c+1
  3. 再减减c+1 变成了c
  4. 解引用C 找到了ENTER
  5. ENTER+3 指向了E
    最后以%s打印 答案是->ER 。内存部图如下(2)
    在这里插入图片描述
  • 3:

printf(“%s\n”, *cpp[-2]+3);

cpp[-2] = * (cpp-2)

  1. cpp[-2] , 此时cpp找到了c+3并解引用(cpp并没有指向他)
  2. c+3在解引用找到了 FIRST
  3. FIRST+3 指向了S
    最后以%s打印 答案是->ST 。内存部图如下(3)
    在这里插入图片描述
  • 4:

printf(“%s\n”, cpp[-1][-1]+1);

cpp[-1][-1] = *( *(cpp-1)-1)

  1. *(cpp-1) 此时指向了 c+2 (cpp并没有指向他)
  2. *( *(cpp-1)-1) 把c+2再减1 (变成c+1)在解引用找到了NEW
  3. NEW + 1 指向了E
    最后以%s打印 答案是->EW 。内存部图如下(4)
    在这里插入图片描述

完!


总结:

  • 把二维数组当成一维数组来看待。题目就没有那么抽象

  • 指针类型加减运算决定了,对指针解引用的时候有多大的权限(能操作几个字节)

  • 如果不是单独放在sizeof()内部,一般的操作都会使指针降一阶

  • 对于抽象的指针一定要画图理解,不然很难做出。

声明:本文内容由网友自发贡献,不代表【wpsshop博客】立场,版权归原作者所有,本站不承担相应法律责任。如您发现有侵权的内容,请联系我们。转载请注明出处:https://www.wpsshop.cn/w/花生_TL007/article/detail/164713
推荐阅读
相关标签
  

闽ICP备14008679号