以下内容含金~
带你掌握指针,克服畏惧笔试题的心理 !
目录
指针与一维数组
实践出真知,你对指针了解多少?
//笔试题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 ;
码字不易~