【C语言进阶技巧】指针解密：炼金术士的秘密面试题揭秘

❤️博客主页： 小镇敲码人
🍏 欢迎关注：👍点赞 👂🏽留言 😍收藏
🌞回来6天了，加油！！！🍎🍎🍎
❤️二十岁出头的时候，请把自己摆在二十岁出头的位置上。踏实的学习，好好积累能力和锻炼心智。那些远大的目标，不管你如何幻想，都不如当下多看一页书，多学一点东西，每天早起奋斗，来的实际。 💞 💞 💞

1. 主要涉及sizeof与strlen函数的使用的笔试题

在做这类题型之前我们首先要回顾一下数组名代表什么？
数组名代表数组首元素的地址，但下面两种情况例外：
1. sizeof(数组名)，此时的数组名，代表整个数组，计算的是整个数组的大小，单位是字节。
2. &数组名，这里的数组名也代表整个数组，取出的是整个数组的大小。

然后我们介绍一下sizeof和stlren：

1. sizeof

sizeof是C语言中的一个关键字，用来计算类型所占内存的大小，单位是字节。

2. strlen
   

由图可知，strlen是C语言标准库'string.h'中的一个函数，用来计算字符串的长度（不包含\0）,这个函数的参数是一个字符指针，并且有const修饰字符串，代表strlen只计算字符的个数，而不会修改字符串，返回值是size_t类型（无符号整形,返回的是字符串的长度，意思是字符串的长度不会出现负数的情况，当遇见\0时，这个函数才会返回一个值。

1.1 笔试题一（一维整形数组）

• sizeof只关注里面()的类型，不会去去计算表达式的值。
• 32位和64位地址的大小不同，分别是4/8字节。

int main()
{
	int a[] = { 1,2,3,4 };
	printf("%d\n", sizeof(a));//16
	printf("%d\n", sizeof(a + 0));//4/8
	printf("%d\n", sizeof(*a));//4
	printf("%d\n", sizeof(a + 1));//4/8
	printf("%d\n", sizeof(a[1]));//4
	printf("%d\n", sizeof(&a));//4/8
	printf("%d\n", sizeof(*&a));//16
	printf("%d\n", sizeof(&a + 1));//4/8
	printf("%d\n", sizeof(&a[0]));//4/8
	printf("%d\n", sizeof(&a[0] + 1));//4/8
}

1. printf("%d\n", sizeof(a));a在这里代表整个数组，所以计算的是整个数组的大小为$16$。
2. printf("%d\n", sizeof(a + 0));a+0代表的是首元素的地址，是地址，就是4/8。
3. printf("%d\n", sizeof(*a));*a的类型是int型，答案是4。
4. printf("%d\n", sizeof(a + 1));a+1的类型是指针，答案是4/8。
5. printf("%d\n", sizeof(a[1]));a[1]与*a是等效的，它的类型也是int型，答案是4。
6. printf("%d\n", sizeof(&a));&a的类型是指针，答案是4/8。
7. printf("%d\n", sizeof(*&a));//*和&抵消，就等价于sizeof(a),和第一个一样，答案是16。
8. printf("%d\n", sizeof(&a + 1));&a+1的类型是指针，答案是4/8。
9. printf("%d\n", sizeof(&a[0]));&a[0]代表第一个元素的地址，地址就是4/8。
   也可以这样理解，&a[0]等价于&*（a+0），&和*抵消，所以这题和第二题一样，答案就是4/8。
10. printf("%d\n", sizeof(&a[0] + 1));&a[0]是首元素地址，加一指向下一个元素，还是地址，所以答案就是4/8。
    运行结果：（32位）
    
    这里给出64位的运行结果，后面的题只给32位：
    

1.2 笔试题二（不带\0的字符数组）

#include<stdio.h>
#include<string.h>
int main()
{
	char arr[] = { 'a','b','c','d','e','f' };
	printf("%d\n", sizeof(arr));//6
	printf("%d\n", sizeof(arr + 0));//4/8
	printf("%d\n", sizeof(*arr));//1
	printf("%d\n", sizeof(arr[1]));//1
	printf("%d\n", sizeof(&arr));//4/8
	printf("%d\n", sizeof(&arr + 1));//4/8
	printf("%d\n", sizeof(&arr[0] + 1));//4/8
	printf("%d\n", strlen(arr));//随机值
	printf("%d\n", strlen(arr + 0));//随机值
	printf("%d\n", strlen(*arr));//err
	printf("%d\n", strlen(arr[1]));//err
	printf("%d\n", strlen(&arr));//随机值
	printf("%d\n", strlen(&arr + 1));//随机值
	printf("%d\n", strlen(&arr[0] + 1));//随机值
}

1. printf("%d\n", sizeof(arr));此时的数组名代表整个数组，计算的是整个数组的大小，所以答案是6。
2. printf("%d\n", sizeof(arr + 0));arr+0代表第一个元素的地址，是地址，所以答案就是4/8。
3. printf("%d\n", sizeof(*arr));由于arr除了和sizeof单独在一起表示整个数组，其余情况都是表示首元素地址，所以解引用后，*arr就代表数组的第一个元素，它的类型是char，所以答案是1。
4. printf("%d\n", sizeof(arr[1]));arr[1]从数组的角度来理解，是代表第二个元素，它的类型是char，所以答案是1。从指针的角度来理解，[]与*等价，所以arr[1]可以写为*（arr+1）,arr是首元素地址，加一，跳过一个字节，指针指向第二个元素，解引用后，代表第二个元素，类型是char，答案是1。
5. printf("%d\n", sizeof(&arr));类型是指针，答案是4/8。
6. printf("%d\n", sizeof(&arr + 1));类型是指针，答案是4/8。
7. printf("%d\n", sizeof(&arr[0] + 1));[]和*等价，&arr[0]+1,可以写为&*(arr+0)+1,*和&抵消，再等价变为，arr+1,代表第二个元素的地址，答案是4/8。
8. printf("%d\n", strlen(arr));arr是首元素地址，strlen遇见\0才会返回值，但这个数组不是字符串不会默认加上\0,所以算出的长度是一个随机值。
9. printf("%d\n", strlen(arr + 0));arr+0也是首元素地址，答案也是随机值由于，数组是连续存储，它分配的地址也是连续的一块，但这一块具体是哪里，每一次都不同，所以这个随机值的结果每一次都不同，但答案和8的答案相同，因为程序开始运行，数组的地址已经分配好了，所以它遇见的\0和第8行代码遇见的\0是同一个\0。
10. printf("%d\n", strlen(*arr));strlen函数的参数是一个字符指针，arr代表首元素地址，解引用后是一个字符，所以这个代码是错误的，程序会崩溃。
11. printf("%d\n", strlen(arr[1]));arr[1]是第二个字符，情况和10的情况一样。
12. printf("%d\n", strlen(&arr));&arr代表整个数组的地址,但它的值和arr是一样的，所以答案也是随机值，和8一样，这里VS的编译器会报警告，因为&arr是数组指针类型，而strlen函数的参数是字符指针，但不影响程序的运行。
13. printf("%d\n", strlen(&arr + 1));&arr是整个数组的地址虽然值和arr一样但是类型不一样，+1跳过整个数组，结果是随机值，比8的值要小6。
14. printf("%d\n", strlen(&arr[0] + 1));&arr[0]是首元素的地址，+1代表第一个元素的地址，是随机值，但结果比8的结果小了1。

运行结果：

• 这里我们没有把错误的代码注释，可以看到，程序进行到那个错误的代码那里就崩溃了。
  当我们把两个错误的代码注释后，运行结果是这样的：
  
• 注意：我们发现两次运行8、9的结果是不同的，因为编译器给数组重新分配了一块新的地址，第一个\0的位置也不同了。

1.3 笔试题三(带\0的字符数组)

#include<stdio.h>
#include<string.h>
int main()
{
	char arr[] = "abcdef";
	printf("%d\n", sizeof(arr));//7
	printf("%d\n", sizeof(arr + 0));//4/8
	printf("%d\n", sizeof(*arr));//1
	printf("%d\n", sizeof(arr[1]));//1
	printf("%d\n", sizeof(&arr));//4/8
	printf("%d\n", sizeof(&arr + 1));//4/8
	printf("%d\n", sizeof(&arr[0] + 1));//4/8
	printf("%d\n", strlen(arr));//6
	printf("%d\n", strlen(arr + 0));//6
	printf("%d\n", strlen(*arr));//err
	printf("%d\n", strlen(arr[1]));//err
	printf("%d\n", strlen(&arr));//6
	printf("%d\n", strlen(&arr + 1int));//随机值
	printf("%d\n", strlen(&arr[0] + 1));//5
	return 0;
}

• 字符串是字符数组的一种类型，区别是字符串编译器会默认在它最后一个非\0字符后面加上\0。

1. printf("%d\n", sizeof(arr));此时的数组名代表整个数组，计算的是整个数组的大小，所以答案是7，因为字符串结尾默认带一个\0,也存入了数组中。
2. printf("%d\n", sizeof(arr+0));表示首元素地址，答案为4/8。
3. printf("%d\n", sizeof(*arr));表示首元素，类型是char,所以答案是1。
4. printf("%d\n", sizeof(arr[1]));表示第二个元素，类型也是char，答案是1。
5. printf("%d\n", sizeof(&arr));表示整个数组的地址，类型是指针，答案是4/8。
6. printf("%d\n", sizeof(&arr+1));类型为指针，答案是4/8。
7. printf("%d\n", sizeof(&arr[0]+1));类型为指针，答案是4/8。
8. printf("%d\n", strlen(arr));strlen计算字符串长度以\0为结束标志，但是不计入\0,arr表示首元素地址，所以答案是就是字符串字符的个数（不含\0）为6。
9. printf("%d\n", strlen(arr+0));表示首元素地址，答案是6。
10. printf("%d\n", strlen(*arr));程序会崩溃，因为*arr是首字符,strlen函数参数是指针。
11. printf("%d\n", strlen(arr[1]));程序会崩溃，因为*arr是首字符,strlen函数参数是指针。
12. printf("%d\n", strlen(&arr));&arr是数组的地址，它的值和数组首元素的值一样，所以答案是6。
13. printf("%d\n", strlen(&arr+1));&arr+1,指针跳过的是一个数组的大小，所以指针指向\0的后面，答案是一个随机值。
14. printf("%d\n", strlen(&arr[0]+1));&arr[0]是首元素的地址，+1是第二个元素的地址，所以答案是5。
    运行结果：
    

1.4 笔试题四 （字符指针形式的字符串）

int main()
{
	char* p = "abcdef";
	printf("%d\n", sizeof(p));//4
	printf("%d\n", sizeof(p + 1));//4/8
	printf("%d\n", sizeof(*p));//1
	printf("%d\n", sizeof(p[0]));//1
	printf("%d\n", sizeof(&p));//4/8
	printf("%d\n", sizeof(&p + 1));//4/8
	printf("%d\n", sizeof(&p[0] + 1));//4/8
	printf("%d\n", strlen(p));//6
	printf("%d\n", strlen(p + 1));//5
	printf("%d\n", strlen(*p));//err
	printf("%d\n", strlen(p[0]));//err
	printf("%d\n", strlen(&p));//随机值
	printf("%d\n", strlen(&p + 1));//随机值
	printf("%d\n", strlen(&p[0] + 1));//5
	return 0;
}

• p是一个字符指针，存放首字符a的地址。
  

1. printf("%d\n", sizeof(p));p是指针变量，所以答案是4/8。
2. printf("%d\n", sizeof(p+1));p+1也是指针变量，答案是4/8。
3. printf("%d\n", sizeof(*p));p是一个字符指针，存放首字符a的地址，*p是首字符，类型是char，所以答案是1。
4. printf("%d\n", sizeof(p[0]));p[0] -> *(p+0),代表首字符，类型是char,故答案是1。
5. printf("%d\n", sizeof(&p));&p是存放字符指针的地址，是地址所以答案就是4/8。
6. printf("%d\n", sizeof(&p+1));&p+1，也是指针，因为char*类型是指针，所以&p+1要跳过4/8个字节，指向一个char*类型的变量，并存放它的地址，不过它既然是指针变量，那么答案就是4/8字节。
7. printf("%d\n", sizeof(&p[0]+1));&p[0] -> &*(p+0)为第一个字符的地址，加上1，就代表第二个字符的地址，类型是指针变量，那么答案就是4/8。
8. printf("%d\n", strlen(p));p是首字符的地址，strlen算的是字符串的长度，所以答案是6。
9. printf("%d\n", strlen(p+1));p+1是第2个字符的地址，从这个字符往后数，直到遇见\0结束，所以答案是5。
10. printf("%d\n", strlen(*p));*p代表首字符，strlen应该传地址，程序会崩。
11. printf("%d\n", strlen(p[0]));p[0] -> *(p+0)也是首字符，和10一样程序会崩。
12. printf("%d\n", strlen(&p));&p是二级指针，存储着指针变量p的地址，除了两次解引用可以找到首字符，它和字符串没有任何关系，这一点和数组是有区别的，所以我们不知道什么时候会遇见\0,答案是随机值。
13. printf("%d\n", strlen(&p+1));&p+1也是一个地址，指针加1在原先位置跳过四个字节，储存那个位置的地址，同样的传给strlen,我们也不清楚什么时候会遇见\0,答案是随机值。
    15.printf("%d\n", strlen(&p[0]+1));由上面第11题可以知道&p[0]等价于p，和第9题一样，答案是5。

运行结果：

• 这里我们没有把错误的代码注释，可以看到，程序进行到那个错误的代码那里就崩溃了。当我们把两个错误的代码注释后，运行结果是这样的：
  

1.5 笔试题五（二维整形数组）

在做题前对二维数组的a[i]做一下阐述：

• 二维数组是一维数组的数组。
• 二维数组的数组名代表首元素地址，也就是第一行的地址，单独放在sizeof内部代表整个数组
• a[i]代表第i行的数组名，一般情况下表示第i行首元素的地址，单独放在sizeof内部表示那一行的大小。

int main()
{
	//二维数组
	int a[3][4] = { 0 };
	printf("%d\n", sizeof(a));//48
	printf("%d\n", sizeof(a[0][0]));//4
	printf("%d\n", sizeof(a[0]));//16
	printf("%d\n", sizeof(a[0] + 1));//4/8
	printf("%d\n", sizeof(*(a[0] + 1)));//4
	printf("%d\n", sizeof(a + 1));//4/8
	printf("%d\n", sizeof(*(a + 1)));//16
	printf("%d\n", sizeof(&a[0] + 1));//4/8
	printf("%d\n", sizeof(*(&a[0] + 1)));//16
	printf("%d\n", sizeof(*a));//16
	printf("%d\n", sizeof(a[3]));//16
}

1. printf("%d\n",sizeof(a));a是二维数组的数组名，与sizeof单独放在一起，所以表示整个二维数组的大小，答案是$3\ast 4\ast 4=48$。
2. printf("%d\n",sizeof(a[0][0]));a[0][0]代表第一个元素，类型是int，答案是4。
3. printf("%d\n",sizeof(a[0]));a[0]代表第一行的数组名，sizeof与第一行数组名单独放在一起，代表第一行的大小，所以答案是$4\ast 4=16$。
4. printf("%d\n",sizeof(a[0]+1));a[0]是第一行数组名，它没有和sizeof单独放在一起，所以现在代表第一行首元素的地址，加上一是第一行第二个元素的地址，是地址，所以答案是4/8。
5. printf("%d\n",sizeof(*(a[0]+1)));a[0] -> *(a+0),a是二维数组的数组名，这里是二维数组首元素地址，也就是第一行的地址，解引用就是第一行的数组名a[0]，第一行的数组名这里不是单独放在sizeof里面，所以代表第一行一维数组的首元素地址，指针加1代表第一行第二个元素的地址，再解引用，代表第一行的第二个元素，即a[0][1],类型是int，所以答案是4。
6. printf("%d\n",sizeof(a+1));a是第一行一维数组的地址，指针+1代表，跳过一个数组的大小，二维数组中的下一行的数据是与前一行的数据相邻的，所以指针现在指向第二行，表示第二行的地址，所以答案是4/8。
7. printf("%d\n",sizeof(*(a+1)));由第6题可以知道，a+1是第二行一维数组的地址，*（a+1）-> a[1],表示第二行一维数组的数组名，sizeof与数组名单独在一起，此时数组名代表整个第二行的一维数组，所以计算的是整个第二行一维数组的大小，答案是$4\ast 4=16$。
8. printf("%d\n",sizeof(&a[0]+1));&a[0] ->&*(a+0))->a+0,此时的a没有单独放在sizeof中，表示第一行数组的地址，数组的地址+1，代表第二行数组的地址，是地址所以答案就是4/8。
9. printf("%d\n",sizeof(*(&a[0]+1)));由第8题可以知道，&a[0]+1代表第二行数组的地址，再解引用，就是(a+1) -> a[1],表示第二行数组名，此时数组名单独放在sizeof里面，计算的是整个这一行数组的大小，所以答案是$4\ast 4=16$。
10. printf("%d\n",sizeof(*a));*a -> a[0],第一行一维数组的数组名单独放在sizeof内部，计算这第一行数组的大小，所以答案是$4\ast 4=16$。
11. printf("%d\n",sizeof(a[3]));sizeof只关心所给式子的类型，虽然这里的a[3]越界了，但是不影响，sizeof不会真的去计算或者访问我的数据，a[3]还是数组名单独放在sizeof内部，它的类型是int [4],所以答案是$4\ast 4=16$。
    运行结果：

2. 无明显特征的笔试题

2.1 笔试题一

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

1. *(a+1)这样来理解，a此时代表数组首元素地址，a+1,指针跳过4个字节，指向第二个元素，解引用，结果就是第二个元素，答案是$4$。
2. *(ptr-1)等于什么？要做这个题，我们得先知道ptr指向哪里？它的类型是什么？&a+1的理解，&a表示整个数组的地址，它的值和a相同，但是间接级别不一样，它的类型是int (*) [5],+1跳过整个数组，指向5后面的内容，它然后强制转换变成int*的指针，-1向后跳4个字节，指向整数5，此时指针变量储存的是5的地址，解引用所以答案是5，下面有一张图帮助你理解：
   
   运行截图：

2.2 笔试题二

2.2.1 %x与%p

在C语言中，%x 和 %p 都是格式化输出的转换说明符，但它们有不同的用途和功能。
%x：%x 用于将无符号整数以十六进制形式输出。它将整数值转换为十六进制表示，并以小写字母表示字母部分（a-f）。例如，使用 %x 输出十进制数 255，结果将是 ff。
%p: %p 用于将指针的地址以十六进制形式输出。它接受一个指向任何类型的指针，并将其地址以十六进制形式输出。通常用于打印指针变量的值。
需要注意的是，使用 %p 输出指针时，需要将指针转换为 (void *) 类型，因为 %p 期望的是一个 void * 类型的指针。

//由于还没学习结构体，这里告知结构体的大小是20个字节
struct Test
{
	int Num;
	char* pcName;
	short sDate;
	char cha[2];
	short sBa[4];
}*p;
//假设p 的值为0x100000。 如下表表达式的值分别为多少？
//已知，结构体Test类型的变量大小是20个字节
//注意：H：十六进制 D:十进制
int main()
{
	printf("%p\n", p + 0x1);//0x100000（H）+20(D) -> 0x100014
	printf("%p\n", (unsigned long)p + 0x1);//0x100001
	printf("%p\n", (unsigned int*)p + 0x1);//0x100004
	return 0;
}

1. printf("%p\n", p + 0x1);p是一个指针，它解引用是一个结构体，所以它的间接级别是这个结构体类型的大小，+1跳过20个字节，p变量的值就会增加，$0X100000(H)+20(D)->0X100000(H)+0X000014（H）=0X100014$。
2. printf("%p\n", (unsigned long)p + 0x1);p被强制转换为一个无符号的整形，+1就是整数加1，它的十六进制存储值也只加1，答案就是0X100001。
3. printf("%p\n", (unsigned int*)p + 0x1);将p强制转换为无符号整形指针的变量，间接级别改变，+1只跳过4个字节，$0X100000+0X100004=0X100004$。

运行截图：

2.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);//4,2000000
	return 0;
}

我们通过画图和文字的形式给出过程：

由于是小端存储(后续会讲)，ptr1解引用后拿出来十六进制表示应该是0x00000002,以十进制打印，结果就是2，ptr2解引用后拿出来以十六进制来表示是0x02000000,以十进制打印，结果就是2000000。

运行结果：

2.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]);//1
	return 0;
}

• 逗号表达式（Comma Expression）是一种C语言中的表达式，它由多个表达式通过逗号连接而成。逗号表达式的值是最后一个表达式的值。
• 在C语言中，表达式（Expression）是由操作数（Operand）和运算符（Operator）组成的组合，用于执行计算和生成值。数字（如整数和浮点数）可以被视为最简单的操作数。

• 此题主要考察了逗号表达式，注意二维数组中一维数组的赋值应该是大括号的形式，此题是(value1,value2)的形式，说明存在陷阱，因为逗号表达式的值是最后一个表达式的值，所以实际上，只给二维数组a赋了3个值，即1、3、5，其他的位置都没有赋值，p是a[0]也就是第一行一维数组的数组名，p[0] -> a[0][0],a[0][0]的值是1，所以结果就是1。

运行结果：

2.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]);//FFFFFFFC,-4
	return 0;
}

• 所以从图中可以看到&p[4][2]与&a[4][2]相差4个元素，注意：高地址的指针-低地址的指针，以%d形式打印得到的是两者之间相隔的元素个数，而单独以%d打印，然后再去相减得到是两个地址相差的字节数，由于是数组从左往右遍历，右边的是高地址，所以%d打印是-4，%p打印-4在内存中是补码的形式去打印，这里我们给出-4的原码、反码、补码、补码的16进制表示：
  

运行截图：

2.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));//10,5

	return 0;
}

• 这是一道送分题，就不画图了，&aa此时表示整个数组的地址，虽然值和aa的值相同但是间接级别不同，&aa的间接级别是 int (*)[2][5],&aa+1跳过整个数组，然后强制转换为int*类型它的间接级别又发生变化，加一减一只跳过一个元素也就是4个字节，赋给ptr1，ptr1-1,此时ptr1就指向a[1][5]这个元素，解引用后结果是10，再来看ptr2，aa表示第一行的地址，间接级别是int (*)[5],加一跳过一个一维数组的大小，aa+1就表示第二行的地址,解引用表示第二行的数组名，强制转换为int*类型后，赋给ptr2,间接级别也发生改变，加一减一只跳过一个元素也就是4个字节，ptr2-1指向第一行最后一个元素的初始位置，解引用后这个元素也就是5。

运行结果：

2.7 笔试题七

#include <stdio.h>
int main()
{
	char* a[] = { "work","at","alibaba" };
	char** pa = a;
	pa++;
	printf("%s\n", *pa);//at;
	return 0;
}

我们画图分析：

• 解引用后，传给%s的就是第二个字符串首字符的地址，所以从首字符开始打印第二个字符串遇到\0就停止。
  运行截图：
  

2.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);//POINT
printf("%s\n", *--*++cpp+3);//ER
printf("%s\n", *cpp[-2]+3);//ST
printf("%s\n", cpp[-1][-1]+1);//EW
return 0;

我们以画图形式给出解析：

运行结果：
`