以下内容含金~

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

指针与一维数组

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

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

最后要注意，你以小端存储看内存*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

指针与结构体

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

//笔试题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;
}
//此题画图解释，清晰明了

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

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

以下是他们的内存布局图

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

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

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

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

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 ；

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

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

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

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 ；