指针面试真题讲解_char* p=“abcdef”,sizeof(p)

1.计算一维数组大小

在计算数组的大小之前我们要知道数组名代表什么。
一般情况数组名代表的是首元素地址，但是有两个例外：

 1：sizeof(数组名)- 数组名表示整个数组
 2：&数组名- 数组名表示整个数组
1
2

再就是要确定要求的是计算的是元素的大小，还是求地址的大小。

1.1整形数组

	  int a[] = { 1,2,3,4 };
	  printf("%d\n", sizeof(a));
      printf("%d\n", sizeof(a+0));
      printf("%d\n", sizeof(*a));
      printf("%d\n", sizeof(a+1));
      printf("%d\n", sizeof(a[1]));
      printf("%d\n", sizeof(&a));
      printf("%d\n", sizeof(*&a));
	  printf("%d\n", sizeof(&a+1));
	  printf("%d\n", sizeof(&a[0]));
	  printf("%d\n", sizeof(&a[0]+1));
1
2
3
4
5
6
7
8
9
10
11

认真思考一下。

答案如下：

	int a[] = { 1,2,3,4 };
	printf("%d\n", sizeof(a));//16 sizeof(数组名)-计算的是数组总大小-单位是字节
	printf("%d\n", sizeof(a+0));//4/8 这里a表示表示首元素地址 a+0 还是表示首元素地址 地址的大小就是4/8个字节
	printf("%d\n", sizeof(*a));//4 这里的a表示首元素地址 *a 解引用操作拿到第一个元素 数组的每个元素的类型是int int的大小是4个字节
	printf("%d\n", sizeof(a+1));//4/8 a表示首元素地址 a+1 表示第二个元素的地址 归根到底是一个地址 地址的大小就是4/8个字节
	printf("%d\n", sizeof(a[1]));//4 //计算第二个元素的大小。
	printf("%d\n", sizeof(&a));//4/8 &a表示整个元素的地址 但是整个元素的地址 还是个地址 而地址的大小就是4/8个字节
	printf("%d\n", sizeof(*&a));//16 &a表示整个数组的地址 *&a 解引用就拿到整个数组的元素 4*4=16
	printf("%d\n", sizeof(&a+1));//4/8 &a是数组的地址，&a+1虽然地址跳过整个数组，但还是地址，所以是4/8个字节
	printf("%d\n", sizeof(&a[0]));//4/8 第一个元素的地址
	printf("%d\n", sizeof(&a[0]+1));//4/8 第二个元素的地址
1
2
3
4
5
6
7
8
9
10
11

1.2字符数组

1.2.1sizeof类型的

• 1：

	char arr[] = { 'a','b','c','d','e','f' };
	printf("%d\n", sizeof(arr));
	printf("%d\n", sizeof(arr+0));
	printf("%d\n", sizeof(*arr));
	printf("%d\n", sizeof(arr[1]));
	printf("%d\n", sizeof(&arr));
	printf("%d\n", sizeof(&arr+1));
	printf("%d\n", sizeof(&arr[0])+1);
1
2
3
4
5
6
7
8

认真思考一下。

答案如下：

	char arr[] = { 'a','b','c','d','e','f' };
	printf("%d\n", sizeof(arr));//6
	printf("%d\n", sizeof(arr+0));//4/8 arr是首元素地址 arr+0还是首元素地址 地址的大小就是4/8个字节
	printf("%d\n", sizeof(*arr));//1 arr是首元素地址 *arr是首元素 首元素的字符大小是一个字节
	printf("%d\n", sizeof(arr[1]));//1 
	printf("%d\n", sizeof(&arr));//4/8  &arr表示整个元素的地址 但是整个元素的地址 还是个地址 而地址的大小就是4/8个字节
	printf("%d\n", sizeof(&arr+1));//4/8  &arr是数组的地址，&arr+1虽然地址跳过整个数组，但还是地址，所以是4/8个字节
	printf("%d\n", sizeof(&arr[0])+1);//4/8 第二个元素的地址
1
2
3
4
5
6
7
8

• 2：

	char arr[] = "abcdef";
	printf("%d\n", sizeof(arr));
	printf("%d\n", sizeof(arr+0));
	printf("%d\n", sizeof(*arr));
	printf("%d\n", sizeof(arr[1]));
	printf("%d\n", sizeof(&arr));
	printf("%d\n", sizeof(&arr+1));
	printf("%d\n", sizeof(&arr[0]+1));
1
2
3
4
5
6
7
8

认真思考一下。

答案如下：

	char arr[] = "abcdef";
	printf("%d\n", sizeof(arr));//7// sizeof(数组名)-计算的是数组总大小-单位是字节
	printf("%d\n", sizeof(arr+0));//4/8 这里arr表示表示首元素地址 arr+0 还是表示首元素地址 地址的大小就是4/8个字节
	printf("%d\n", sizeof(*arr));//1 这里的arrr表示首元素地址 *arr 解引用操作拿到第一个元素 数组的每个元素的类型是charr,char的大小是1个字节。
	printf("%d\n", sizeof(arr[1]));//1拿到的是第一个元素，元素类型是char。
	printf("%d\n", sizeof(&arr));//4/8 &arr表示整个元素的地址,但是整个元素的地址还是个地址,而地址的大小就是4/8个字节
	printf("%d\n", sizeof(&arr+1));//4/8 &ar是数组的地址，&arrr+1虽然地址跳过整个数组，但还是地址，所以是4/8个字节。
	printf("%d\n", sizeof(&arr[0]+1));//4/8 //拿到的是第二个元素的地址
1
2
3
4
5
6
7
8

• 3：

	char* p = "abcdef";
	printf("%d\n", sizeof(p));
	printf("%d\n", sizeof(p+1));
	printf("%d\n", sizeof(*p));
	printf("%d\n", sizeof(p[0]));
	printf("%d\n", sizeof(&p));
	printf("%d\n", sizeof(&p+1));
	printf("%d\n", sizeof(&p[0]+1));
1
2
3
4
5
6
7
8

认真思考一下。
提示：char* p = “abcdef”，这种写法是把常量字符串（内容不能改）放到p里面去了，p存放的其实是a的地址。

答案如下：

	char* p = "abcdef";
	printf("%d\n", sizeof(p));//4/8 计算指针变量p的大小
	printf("%d\n", sizeof(p+1));//4/8 p+1 得到的是字符b的地址，地址的大小就是4/8个字节。
	printf("%d\n", sizeof(*p));//1 *p 就是字符串的第一个字符'a'
	printf("%d\n", sizeof(p[0]));//1 int arr[10]: arr[0]==*(arr+0)    p[0]==*(p+0)=='a'，和上面的一个其实是一样的。
	printf("%d\n", sizeof(&p));//4/8 拿到的是p的地址
	printf("%d\n", sizeof(&p+1));//4/8 地址
	printf("%d\n", sizeof(&p[0]+1));//4/8 计算第二个元素的地址。
1
2
3
4
5
6
7
8

1.2.2strlen类型的

在这里我们对sizeof和strlen进行一个比较。
1：他们的性质不同。

sizeof是一个关键词，而strlen是一个函数，他的头文件是include<string.h>。
1

2：计算的对象不同：

sizeof的计算方式的是元素所占空间的大小，strlen函数是求字符串长度的，strlen（参数）参数部分
要求传的是地址。
1
2

3：计算方式不同：

sizeof计算大小的时候只计算你传过来的元素所占的空间大小，strlen是以你给的作为起始地址（注
意必须是地址）往后访问知道遇到'\0'停止，并且计算大小的时候不会把/0加上去。
1
2

• 1:

	char arr[] = { 'a','b','c','d','e','f' };
	printf("%d\n", strlen(arr));
	printf("%d\n", strlen(arr+0));
	printf("%d\n", strlen(*arr));
	printf("%d\n", strlen(arr[1]));
	printf("%d\n", strlen(&arr));
	printf("%d\n", strlen(&arr+1));
	printf("%d\n", strlen(&arr[0]+1));
1
2
3
4
5
6
7
8

认真思考一下。
这里提示一下，数组创建的时候以{ }包含起来的时候里面不包含’/0’。

答案如下：

	char arr[] = { 'a','b','c','d','e','f' };
	printf("%d\n", strlen(arr));//随机值
	printf("%d\n", strlen(arr+0));//随机值
	printf("%d\n", strlen(*arr));//错误//strlen（参数）参数部分要的是地址，而这里是传递的数组的第一个字符'a'，字符a的ASCLL码值是97
	// 这里就会把97当作是个地址，然后从97这个起始地址访问下去，这就是非法访问了
	printf("%d\n", strlen(arr[1]));//错误//同理
	printf("%d\n", strlen(&arr));//随机值//&arr是数组的地址 但是访问时还是从首地址开始访问，所以大小和前面两个一样
	printf("%d\n", strlen(&arr+1));//随机值//比前面三个值小6
	printf("%d\n", strlen(&arr[0]+1));//随机值，从第二个地址开始访问//比最前面三个小1
1
2
3
4
5
6
7
8
9

综上可得：因为数组里面不包含’/0’,而strlen函数计算的时候是一直计算到遇到’/0’后停止所以’/0’会在哪里出现四不知道的，所以计算的就是随机值了。

• 2：

	char arr[] = "abcdef";
	printf("%d\n", strlen(arr));
	printf("%d\n", strlen(arr + 0));
	printf("%d\n", strlen(*arr));
	printf("%d\n", strlen(arr[1]));
	printf("%d\n", strlen(&arr));
	printf("%d\n", strlen(&arr + 1));
	printf("%d\n", strlen(&arr[0] + 1));
1
2
3
4
5
6
7
8

认真思考一下。
这里提示一下，数组创建的时候以" "包含起来的时候里面不包含’/0’。
“abcdef”==abcdef /0

答案如下：

	char arr[] = "abcdef";
	printf("%d\n", strlen(arr));//6 这里arr是代表首元素地址，从首元素地址开始计算知道遇到/0停止，在这里数组创建的时候以" "包含起来的时候里面不包含'/0'，也就是说f后面其实还有个/0.
	printf("%d\n", strlen(arr + 0));//6 这里arr是代表首元素地址，arr==arrr+0，就和上面的一样的了。
	//printf("%d\n", strlen(*arr));//错误，因为strlen函数的参数要求传过来的是地址
	//printf("%d\n", strlen(arr[1]));//错误 同理strlen函数的参数要求传过来的是地址
	printf("%d\n", strlen(&arr));//6 这里&arr是代表真个数组的地址的，但是计算大小的时候还是从首元素地址开始的。
	printf("%d\n", strlen(&arr + 1));//随机值 这里&arr代表整个数组的地址，&arr+1是跳过一个数组，那既然跳过一个数组，那/0会在哪里出现也是随机的（未知的）。
	printf("%d\n", strlen(&arr[0] + 1));//5 这里拿到的是第二个元素的地址，也就是从第二个元素的地址开始计算大小。
1
2
3
4
5
6
7
8

• 3：

	char* p = "abcdef";
	printf("%d\n", strlen(p));
	printf("%d\n", strlen(p+1));
	printf("%d\n", strlen(*p));
	printf("%d\n", strlen(p[0]));
	printf("%d\n", strlen(&p));
	printf("%d\n", strlen(&p+1));
	printf("%d\n", strlen(&p[0]+1));
1
2
3
4
5
6
7
8

认真思考一下。
提示：char* p = “abcdef”，这种写法是把常量字符串（内容不能改）放到p里面去了，p存放的其实是a的地址。

答案如下：

	char* p = "abcdef";
	printf("%d\n", strlen(p));//6 p存放的是a的地址，从a的地址开始计算大小。
	printf("%d\n", strlen(p+1));//5 p是存放的a的地址，那p+1拿到的其实是第二个元素的地址，也就是b的地址。
	//printf("%d\n", strlen(*p));//错误，因为strlen函数的参数要求传过来的是地址
	//printf("%d\n", strlen(p[0]));//错误 同理strlen函数的参数要求传过来的是地址
	printf("%d\n", strlen(&p));//随机值 因为p存放的是a的地址，而&p就是存放的p的地址 而a的地址不知道是什么strlen函数要遇到'\0'才会停止
	//有可能a的地址是0x00122345也可能是0x12233445 遇到0的位置不确定 所以是随机值
	printf("%d\n", strlen(&p+1));//随机值 既然&p都不知道。那&p+1其实也是不知道的
	printf("%d\n", strlen(&p[0]+1));//5 这里拿到的人是第二个元素的地址。
1
2
3
4
5
6
7
8
9

2.二维数组

• 1：

	int a[3][4] = { 0 };
	printf("%d\n", sizeof(a));
	printf("%d\n", sizeof(a[0][0]));
	printf("%d\n", sizeof(a[0]));
	printf("%d\n", sizeof(a[0]+1));
	printf("%d\n", sizeof(*(a[0]+1)));
	printf("%d\n", sizeof(a+1));
	printf("%d\n", sizeof(*(a+1)));
	printf("%d\n", sizeof(&a[0]+1));
	printf("%d\n", sizeof(*(&a[0] + 1)));
	printf("%d\n", sizeof(*a));
	printf("%d\n", sizeof(a[3]));
1
2
3
4
5
6
7
8
9
10
11
12

认真思考一下。
提示：在我们之前的学习当中我们已经知道了二维数组的数组名代表的是什么了，仍然如果还有不知道的小伙伴可以前往我的资源库 详解之进阶指针里面进行学习。

答案如下：

	int a[3][4] = { 0 };
	printf("%d\n", sizeof(a));//48 sizeof(数组名)-计算的是数组总大小-单位是字节
	printf("%d\n", sizeof(a[0][0]));//4 第一个元素的大小。
	printf("%d\n", sizeof(a[0]));//16 a[0]相当于第一行作为一维数组的数组名
	//sizeof(arr[0])把数组名单独放在sizeof()内，计算的是第一行的大小
	printf("%d\n", sizeof(a[0]+1));//4/8 这里a[0]没有单独放在sizeof()内部也没有&，a[0]是第一行的数组名，a[0]此时是首元素地址，
	//a[0]+1其实就是第一行第一个元素的地址
	//所以a[0]+1指的就是第一行第二个元素的地址。
	//这里可以打印他们的地址对比一下
	//printf("%p\n", &a[0][0]);
	//printf("%p\n", a[0] + 1);
	//会发现他们的地址只相差4个字节，这就说明了a[0]+1就是第一行第二个元素的地址
	printf("%d\n", sizeof(*(a[0]+1)));//4 a[0]是第一行的数组名，数组名此时是首元素地址 *(a[0]+1) 就是第一行第二个元素
	printf("%d\n", sizeof(a+1));//4/8 a是二维数组的数组名，没有sizeof（数组名），也没有&（数组名），所以a是首元素地址
	//而把二维数组看成一维数组时，二维数组的首元素是它的第一行，a就是第一行（首元素）的地址
	//a+1就是第二行的地址
	//也可以打印地址验证一下
	//printf("%p\n",a+1);
	printf("%d\n", sizeof(*(a+1)));//16 *(a+1)==a[1] sizeof(a[1]) 就是第二行的大小
	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 sizeof(内部表达式)内部表达式不参与真实计算的，它只是根据它的类型来计算他的大小
	//a[3]也是一个数组名和a[0]类型相同，所以大小也相同。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

总结：

3.笔试题

• 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

认真思考一下。

第一个值：* (a+1)

这里a是数组名，这里没有&数组名和siziof（数组名）说明这里的数组名代表的是首元素地址，所以
a+1就是第二个元素的地址，在进行解引用操作就拿到了2。
1
2

第二个值：* (ptr - 1)

这里&a拿到了整个数组的地址，&a+1是跳过了一个数组，后强制类型转换成了int*类型并且赋值个了ptr（类型是int*），所以ptr+-整数访问的是4个字节，这里ptr-1说明后退了4个字节，数组类型是int也是4个字节，就说明是后退了一个元素，就找到了5。
1

接下来我们来看一张图：

这样答案就很清楚了。

所以答案是：

2，5
1

• 2:

struct Test
{
	int Num;
	char* pcName;
	short sDate;
	char cha[2];
	short sBa[4];
}*p;
//假设p 的值为0x100000 如下表达式的值分别是多少
//已知，结构体Text类型的变量大小是20个字节。
int main()
{
	p = (struct Test*)0x100000;
	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
18

提示：
这里考察了指针±整数的概念。

第一个：

这里p是一个是指针+ 0x1其实就是+1，而p的类型是结构体类型所以+1是跳过怎个结构体，这里又
是打印地址，而且打印地址是以16进制打印的，这里又告诉了我们结构体Text类型的变量大小是20
个字节，也就是说跳过了20个字节，换算成16进制也就是14，而开始的地址也告诉我们了是0x100000，所以只要加上14就行了。
1
2
3

第二个：

这里p本来是个指针的，但是这里强制类型转换成了(unsigned long)整形类型，那既然转换成了整型
类型的，那+-整数就是像我们正常生活中的+-整数一样，所以这里直接加上1就行，16进制的1也还
是1。
1
2
3

第三个：

这里p是一个结构体类型指针，但是这里强制类型转换成了(unsigned int*)无符号整形指针，也就是
说这里+-整数跳过的是一个整形指针的大小，也就是4个字节，那+1相当于跳过了4个字节，而4的
16进制也还是4。
1
2
3

所以最后答案：

0x00100014
0x00100001
0x00100004
1
2
3

• 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
9

第一个:

&a拿到整个数组的地址，&a+1是跳过整个数组，后又把此地址传给了ptr1，这和上面的笔试题1是
一样的道理。只不过我们得了解一下ptr[-1]是什么。
我们之前知道了arr[1]==*(arr+1)，这里其实是一样的，ptr[-1]==*(ptr+(-1))==*(ptr-1)==*(a-1)
1
2
3

第二个：

这里a数组名是首元素地址，这里把a强制类型传换成（int）整形，而转换成整形之后加1，就单单
是加1了，后又把加完后的值强制类型转换成了整形指针，最后进行解引用。
这里这里数组a在地址的排布时（小端）：01 00 00 00 02 00 00 00 03 00 00 00 04 00 00 00 这里
本来首元素地址是指向01+1后指向01的后面00打印时是ptr2是int*整形指针，整形指针解引用能访
问4个字节，所以解引用之后能访问的就是00 00 00 02 又因为打印时要以小端形式打印，最后就是
02 00 00 00=2000000
1
2
3
4
5
6

所以答案是：

4，2000000
1

• 4:

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

提示：这里要用到逗号表达式。
这里最最重要的是你要了解逗号表达式，这里和多人会误以为这个二维数组的排序是这样的：

0  1
2  3
4  5
1
2
3

其实不是这样的，这里其实{ (0,1),(2,3),(4,5) }=={ 1，3，5) };
他的排布是这样子的：

1  3
5  0
0  0
1
2
3

这样答案就很清楚了。
所以答案是：

1
1

• 5:

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

第一个：

这里int(*p)[4]是一个数组指针，前面我们也学习过来什么是数组指针。
这里a是一个5行5列的数组，现在&a[4][2]是很好找的，关键就是p怎么弄了，p是一个指针，指针指
向的数组有4个元素，每个元素的类型是int，那就说明当p+-整数的时候只能跳过4个字节，因为p是
一个指向整形数组的指针，而指向的这个整形数组的元素时4个，所以p+-整数跳过的时4个元素
1
2
3
4

现在我们知道他们的分布了，而指针-指针我们知道是可算得，结果就是-4。
1

第二个：

现在我们由第一个知道了他们的分布，这里要打印的是地址，其实就是-4的地址，内存是以原码存
储数据的，但是是以补码形式打印出来的，所以-4的16进制形式补码就是0xFF FF FF FC 。
1
2

所以答案是：

-4，0xFF FF FF FC 
1

• 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;
}
1
2
3
4
5
6
7
8

第一个:
和上面的1是相似的，&aa拿到整个数组的地址，+1跳过整个数组，后强制类型转换成int* 类型的，解引用操作-1后退一个地址位置，就找到了10。
第二个：

aa数组的分布：
1  2  3  4  5
6  7  8  9  10
这里aa是首元素地址，而二维数组的首元素地址是第一行，现在+1就是表示第二行地址，后强制类
型转换成int*类型并且存放到了ptr2（类型是int*）），解引用操作-1后退一个地址位置,就找到了5

10，5
1
2
3
4
5
6
7

• 7:

int main()
{
	char* a[] = { "work","at","alibaba" };
	char** pa = a;
	pa++;
	printf("%s", *pa);
	return 0;
}
1
2
3
4
5
6
7
8

所以答案是：

at
1

• 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

第一个：

这是c，cp，cpp的逻辑图。
**++cpp首先++所以地址平移了一位就指向了C+2的地址，后接应引用拿到了所指向的值，在解引用就找到了值。

这里要注意的时++会保留叠加

第二个：

首先cpp++，找到C+1所在的地址，后进行解引用拿到，里面的值，后又–操作，C+1-1后=C，这时对所指向的值再次解引用就找到了首元素地址后+3 找到对应的元素。

这里要注意的时++会保留叠加

第三个：
这里我们得转换一下 * cpp[-2]+3== *（ *（cpp-2))+3, 这里cpp-2就找到了C+3所指向的地址后进行解引用就拿到了值，拿到的值有指向c，后有进行解引用操作拿到最后值，再+3。

这里要注意的时++不会保留叠加

第四个：
这里也转换一下cpp[-1][-1] + 1== * ( * (cpp-1)-1)+1，这里cpp-1找到C+2所指向的地址，在进行解引用操作，得到里面的值后减1，再次解引用操作+1。

这里要注意的时++不会保留叠加

所以答案是：

POINT
ER
ST
EW
1
2
3
4

好了这就是全部了，如果你看到这里了，首先表达我的感谢，感谢你们的支持，再就是如果当中又讲的不好的，不清楚的，或者讲错的请大家多多指教。