抽丝剥茧C语言（高阶）指针进阶练习

导语

这里我会把我见过的笔试题都和大家分享一下，并且讲解。
本章用的是32位平台。

试题部分

一

#include <stdio.h>
int main()
{
	char str1[] = "hello baiye.";
	char str2[] = "hello baiye.";
	const char* str3 = "hello baiye.";
	const char* str4 = "hello baiye.";
	if (str1 == str2)
		printf("str1 and str2 are same\n");
	else
		printf("str1 and str2 are not same\n");

	if (str3 == str4)
		printf("str3 and str4 are same\n");
	else
		printf("str3 and str4 are not same\n");

	return 0;
}

代码运行结果是：

这里str3和str4指向的是一个同一个常量字符串。C/C++会把常量字符串存储到单独的一个内存区域，当几个指针。指向同一个字符串的时候，他们实际会指向同一块内存。但是用相同的常量字符串去初始化不同的数组的时候就会开辟出不同的内存块。所以str1和str2不同，str3和str4不同。

二

#include <stdio.h>
int main()
{
	//一维数组
	int a[] = { 1,2,3,4 };
	printf("%d\n", sizeof(a));//数组名单独放在sizeof中是计算整个数组的长度
	printf("%d\n", sizeof(a + 0));//数组名不是单独放在sizeof内，也就等于首元素地址，加0等于没动，算的是首元素地址的长度（64位平台就是8个字节）
	printf("%d\n", sizeof(*a));//同上不是单独放在内部，解引用之后算的是第一个元素的长度
	printf("%d\n", sizeof(a + 1));
	printf("%d\n", sizeof(a[1]));
	printf("%d\n", sizeof(&a));//算的还是一个地址的长度，只要是地址，不是4就是8
	printf("%d\n", sizeof(*&a));//这个就等于取出数组的地址，然后又解引用等于是一个数组在sizeof的内部
	printf("%d\n", sizeof(&a + 1));//这个是跳过一数组，但要算的也是地址的长度
	printf("%d\n", sizeof(&a[0]));//取出的是数组下标为0元素的地址
	printf("%d\n", sizeof(&a[0] + 1));
	return 0;
}

代码运行结果：

三

#include <stdio.h>
#include <string.h>
int main()
{
	//字符数组
	char arr[] = { 'a','b','c','d','e','f' };
	printf("%d\n", sizeof(arr));
	printf("%d\n", sizeof(arr + 0));
	printf("%d\n", sizeof(*arr));//char类型的长度是一个字节
	printf("%d\n", sizeof(arr[1]));
	printf("%d\n", sizeof(&arr));
	printf("%d\n", sizeof(&arr + 1));
	printf("%d\n", sizeof(&arr[0] + 1));

	printf("%d\n", strlen(arr));//stelen是将你要计算的字符串的首地址传过去，因为读取到\0才会停止，这里我们是一个字符一个字符放进去的，所以是随机值
	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));
	return 0;
}

代码运行结果：

#include <stdio.h>
#include <string.h>
int main()
{
	char arr[] = "abcdef";
	printf("%d\n", sizeof(arr));//sizeof会把末尾的\0也算上
	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));
	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));
}

代码运行结果：

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

代码运行结果：

#include <stdio.h>
#include <string.h>
int main()
{
	//二维数组
	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));//一维数组的数组名不是单独放在sizeof内部，所以算的是一维数组的第二个元素地址的长度
	printf("%d\n", sizeof(*(a[0] + 1)));
	printf("%d\n", sizeof(a + 1));
	printf("%d\n", sizeof(*(a + 1)));//这个虽然是跳过一个二维数组之后才解引用，但是sizeof不会看里面有什么元素，所以数组越界了也没事，因为它已经知道了里面有4的整形元素
	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]));
	return 0;
}

代码运行结果：

四

1.

#include <stdio.h>
struct Test
{
	int Num;
	char* pcName;
	short sDate;
	char cha[2];
	short sBa[4];
}*p;
//假设p 的值为0x100000。 如下表表达式的值分别为多少？
//已知，结构体Test类型的变量大小是20个字节
int main()
{
	printf("%p\n", p + 0x1);//这里加的是结构体类型的指针大小20，但是因为要转换为16进制所以是加14
	printf("%p\n", (unsigned long)p + 0x1);//将地址强制类型转换为十进制然后加1之后再转为十六进制（这次算的就是整形的加法了）
	printf("%p\n", (unsigned int*)p + 0x1);//这里是转换为整形指针，加1等于跳过一个整形的长度也就等于加4
	return 0;
}

代码结果：

2.

#include <stdio.h>
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; 
}

大家想必对ptr2非常的疑惑；
因为数组名（首元素地址）被强制类型转换为int，也就是变成了整数之后加一，也就等于我们原来的地址跳过了一个字节。
我的计算机是小端储存方式

因为是倒着存进去(高位放到高地址，低位放到低地址)，那么也要把00 00 00 02倒着拿出来，所以就有了上面的结果。
3.

#include <stdio.h>
int main()
{
	int a[3][2] = { (0, 1), (2, 3), (4, 5) };//注意，里面是圆括号
	int* p;
	p = a[0];
	printf("%d", p[0]);
	return 0;
}

运行结果：

4.

#include <stdio.h>
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;
}

运行结果如下：

指针相减算的是中间元素的个数。

p[4][2]可以看成（*（*p+4）+2）
第二个结果因为是低地址减高地址，所以是-4
第一个结果是因为用%p打印，所以把-4的补码给换算成了16进制，就变成了FFFFFFC
5.

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

运行结果：

6.

#include <stdio.h>
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;
}

运行结果：

这道题一开始是这个样子的

charc储存的是各个字符串的首字母地址，char**cp指向的是charc的地址，char*cpp指向的是charcp的地址。
第一个，因为++cpp所以移动到了这里

两次解引用之后就得到了POINT。
第二个又要++cpp再解引用，然后又要减减再解引用，最后再加三

我们发现，cp中的第三个元素从c+1变成了c，因为是- -运算符和++一样有永久性，不像c+1-1没有赋值给自己一样。至于为什么红色箭头指向了E，是因为后面的加三让指向这个字符串的首字母向后移动了三个字符的距离。
第三个找的是cp中的-2位置，因为前两个++导致我们找到了c+3那个位置（蓝色箭头表示）

注意，这次的cpp是临时移动而已，找到cpp[-2]的位置之后会回到原位。后面解引用之后又加了一个3就是同上，打印的就是ST。
最后第四个也就容易理解了，先找到cpp[-1]的位置，然后找到了c+2，c+2指向的位置是POINT这个字符串，因为又要找cp[-1]的位置所以又到了NEW的位置，又因为最后的+1所以变成了EW。

总结

1.数组名的意义:

sizeof(数组名)，这里的数组名表示整个数组，计算的是整个数组的大小。
&数组名，这里的数组名表示整个数组，取出的是整个数组的地址。
除此之外所有的数组名都表示首元素的地址。

2.cpp[-2][1]这样的代码可以转换为（*（*cpp-2）+1）