// 建议先观看上文《C语言 指针（从入门到入土）》
目录
巩固基础
数组名是元素的首地址，但是有两个例外：
| 1. sizeof(数组名)，这里的数组名是表示整个数组的，计算的是整个数组的大小，单位是字节。 |
| 2. &数组名，这里的数组名也表示整个数组，取出的是数组的地址 |
| （除上面2中特殊情况外，所有的数组名都是数组首元素的地址） |
sizeof只关注占用空间的大小，单位是字节
sizeof不关注类型
sizeof是操作符
?
strlen关注的字符串中\0的为止，计算的是\0之前出现了多少个字符
strlen指针对字符串
strlen是库函数?
- 指针的大小是固定的4/8个字节（32位平台/64位平台）
//魔鬼细节：答案由vs2019和dev两个不同编译器得出（有的题目在不同编译器和不同电脑结果不同！！）?
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));
解析：?
#include<stdio.h>
int main()
{
int a[] = { 1,2,3,4 };
printf("%d\n", sizeof(a));//数组名a单独放在sizeof内部，计算的整个数组的大小，单位是字节，4*4 = 16
printf("%d\n", sizeof(a + 0));//a表示的首元素的地址，a+0还是数组首元素的地址，是地址大小4/8
printf("%d\n", sizeof(*a));//a表示的首元素的地址,*a就是对首元素的地址的解引用，就是首元素，大小是4个字节
printf("%d\n", sizeof(a + 1));//a表示的首元素的地址，a+1是第二个元素的地址，是地址，大小就4/8个字节
printf("%d\n", sizeof(a[1]));//a[1]是数组的第二个元素，大小是4个字节
printf("%d\n", sizeof(&a)); //&a 表示是数组的地址，数组的地址也是地址，地址大小就是4/8字节
printf("%d\n", sizeof(*&a));//可以理解为*和&抵消效果，*&a相当于a,sizeof(a)是16
//&a -> int(*)[4]
//&a是数组的地址，它的类型是int(*)[4]数组指针，如果解引用，访问的就是4个int的数组，大小是16个字节
printf("%d\n", sizeof(&a + 1));//&a是数组的地址，&a+1 跳过整个数组后的地址，是地址就是4/8
printf("%d\n", sizeof(&a[0]));//&a[0]取出数组第一个元素的地址，是地址就是4/8
printf("%d\n", sizeof(&a[0] + 1));//&a[0]+1就是第二个元素的地址,是地址大小就是4/8个字节
//&a[0] -> int* , int*+1跳过一个整形
return 0;
}?答案是（我的电脑是64位平台）
?2、字符数组
char a[] = {'a','b','c','d','e','f'};
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));
printf("%d\n",sizeof(&a+1));
printf("%d\n",sizeof(&a[0]+1));
char a[] = {'a','b','c','d','e','f'};
printf("%d\n",strlen(a));
printf("%d\n",strlen(a+0));
printf("%d\n",strlen(*a));
printf("%d\n",strlen(a[1]));
printf("%d\n",strlen(&a));
printf("%d\n",strlen(&a+1));
printf("%d\n",strlen(&a[0]+1));
?解析1：
#include <string.h>
#include<stdio.h>
int main()
{
//字符数组
char arr[] = { 'a','b','c','d','e','f' };
printf("%d\n", sizeof(arr));//arr作为数组名单独放在sizeof内部，计算的整个数组的大小，单位是字节，6
printf("%d\n", sizeof(arr + 0));//arr就是首元素的地址，arr+0还是首元素的地址，地址大小就是4/8
printf("%d\n", sizeof(*arr));//arr就是首元素的地址，*arr就是首元素，是一个字符，大小是一个字节，1
printf("%d\n", sizeof(arr[1]));//arr[1]就是数组的第二个元素，是一个字符，大小是1个字节
printf("%d\n", sizeof(&arr));//&arr取出的是数组的地址，数组的地址也是地址，地址就是4/8个字节
printf("%d\n", sizeof(&arr + 1));//&arr取出的是数组的地址，&arr+1，跳过了整个数组，&arr+1还是地址，地址就是4/8个字节
printf("%d\n", sizeof(&arr[0] + 1));//&arr[0]是第一个元素的地址，&arr[0]+1就是第二个元素的地址，地址就是4/8个字节
return 0;
}答案：
?解析2：
#include <stdio.h>
#include <string.h>
int main()
{
//字符数组
char arr[] = { 'a','b','c','d','e','f' };
printf("%d\n", strlen(arr));//arr是首元素的地址，但是arr数组中没有\0，计算的时候就不知道什么时候停止，结果是：随机值
printf("%d\n", strlen(arr + 0));//arr是首元素的地址，arr+0还是首元素的地址，结果是：随机值
printf("%d\n", strlen(*arr)); //err,strlen需要的是一个地址，从这个地址开始向后找字符,直到\0，统计字符的个数。
//但是*arr是数组的首元素，也就是'a',这是传给strlen的就是'a'的ascii码值97，strlen函数会把97作为起始地址，统计字符串，会形成内存访问冲突
printf("%d\n", strlen(arr[1]));//err 和上一个一样，内存访问冲突
printf("%d\n", strlen(&arr));//&arr是arr数组的地址，虽然类型和strlen的参数类型有所差异，但是传参过去后，还是从第一个字符的
//位置向后数字符，结果还是随机值。
printf("%d\n", strlen(&arr + 1));//随机值
printf("%d\n", strlen(&arr[0] + 1));//随机值
return 0;
}?答案见解析；
3、字符串
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));
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：
#include <stdio.h>
#include <string.h>
int main()
{
char arr[] = "abcdef";
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));//从‘\0’后一个元素开始数 随机值
printf("%d\n", strlen(&arr[0] + 1));从第二个元素开始数
return 0;
}
答案 ：
?解析2：
#include <stdio.h>
#include <string.h>
int main()
{
char arr[] = "abcdef";
printf("%d\n", sizeof(arr));//字符串+\0 7
printf("%d\n", sizeof(arr + 0));//首元素地址 4/8
printf("%d\n", sizeof(*arr));//首元素'a'
printf("%d\n", sizeof(arr[1]));//元素'b'
printf("%d\n", sizeof(&arr));//首元素地址 4/8
printf("%d\n", sizeof(&arr + 1));//'\0'后的地址 4/8
printf("%d\n", sizeof(&arr[0] + 1));//'b'地址 4/8
return 0;
}答案：
换一种写法：
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));
解析3：
#include <stdio.h>
#include <string.h>
int main()
{
char* p = "abcdef";
printf("%d\n", strlen(p));//p中存放的是'a'的地址，strlen(p)就是从'a'的位置向后求字符串的长度，长度是6
printf("%d\n", strlen(p + 1));//p+1是'b'的地址，从b的位置开始求字符串长度是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));//p[0] -> *(p+0) -> *p ->'a' ,&p[0]就是首字符的地址，&p[0]+1就是第二个字符的地址
//从第2 字符的位置向后数字符串，长度是5
printf("%d\n", sizeof(p)); //p是一个指针变量，sizeof(p)计算的就是指针变量的大小，4 / 8个字节
printf("%d\n", sizeof(p + 1));//p是指针变量，是存放地址的，p+1也是地址，地址大小就是4/8字节
printf("%d\n", sizeof(*p));//*p访问的是1个字节
printf("%d\n", sizeof(p[0]));//p[0]--> *(p+0) -> *p 1个字节
printf("%d\n", sizeof(&p));//&p也是地址，是地址就是4/8字节，&p是二级指针
printf("%d\n", sizeof(&p + 1)); //&p是地址， + 1后还是地址，是地址就是4 / 8字节
//&p + 1,是p的地址+1，在内存中跳过p变量后的地址
printf("%d\n", sizeof(&p[0] + 1));//p[0]就是a，&p[0]就是a的地址，&p[0]+1就是b的地址，是地址就是4/8字节
return 0;
}?答案见解析；
4、二维数组
int a[3][4] = {0};
1printf("%d\n",sizeof(a));
2printf("%d\n",sizeof(a[0][0]));
3printf("%d\n",sizeof(a[0]));
4printf("%d\n",sizeof(a[0]+1));
5printf("%d\n",sizeof(*a[0]+1));
6printf("%d\n",sizeof(a+1));
7printf("%d\n",sizeof(*(a+1)));
8printf("%d\n",sizeof(&a[0]+1));
9printf("%d\n",sizeof(*(&a[0]+1)));
10printf("%d\n",sizeof(*a));
11printf("%d\n",sizeof(a[3]));
解析：
1.数组名单独放在sizeof内部,计算的是整个数组的大小，12*4=48
2.首元素，4
3.a[0]表示第一行的数组名 ，a[0]作为数组名单独放在sizesr内部 ，计算的是整行数组的大小 ，? ? 4 *?4 = 16
4.a[0]作为第一行的数组名，没有&，没有单独放在sizeof内部，所以a[0]表示的就是首元素的地址，即a[0][0]的地址，a[0]+1就是第一行第二个元素的地址。是地址就4/8
5.第一行第二个元素 4
6.a是二维数组的数组名，没有&，没有单独放在sizeof内部，a表示首元素的地址，即第一行的地址a+1就是第二行地址,是类型为int(*)[4]的数组指针。是地址就是4/8字节
7.*(a+1)就是第二行，相当于第二行的数组名，*(a+1) ->??a[1] ，sizeof (*(a+1))计算的是第二行的大小，16字节
8.*(&a[0]+1)就相当于第二行，也就是a[1]，sizeof(a[1]),大小是16字节
9.a二维数组的数组名，没有&，没有单独放在sizeof内部，a表示首元素的地址，*a就是二维数组的首元素,也就是第一行。*a- > *(a+0) -> a[0]? ?16
10.感觉a[3]是越界了，但是没关系 ，因为sizeof并不会访问，而会自动推导出类型为int [4]? ? 16
进阶提升
text1：
#include<stdio.h>
int main()
{
int a[5] = { 1, 2, 3, 4, 5 };
int* ptr = (int*)(&a + 1);
printf("%d,%d", *(a + 1), *(ptr - 1));
return 0;
}
//程序的结果是什么？*(ptr - 1) ：
&a表示取出整个数组的地址，&a+1就跳过整个数组，&a的类型：int(*)[5]，&a+1的类型还是int(*)[5]，将&a+1强制类型转换为int*，赋给ptr,则ptr指向的就是&a+1的地址，ptr-1即为前一个元素的地址，再解引用*(ptr-1)拿到的就是5。
*(a + 1)：
a表示数组名为首元素1的地址，+1表示元素2的地址，再解引用*(a+1)就是2。
?
答案? 2,5
text2：
#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);
printf("%p\n", (unsigned long)p + 0x1);
printf("%p\n", (unsigned int*)p + 0x1);
printf("%x\n", p + 0x1);
printf("%x\n", (unsigned long)p + 0x1);
printf("%x\n", (unsigned int*)p + 0x1);
//%p以地址的形式打印，不省略0
//%x就是打印16进制，省略0
return 0;
}p+0x1:
整形指针（int*）+1跳过4个字节，字符指针（char*）+1跳过1个字节，结构体指针p+1应该跳过一个结构体大小，也就是20字节，20的16进制是0x000014，加完后是0x100014。
(unsigned long)p + 0x1：
p本来是个结构体指针，把p强转成unsigned long类型，就是将变成无符号整型，就不再是指针了，既然是无符号整型，那就当成一个数字，加1后就直接加就行了，即0x100001
(unsigned int*)p + 0x1：
p被强制类型转换成整型指针，整型指针+1跳过4个字节，加4即为0x100004
标准答案：
00100014
00100001
00100004
100014
100001
100004
答案：（这里没有假设p 的值为0x100000，p值为0x000000）
text3
#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;
}?ptr1[-1]：
&a取出的是数组的地址，&a+1跳过整个数组，将其强制类型转换为int*赋给ptr1，此时ptr1的地址就是&a+1，而ptr[-1]相当于*(ptr1-1）得到4
*ptr2：
数组名a表示首元素地址，将其强制类型转化为整型，就是一个值，加1就是加了1个字节，需要将内存化为以字节为单位的数据，元素1就是4个字节，如果是小端，假设a的地址0x10，转成10进制就是16，加1就是17，16进制为0x11，找到ptr2的地址了，再解引用就只需再往后访问4个字节即可，打印出来即为2000000
?答案,4,02000000
text4
#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;
}解析：
?
看到此图，我猜你直呼卧槽并且什么都会了
此题考到了逗号表达式，int a[3][2] = { (0, 1), (2, 3), (4, 5) };可以转化为int a[3][2] = { 1, 3, 5 };此数组为3行2列，a[0]是第一行的数组名，数组名表示首元素地址，a[0]代表第一行第一个元素的地址，也就是p指向的位置，p[0] = *(p+0) = *p，p解引用拿到的就是1。
?
?text5
#include<stdio.h>
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));
return 0;
}解析：
*(ptr1 - 1)：
&aa表示二维数组的地址，&aa+1表示跳过整个二维数组，强转成整型指针赋给ptr1，ptr1-1再解引用拿到的就是数字10。
*(ptr2 - 1)：
aa为数组名表示二维数组首元素第一行的地址，aa+1跳过第一行来到第二行，再解引用*(aa+1)拿到第二行数组名首元素地址，即元素6的地址，强转赋给ptr2，ptr2-1向前移动再解引用拿到的就是5。
答案：
text6
#include <stdio.h>
int main()
{
char* a[] = { "work","at","alibaba" };
char** pa = a;
pa++;
printf("%s\n", *pa);
return 0;
}题目分析：本题难度不大，只需找到指针pa初始指向的位置以及指针变量pa++以后所指向的字符串的首地址即可，如图所示：
pa的类型是char*，加1表示跳过了一个char*的元素，指向如图所示位置，再解引用*pa拿到a的地址，再%s向后访问到\0停止。即为at。
text7
#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;
}- **++cpp：
?++cpp跳过了一个char**元素的地址到如图所示位置，解引用*++cpp拿到了c+2这个元素，c+2又是c里第3个元素的地址，再解引用拿到了p的地址，以%s的形式打印直到\0为止，即POINT。
- *-- * ++cpp + 3：
++cpp再跳过一个char*的元素到图示位置，再解引用 * ++cpp拿到c+1，-- * ++cpp让c+1-1=c，此时c就是c数组名第一个元素地址，再解引用*-- * ++cpp拿到E的地址，再+3指向第二个E，再%s打印处ER。
- ?*cpp[-2] + 3：
??*cpp[-2]就是**(cpp-2)+3。cpp-2指向的位置如图所示，解引用*(cpp-2)拿到c+3，再解引用**(cpp-2)拿到F的地址，再+3指向S，再%s打印出ST。
- cpp[-1][-1] + 1：
?cpp[-1][-1] + 1就是*(*(cpp-1)-1)+1，cpp-1的位置如图，解引用拿到c+2，减1就是c+1，再解引用*(*(cpp-1)-1)拿到的就是N的地址，再加1指向E，%s打印出EW。
?答案:
?总结：这些道题考查了二维数组的访问、数组的存储、大端模式、小端模式、数组名与&数组名+1所代表的含义、操作符结束运算后变量是否发生改变以及指针的运算，画图更加便于理解数组与指针相结合的题目，希望大家可以加深理解。