【C语言】一次让你看透指针笔试题

怼烎@ 2023-09-28 13:21 111阅读 0赞

以下内容含金~

带你掌握指针，克服畏惧笔试题的心理 ！

--------------------

**目录**

指针与一维数组

解析

指针与二维数组

解析

指针与结构体

解析

二级指针

解析

三级指针

解析

--------------------

# 指针与一维数组 #

*实践出真知，你对指针了解多少？*

//笔试题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;
     }

//笔试题2
    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
    int main()
    {
        int a[5] = { 1, 2, 3, 4, 5 };
    
        int *ptr = (int *)(&a + 1);
    
        //&a取出整个数组的地址，+1跳过整个数组
        //再被强制类型转化成int*类型，可以想到什么呢？
        //指针类型决定指针解引用时访问内存空间的大小
        //最后将地址交给类型为int*的指针ptr
    
        printf( "%d,%d", *(a + 1), *(ptr - 1));
    
        //*(a + 1) a表示首元素地址，+1指向数组第二个元素的地址，再解引用，找到整形2
        //*(ptr + 1) ptr指向数组的末尾，-1指向数组第五个元素，最后解引用，找到整形5 
    
        return 0; 
    }
    
    答案是 2，5

//笔试题2
    int main()
    {
        int a[4] = { 1, 2, 3, 4 };
    
        int *ptr1 = (int *)(&a + 1);
    
        //这里和笔试题1同理
    
        int *ptr2 = (int *)((int)a + 1);
    
        //(int)a  a表示首元素地址，强制转化成int类型，
        //+1指向下一个元素，真的是这样吗？
        //实则不然，a经强制类型转化后，就真的变成数字了
        //假设a首元素地址是0x0012ff40,经(int)强制类型转换后，0x0012ff40真的就变成了十六进制数
        //+1后a就变成了0x0012ff41，再强制类型转化成(int*)类型，意味着解引用操作可以访问四个字节
    
        printf( "%x,%x", ptr1[-1], *ptr2);
    
        //ptr1[-1] == *(ptr1 - 1) 即指向数组的第4个元素，是整形4
        //*ptr2  #如图解#
    
        return 0;
     }
    
    答案是 4，2000000

![761e6759cbb242258e2a22bc4a8e681f.png][]

![4afc0dc3f510454cad3ceb2ab111a45a.png][] ***最后要注意，你以小端存储看内存\*ptr2是00 00 00 02，以%x的形式打印他，要继续用小端存储的视角，也就是再倒着拿出来，即2 00 00 00 （2前面的0可以省略）***

--------------------

# 指针与二维数组 #

*实践出真知，你对指针了解多少？*

//笔试题3
    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; 
    }

--------------------

### 解析 ###

//笔试题3
    int main()
    {
        int a[5][5];
    
        int(*p)[4];
    
        //创建了一个指向数组(4个元素都是int类型)的指针
    
        p = a;
    
        //这里注意，a数组的每个元素真的都能给p吗？
        //p指针访问只能一次访问4个元素的内容
        //#请看图解#
    
        printf( "%p,%d\n", &p[4][2] - &a[4][2], &p[4][2] - &a[4][2]);
    
        //由图解可知&p[4][2] - &a[4][2] = -4;
        //但请注意，以%p打印，打印的是地址，也就是打印数字-4在内存的16进制补码
        //-4的16进制补码是fffffffc
        return 0; 
    }
    
    答案是 fffffffc,-4

![a12d1d231092409e89f42853917f1119.png][]

--------------------

#  #

--------------------

# 指针与结构体 #

*实践出真知，你对指针了解多少？*

//笔试题4
    struct Test
    {
    	int Num;
    	char* Name;
    	short Date;
    	char chan[2];
    	short s[4];
    }*p = 0x100000;
    int main()
    {
     printf("%p\n", p + 0x1);
     printf("%p\n", (unsigned long)p + 0x1);
     printf("%p\n", (unsigned int*)p + 0x1);
     return 0;
    }

--------------------

### 解析 ###

//笔试题4
    struct Test
    {
    	int Num;
    	char* Name;
    	short Date;
    	char chan[2];
    	short s[4];
    }*p = 0x100000;
    
    //本篇重点讲指针，不讲如何计算结构体大小
    //这里可以计算出结构体的大小为20
    
    int main()
    {
     printf("%p\n", p + 0x1);
    
    //p表示结构体的地址为0x100000,+0x1相当于+1，但真的是只+1吗？
    //还记得吗？指针类型决定指针加减整数访问的空间大小,指针类型是结构体，故+1跳过20个字节
    //0x100000是16进制形式表示的，所以+20个字节就是0x100014
    //%p的形式打印出来就是0x100014
    
     printf("%p\n", (unsigned long)p + 0x1);
    
    //这里将p强制类型转化成无符号长整形，什么意思呢？
    //也就是p指向的地址0x100000成为了真正意义上的一个数，+1就只是加了一个数字1
    //因为这是p的内容和数字1都表示整形
    //所以 0x100000 + 0x1 = 0x100001
    //%p的形式打印出来就是0x100001
    //这时可能就有人要问了，这不是个数字吗，怎么以%p的形式打印出来还是没变？
    //%p实际上就是将内存中放的这个数原模原样的打印出来，无符号数0x100000就是内存
    //中的补码转化为16进制后的结果，补码是他在内存中的真正存在形式
    
     printf("%p\n", (unsigned int*)p + 0x1);
    
    //这里将p强制类型转化成一个无符号整形的指针类型，指针的类型决定访问空间的大小，
    //指针的类型是无符号整形，所以+1跳过一个整形
    //这里一定要和上一个printf区分开来，上一个是将p真正的转化成一个数
    //而这里是将p转化成指针，只不过因为指针的类型是无符号整形，访问空间的大小是由指针类型决定的
    //故这里最后的结果是0x100004
    
     return 0;
    }

--------------------

#  #

--------------------

# 二级指针 #

*实践出真知，你对指针了解多少？*

笔试题5
    这是一道曾经阿里巴巴的面试题
    int main()
    {
     char *a[] = {"work","at","alibaba"};
     char**pa = a;
     pa++;
     printf("%s\n", *pa);
     return 0;
    }

--------------------

### 解析 ###

这道题虽然是阿里面试题，但却相比刚刚几个例子，容易很多
    所以我们要敢于有梦想，冲刺大厂！
    int main()
    {
     char *a[] = {"work","at","alibaba"};
     char**pa = a;
     pa++;
     printf("%s\n", *pa);
     return 0;
    }
    //此题画图解释，清晰明了

![948c52ec289643839d3699900fe35603.png][]

*pa表示a数组的首元素地址，pa++指向a数组第二个元素地址的起始位置*

![2531556faa08455792bae6cc358d6ee7.png][]

\*pa找到数组的第二个元素，第二个元素是char\* 类型，通过%s打印字符串"at"

**故答案是 at**

--------------------

# 三级指针 #

*实践出真知，你对指针了解多少？*

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;
    }

--------------------

### 解析 ###

此题相对前面几道题较难
    废话不多讲，咱直接上图~
    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;
    }

*以下是他们的内存布局图*

![60259ab2b8f647af87d1575941faaf45.png][]

*不就是个三级指针，咱也别虚他，乱了阵脚，你看，画出图后是不是清晰了许多*

**“所以，有时画图真的很重要”**

*printf("%s\\n", \*\*++cpp); ++cpp使cpp指向cp数组的第二个元素的地址(c+2这个元素的地址)，第一个\*cpp找到cp数组的第二个元素c+2，第二次解引用\*\*cpp找到c数组的第三个元素P的地址，最后通过%s打印出 POINT；*

*操作后，内存布局变化如下图*

![8051af1891ff4b91a8facc3c2e39f125.png][]

*printf("%s\\n", \*-- \* ++cpp + 3); 先++cpp（一定要注意此时cpp由于第一个printf已经执行指向了cp数组中的第二个元素，如上图）使得cpp指向cp数组的第三个元素c+1的地址，然后\*cpp找到cp数组的第三个元素c+1，在减减操作,c+1-1（注意这里的减减操作是对cp数组的第三个元素），即等于c，再解引用找到c数组第一个元素E的地址，最后+3，跳过三个地址的内容，指向了E元素的地址，如下图 ，最后通过%s打印 ER ；*

![febd6a27baaa4ca2be8ff03a6a91c557.png][]

*操作后，内存布局变化如下图*

![15465a3ba6314e1997856724aabe4838.png][]

*printf("%s\\n", \*cpp\[-2\] + 3); cpp\[-2\] == (cpp - 2)，故经此操作后，cpp又会重新指向cp数组的第一个元素（由上图可知，cpp原本指向cp数组的第三个元素），再解引用cpp得到F的地址，最后 +3 跳过三个地址，指向S元素的地址，如下图，通过%s打印 ST ；*

![d1906e7123214c78a89868754d7310f3.png][]

*操作后，内存布局变化如下图*

![15465a3ba6314e1997856724aabe4838.png][]

*printf("%s\\n", cpp\[-1\]\[-1\] + 1); cpp\[-1\] == \*(cpp - 1）找到cp数组的第二个元素c+2，cpp\[-1\]\[-1\] == \*(\*(cpp - 1) - 1) == \*(c + 2 - 1) == \*(c + 1) 找到了c数组的第二个元素N的地址，最后再+1，跳过一个地址，指向E字符的地址，如下图，通过%s打印 EW ；*

![f7504b7846334f49bf65a5667cee2f40.png][]

**码字不易~**

[761e6759cbb242258e2a22bc4a8e681f.png]: https://img-blog.csdnimg.cn/761e6759cbb242258e2a22bc4a8e681f.png
[4afc0dc3f510454cad3ceb2ab111a45a.png]: https://img-blog.csdnimg.cn/4afc0dc3f510454cad3ceb2ab111a45a.png
[a12d1d231092409e89f42853917f1119.png]: https://img-blog.csdnimg.cn/a12d1d231092409e89f42853917f1119.png
[948c52ec289643839d3699900fe35603.png]: https://img-blog.csdnimg.cn/948c52ec289643839d3699900fe35603.png
[2531556faa08455792bae6cc358d6ee7.png]: https://img-blog.csdnimg.cn/2531556faa08455792bae6cc358d6ee7.png
[60259ab2b8f647af87d1575941faaf45.png]: https://img-blog.csdnimg.cn/60259ab2b8f647af87d1575941faaf45.png
[8051af1891ff4b91a8facc3c2e39f125.png]: https://img-blog.csdnimg.cn/8051af1891ff4b91a8facc3c2e39f125.png
[febd6a27baaa4ca2be8ff03a6a91c557.png]: https://img-blog.csdnimg.cn/febd6a27baaa4ca2be8ff03a6a91c557.png
[15465a3ba6314e1997856724aabe4838.png]: https://img-blog.csdnimg.cn/15465a3ba6314e1997856724aabe4838.png
[d1906e7123214c78a89868754d7310f3.png]: https://img-blog.csdnimg.cn/d1906e7123214c78a89868754d7310f3.png
[f7504b7846334f49bf65a5667cee2f40.png]: https://img-blog.csdnimg.cn/f7504b7846334f49bf65a5667cee2f40.png