【C语言】一系列指针题，从内存、语法角度拨开指针和数组名之间的迷雾

前置知识

给不明白的大伙说下，下面题目中答案“4或8”的含义。指针也就是地址，在C语言中是同一个说法。地址由计算机地址线产生，32位机器使用32根地址线产生32位电信号（0或1），那么换算字节就是4个字节，64位平台机器同理就是8个字节，所以指针变量的大小取决于是32位机器还是64位机器。现在的机器都是64位，在IDE中既可以改成以32位机器运行，也可以改成以64位机器运行。

1. 数组名的含义。
2. 链接：数组名不是首元素地址的的2个例外。
3. sizeof关键字。
4. strlen()库函数作用、参数、返回值。
5. &关键字。
6. *指针解引用（间接访问）操作符。
7. 指针间的的+ -运算。
8. 字符串与’\0’。
9. 数组指针
   10.指针类型的作用

1、指针和数组之间

1.1一维数组

1.1.1 整型一维数组

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

逐个分析：

1. sizeof(数组名)，这时的数组名代表整个数组，对整个数组计算内存大小。
2. a + 0相当于&a[0]，是首元素的地址，等于sizeof(int*)。
3. *a相当于a[0]，等于sizeof(int)。
4. a + 1相当于&a[1]，等于sizeof(int*)。
5. a[1]相当于*(a + 1)，等于sizeof(int)。
6. &a中的a代表整个数组，取的是整个数组的地址，注意整个数组的地址那也是地址（实际上还是从首元素地址开始），等于sizeof(int*)，要与第1题区分。
7. 对整个数组解引用操作，或者这么理解：*和&抵消，*&a相当于只有a，代表整个数组。
8. &a + 1，实际上是指针跳过了整个数组，指向了数组最后一个元素后面的地址。&a是整个数组的地址，指针类型实际上是数组指针：int (*)[4]，那么指针的运算自然是跳过16个字节。不过不管咋样，取出的是地址那也还是地址，等于sizeof(int*)。
9. &a[0]相当于a + 0，等于sizeof(int*)。
10. &a[0] + 1相当于a + 1，等于sizeof(int*)。

---

1.1.2 字符型一维数组

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

逐个分析：

1. 整个数组占用的内存大小。
2. arr + 0相当于&arr[0]，等于sizeof(char*)。
3. *arr相当于arr[0]，等于sizeof(char)。
4. arr[1]相当于*(arr + 1)，等于sizeof(char)。
5. 整个数组的地址，也是地址，不存在哪个地址的内存大小更大或更小之说，等于sizeof(char*)。
6. 指针跳过了整个数组，指向了数组后面地址，那还是地址，等于sizeof(char*)。
7. &arr[0] + 1相当于arr + 1，第2个元素地址，等于sizeof(char*)。

---

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)); // 不确定的值 - 6
 printf("%d\n", strlen(&arr[0] + 1)); // 不确定的值 - 1

逐个分析：

1. arr为首元素地址，等于是从首元素地址开始计算长度。长度不为6的原因是数组中没有’\0’，那么就不知道’\0’（也就是0）在哪，只能往内存后面地址一直找到’\0’位置。
2. 同上。
3. strlen()函数的参数只能接收一个char类型数据的地址。这个是将字符a传入，等于是将a当做一个地址，也就是将97当做一个地址传入，这个地址程序是不能访问的。
4. 同上。
5. 整个数组的地址，数组的地址也是从首元素地址开始。
6. &arr + 1中的&arr是char (*)[6]类型的指针，通过指针的+ -运算跳过整个数组内存，再开始计算。
7. 从第2个元素地址开始计算。

---

char arr[] = "abcdef";
printf("%zd\n", sizeof(arr)); // 7
printf("%zd\n", sizeof(arr + 0)); // 4或8
printf("%zd\n", sizeof(*arr)); // 1
printf("%zd\n", sizeof(arr[1])); // 1
printf("%zd\n", sizeof(&arr)); // 4或8
printf("%zd\n", sizeof(&arr + 1)); // 4或8 
printf("%zd\n", sizeof(&arr[0] + 1)); // 4或8

逐个分析：

1. 计算整个数组的内存大小，'\0’自然也是数组元素，所以是7而不是6。
2. 首元素地址，等于sizeof(char*)。
3. 首元素，等于sizeof(char)。
4. 第2个元素，等于sizeof(char)。
5. 整个数组的地址也是地址，，等于sizeof(char*)。
6. 指向数组后面地址，还是地址，等于sizeof(char*)。
7. 第2个元素地址，等于sizeof(char*)。

---

char arr[] = "abcdef";
printf("%d\n", strlen(arr)); // 6
printf("%d\n", strlen(arr + 0)); // 6
printf("%d\n", strlen(*arr)); // 错误
printf("%d\n", strlen(arr[1])); // 错误
printf("%d\n", strlen(&arr)); // 6
printf("%d\n", strlen(&arr + 1)); // 不确定的值 - 7
printf("%d\n", strlen(&arr[0] + 1)); // 5

逐个分析：

1. 从首元素a的地址开始计算，6个字符后有’\0’。
2. 同上。
3. strlen()只能传入地址，strlen(‘a’)也就是strlen(97)，程序无法访问97的地址。
4. 同上。
5. 整个数组的地址也是从首元素地址开始。
6. 跳过整个数组再开始计算，直到找到’\0’。
7. 从第2个元素地址开始计算。

---

char* p = "abcdef";
printf("%zd\n", sizeof(p)); // 4或8
printf("%zd\n", sizeof(p + 1)); // 4或8
printf("%zd\n", sizeof(*p)); // 1
printf("%zd\n", sizeof(p[0])); // 1
printf("%zd\n", sizeof(&p)); // 4或8
printf("%zd\n", sizeof(&p + 1)); // 4或8
printf("%zd\n", sizeof(&p[0] + 1)); // 4或8

逐个分析：

1. 第1个字符a的地址，计算的是指针的大小，相当于sizeof(char*)。
2. 第2个字符b的地址。
3. *p等于*(p + 0)，或p[0]，计算的是字符a占用多少字节，相当于sizeof(char)。
4. 同上。
5. 取出的是的变量p的地址，也是地址，相当于sizeof(char*)。这里说的不是指针p指向的字符串"abcdef"的地址，也不是字符a的地址，就是p自身的地址。
6. 跳过1个指针类型大小，取出的是的变量p内存后面的地址，也就是从p变量第1个字节开始向后跳过4/8个字节的地址，那还是地址，等于sizeof(char*)。
7. 取出的是字符b的地址，相当于sizeof(char*)。

---

char* p = "abcdef";
printf("%d\n", strlen(p)); // 6
printf("%d\n", strlen(p + 1)); // 5
printf("%d\n", strlen(*p)); // 错误
printf("%d\n", strlen(p[0])); // 错误
printf("%d\n", strlen(&p)); // 不确定的值
printf("%d\n", strlen(&p + 1)); // 不确定的值 - 4或8
printf("%d\n", strlen(&p[0] + 1)); // 5

逐个分析：

1. 从字符a开始计算。
2. 从字符b开始计算。
3. *p等于p[0]，strlen(a)也等于strlen(97)，把97当做地址传入，然而程序无法访问97的地址。
4. 同上。
5. &p是将变量p的地址取出，不是取出指针变量指向的字符串"abcdef"的地址，也不是字符a的地址。它是不确定值的原因：变量p占4个或8个字节，从它的第一个字节开始算，并不能确定后面什么时候遇到0（也就是’\0’）。
6. 跳过指针p变量开始算，所以结果为不确定值减去4或8。
7. 从字符b开始计算。

1.2 二维数组

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

逐个分析：

1. 计算的是整个数组内存大小，3 * (4 * 4)。
2. 首元素，相当于*(a[0] + 0)。
3. 计算的是第一行大小，a[0]是a的首元素，相当于a + 0，同时a[0]也是一个一维数组，那么a[0]就是这个一维数组的数组名，这时就代表了整个数组，4 * 4，相当于是计算*(int (*)[4])，很显然这个数组指针能操作4个整型，16个字节大小。
4. 第一行第二个元素的地址，相当于&a[0][1]，并不是第二行的地址，因为这时的a[0]并不代表整个数组，而是第一行的首元素。
5. 第一行第二个元素，a[0][1]。
6. 第二行的大小，a + 1这时a代表首元素地址，首元素是一维数组，+1来到第二行。对一行数组解引用操作，很显然这个指针是能操作一个一维数组大小的，所以是4*4=16，相当于a[1]。
7. 第二行的地址，等于a + 1。
8. 第二行的大小，它是对第二行进行解引用操作，相当于*(a + 1)。
9. 第一行的大小，相当于a[0]，或*(a + 0)。
10. 这个或许很多人不明白是这回事，为啥会是16？ 首先要知道sizeof实际上只是计算类型大小，而变量的类型在编译阶段就已经确定了，sizeof(a[3])中的a[3]实际上并没有进行访问操作，a[3]在这里与sizeof(a[0])，a + 0，*a，a[1]，a[2]等无异。

1.3 总结

其实这些题做下来，会发现核心就是搞懂数组名是什么，写成指针形式是什么样的，那这些题就没啥问题了。

2.指针

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

---

struct Test
{
	int Num;
	char *pcName;
	short sDate;
	char cha[2];
	short sBa[4];
}*p;
int main()
{
	printf("%p\n", p + 0x1); // 00100014
	printf("%p\n", (unsigned long)p + 0x1); // 00100001
	printf("%p\n", (unsigned int*)p + 0x1); // 00100004
	return 0;
}

假设p 的值为0x100000。 如下表表达式的值分别为多少？已知，结构体Test类型的变量大小是20个字节（32位机器下：4 + 4 + 2 + 2 + 8）。

解析：首先要知道0x1，虽然是16进制数，但它还是1，说白了就是0x01。

1. p是一个结构体指针变量，指向的结构体已知是20个字节大小。+1实际上就是加了20个字节，0x100000 + 20可不敢写成0x100020，这是十六进制数形式的整数而不是十进制整数。另外%p的打印会将完整的地址打印出来，既然假设是32位平台，所以是高位补0补够4个字节。
2. 第二个实际上就是正常的十进制整数+1，把地址强转当成十进制整型来看待了。
3. p强转成u int类型指针 + 1，实际上就是+4，因为int能操作4个字节。

---

int main()
{
	int a[4] = { 1, 2, 3, 4 };
	int *ptr1 = (int *)(&a + 1); // 4
	int *ptr2 = (int *)((int)a + 1); // 2000000
	printf( "%x,%x", ptr1[-1], *ptr2);
return 0;
}

1. ptr[-1]等于*(ptr - 1)，找到4的起始位置，又机器以小端字节序存储（不清楚的看下文章：数据在内存中是以什么顺序存储的？），那么整数4在内存中是这么存储的（十六进制表示）：04 00 00 00，取出来也是倒着取，%x形式打印省略0。
2. a这里代表首元素地址，也就是1的起始地址（第一个字节位置），然而这里将a强转成了int类型的整数，也就是将地址看成一个int类型整数，+1操作那就是正常的+1，等于说ptr2指向的实际上是1的第二个字节位置。那这里当解引用时，int*类型操作4个字节，那么我们知道1是这么存储的：01 00 00 00，2是这么存储的：02 00 00 00，对ptr2解引用拿出的实际上是02 00 00 00（存储以小端字节序存储，读取时那么也要反过来还原），是一个比较大的数字。

---

#include 
int main()
{
	int a[3][2] = { (0, 1), (2, 3), (4, 5) };
	int *p;
	p = a[0];
	printf( "%d", p[0]); // 1
	return 0;
}

这道题其实有坑，要注意看数组初始化，其实里边用的是{}，而这里使用了()包含的逗号表达式，那么实际上a数组存储的元素是：1, 3, 5, 0, 0, 0。p指向a的首元素a[0]，它是一个一维数组，p[0] == a[0]，又数组名等于首元素地址，所以取出的是1。

---

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个整型元素的数组，所以p一次只能操作4个整型。指针-指针得到的结果为两个地址间的元素个数，这道题最难的是%p打印的结果下面逐步分析下过程：

1. 首先这里指针-指针得到的结果肯定是-4，那么它在内存中是这么存储的：11111111 11111111 11111111 11111100，不知道的请看文章：整数在内存的存储。
2. 然后%p按十六进制打印完整的地址，那么就是将-4的补码当做地址打印了：fffffffc。

---

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. &aa取出的是整个数组的地址；
2. aa + 1中的aa代表的是数组首元素地址，即a[1]，它是一个一维数组，实际为数组指针int (*)[5]，实际类型是int [5]。

---

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

1. 理解char* a[]，a先和[]结合是一个数组，然后每个元素都是char*类型的，存储的实际上是字符串首字符的地址。
2. 理解char** pa，*pa说明它是指针，char*说明指向的是char类型的指针，是一个二级指针，即指向指针的指针，而pa指向了a的首元素a[0]，刚好a的每个元素都是char类型。pa++跳过一个char指针，指向a[1]，这时pa则等于a[1]或*(a + 1)。

---

前方高能

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

1. **++cpp，这里先++再**，和优先级无关。++cpp找到cp[1]（cp[1]存储了c[2]的地址），一次*解引用操作找到c[2]，再一次*解引用操作找到POINT的起始位置（P）。
2. *- -*++cpp+3，此时cpp已经指向cp[1]。++cpp指向cp[2]（cp[2]存储了c[1]的地址），一次*解引用找到c[1]，再- -操作找到c[0]，再解引用找到ENTER的起始位置（E），+3找到ENTER中后面那个E。
3. *cpp[-2]+3，此时cpp已经指向cp[2]。cpp[-2]先执行，再*操作。cpp[-2]找到c[3]（cpp[-2]等于*(cpp - 2)），*cpp[-2]找到F（等于*(*(cpp - 2))）。
4. cpp[-1][-1]+1，此时cpp还是指向cp[2]，上一步操作并没有动cpp的指向。cpp[-1]找到c[2]（等于*(cpp - 1)找到cp[1]，*(*cpp - 1)找到c[2]），cpp[-1][-1]找到c[1]存储的地址（等于*(*(cpp - 1) - 1)）（c[1]存储的地址即"NEW"中N的地址，也是"NEW"的起始地址），+1找到E。