如果您已经懂了指针与数组那就来看看，指导指导吧。那如果你还没那么清楚，你也来看看吧，希望对你有帮助。
在前面的学习，我们已经了解了数组名在大多数情况下表示的是数组首元素的地址，除了以下两种
1. &数组名得到的是整个数组的地址，数值上与首元素的地址相同， 但是意义却不同。
2. sizeof（数组名）中的数组名表示的是整个数组，计算的是整个数组的大小。
在解读以下题目时，首先就看是否满足这两个条件再进行判断
test.1 （整形数组）
#include<stdio.h>
#include<string.h>
int main()
{
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));
return 0;
}解析
sizeof(a)//数组名单独放在sizeof内部，表示整个数组大小 4*4
sizeof(a + 0)//后面+0，使得数组名没有单独，所以a就是首元素地址 4/8
sizeof(*a)//首元素地址解引用，表示首元素 4
sizeof(a + 1)//首元素地址+1表示第二个元素地址 4/8
sizeof(a[1])//第二个元素 4
sizeof(&a)//整个数组的地址 4/8
sizeof(*&a)// &a是整个数组的地址，*访问整个数组元素 16（这里*与& 的效果可以抵消）
sizeof(&a + 1)//整个数组的地址+1，跳过4个整型 4/8
sizeof(&a[0])//地址 4/8
sizeof(&a[0] + 1)//第二个元素的地址 4/8编译
text.2（字符数组一）
int main()
{
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));
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));
return 0;
}解析
strlen(arr)//计算\0之前的字符 随机数
strlen(arr + 0)//随机数
strlen(*arr)//arr是首元素地址，*arr就是arr[0]（一个字符，strlen接受的是地址）而你将数组首元
//素传（a）过去，编译器就会自动将a的ASCLL码值作为地址传过去导致非法访问
strlen(arr[1])// 非法访问
strlen(&arr)//&arr得到的是整个数组的地址，类型是char（*）[6]而strlen是
//size_t strlen( const char *string );所以传参时就强行转换了类型 随机数
strlen(&arr + 1)//&arr+1 跳过整个char[6]的字符型 随机数-6
strlen(&arr[0] + 1)//第二个元素的地址 随机值-1
sizeof(arr)//sizeof计算的是占用内存空间大小，不关心内存存放的到底是什么值 6
sizeof(arr + 0)//地址 4/8
sizeof(*arr)//arr[0] 1
sizeof(arr[1])// 1
sizeof(&arr)//地址 4/8
sizeof(&arr + 1)//地址 4/8
sizeof(&arr[0] + 1)//地址 4/8编译
test.2 (字符数组二)
int main()
{
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));
return 0;
}解析
这串字符串与上一个字符串的区别就是多了一个\0，分析方法与上面一样。
编译
test.2 (字符数组三)
int main()
{
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\n", strlen(&p[0] + 1));
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));
return 0;
}解析
这里的字符串是一个常量字符串，p存放的就是这个常量字符串的首字符地址。
strlen(p)// 6
strlen(p+1)// 5
strlen(*p)// *p就是字符a 非法访问
strlen(p[0])// 字符a 非法访问
strlen(&p)//指针变量p存放字符a的地址，&p就是存放字符a地址的地址 随机值
strlen(&p+1)//&p+1是在&p的基础上跳过一个指针类型（x64位机器8个字节） 随机值
//与上面的随机值不一定差值为8，取决于\0的位置
strlen(&p[0]+1)//p[0]可以看作 *(p+0) 5
sizeof(p)//p是字符a的地址 4/8
sizeof(p+1)//字符b的地址 4/8
sizeof(*p)//字符a 1
sizeof(p[0])//字符a 1
sizeof(&p)// 地址 4/8
sizeof(&p+1)//4/8
sizeof(&p[0]+1)//地址 4/8编译
test.3(二维数组)
int main()
{
int a[3][4] = { 1,2,3,4,5,6,7,8,9,10,11,12 };
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]));
return 0;
}解析
我们首先得了解二维数组，二维数组实际上是一维数组，在内存空间中是连续存放的，并不是以二维空间的形式存放在内存中。
而二维数组的每一行都可以看作一个一维数组的数组名，二维数组的数组名是首行元素的地址。
sizeof(a)//a是二维数组的数组名，单独放在sizeof内部 12*4
sizeof(a[0][0])//第一个元素 4
sizeof(a[0])//第一行元素的数组名，单独放在sizeof内部 4*4
sizeof(a[0] + 1)//第一行首元素的地址+1 就是第一行第二个元素的地址 4/8
sizeof(*(a[0] + 1))//第一行第二个元素 4
sizeof(a + 1)//首行元素的地址+1 第二行元素地址 4/8
sizeof(*(a + 1))//第二行元素地址解引用 4*4
sizeof(&a[0] + 1)//a[0]是第一行元素的数组名，取地址就是第一行地址，+1就是第二行地址 4/8
sizeof(*(&a[0] + 1))第二行地址解引用 4*4
sizeof(*a)//a是首行地址，解引用就是首行元素 4*4
sizeof(a[3])//第四行元素数组名，这不越界了吗？
sizeof(a[3])这看似就是数组越界，应该就会报错嘛，但对于sizeof操作符来说呢，它并不会执行（访问）括号内部的表达式，它只需要知道内部数据的类型就可以了。
这里的sizeof内部表达式就没有发生运算，所以只需要知道sizeof内部的数据类型就可以得出结果。
代码内部的主要原因还是因为我们写出的 test.c的源代码————>编码——————>链接——————>生成 test.exe可执行程序进行运行。而上面的表达式需要运算得生成生成 test.exe可执行程序进行运行。而sizeof这种计算结果根本不需要你的运算结果，在你编译的过程中就已经得到结果了。
任何一个值都有两个属性 1.值属性 2.类型属性
所以回到上面的题目 a[3]虽然越界，但是并未发生越界访问，只需要得到类型属性即可
编译
test.4(指针)
int main()
{
int a[5] = { 1, 2, 3, 4, 5 };
int* ptr = (int*)(&a + 1);
printf("%d,%d", *(a + 1), *(ptr - 1));
return 0;
}解析
int main()
{
int a[5] = { 1, 2, 3, 4, 5 };//整型数组存放五个元素
int* ptr = (int*)(&a + 1);//&a是整个数组的地址，+1跳过五个整型
printf("%d,%d", *(a + 1), *(ptr - 1));//a是首元素地址，ptr是整形指针-1是移一个整形
return 0;
}编译（结构体指针）
test.5
struct Test
{
int Num;
char* pcName;
short sDate;
char cha[2];
short sBa[4];
}* p;
//已知，结构体Test类型的变量大小是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;
}解析
struct Test
{
int Num;
char* pcName;
short sDate;
char cha[2];
short sBa[4];
}* p;
//已知，结构体Test类型的变量大小是32个字节
int main()
{
p = (struct Test*)0x100000;//将0x100000强行存放在指针p中
printf("%p\n", p + 0x1);//0x1就是十进制的1，p是结构体指针类型，＋1跳过一个结构体类型 32
printf("%p\n", (unsigned long)p + 0x1);//将p强转成无符号整型+1就是整数＋1（可不是整形指针）
printf("%p\n", (unsigned int*)p + 0x1);//将p强转成无符号整型指针类型，+1跳过一个整型
return 0;
}编译
十六进制的20就是十进制的32
test.5
#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;
}
解析
int a[4] = { 1, 2, 3, 4 };
int* ptr1 = (int*)(&a + 1);//&a实际是数组指针类型，强制转换成整形指针存储，&a是整个数组的地址，+1跳过整个数组
int* ptr2 = (int*)((int)a + 1);//将a（首元素地址）强制转换成整型，+1就是按照整数+1，所以就地址向后跳一个字节
printf("%x,%x", ptr1[-1], *ptr2);//%x打印十六进制数，*ptr2表示向后访四个字节编译
博主实在VS上的x86环境下编译的：
由于 *ptr2实际上是 0x02 00 00 00 以%x的形式打印出来，前面的0x0就省略了。
test.6
#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) };
//这个表示的是三行两列的二维数组，存放的是01 23 45吗？
//
//这可不能粗心大意哈，再仔细检查一下表达形式是否有问题。
//如果是是上面解释的不是这样嘛：{ {0, 1}, {2, 3}, {4, 5} }
//小括号不就成了逗号表达式嘛。存放 13 50 00编译
test.7
#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;
}解析
为了更好的通过图片展示出来，博主就将数组整成二维的形式，实际在内存中是按照顺序依次存放的。
//这里我们要知道 arr[i] = *(arr+i)
int a[5][5]; int (*p)[4];//创建数组指针p p = a;//p存放a（二位数组首行元素的地址），数组指针p存放的是数组（存四个整型） 而a数组的首行有五个整形，所以发生了强制性存储。p存的就是a首行的前四个元素的地址。 printf("%p,%d\n", &p[4][2] - &a[4][2], &p[4][2] - &a[4][2]); //&p[4][2]中的p[4][2]可看作 *( *(p+4)+2 ) 而p是数组指针，+1就跳过一个数组（四个整型） 再解引用就相当于一个一维数组的数组名，在此基础再+2就是跳过两个整型 // &p[4][2] - &a[4][2] 的整数结果就是 -4 //而以地址的形式就是：将-4看作是地址，而-4在内存中是 0xFF FF FF FC（补码的十六进制）
编译
test.8
int main()
{
char* a[] = { "work","at","alibaba" };
char** pa = a;
pa++;
printf("%s\n", *pa);
return 0;
}解析
//这里的字符指针数组存放的是每个单词的首元素地址。
//遇到了类似于这种答案有点模糊不定的题目时，画图分析是一个不错的选择。
编译
test.9
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;
}解析
先画出对应的分析图：
执行第一个printf：
printf("%s\n", **++cpp);//我们++先执行，而且极为关键的是++是赋值操作符
执行之后会改变cpp的值。
//cpp存放的是二级指针数组cp的首元素地址，++后就使cpp存放的是cp的第二个元素的地址
//第一次* 得到cp的第二个元素（c+2），
再次解引用就得到指针数组c的第三个元素（POINT的首元素地址）分析图指向发生改变
执行第二个printf：
printf("%s\n", *-- * ++cpp + 3);//单目操作符优先级高于双目操作符
//*与++ --的操作符结合方向从右往左
//++操作符，自加1，指向cp[2]的地址，解引用指向cp[2]的空间
//因为cp[2]指向c[1]的地址，再--操作符，自减1，使得cp[2]指向c[0]的地址
//再解引用操作执行c[0]（存放ENTER的首元素E的地址），+3指向ER
分析图指向发生改变
执行第三个printf：
printf("%s\n", *cpp[-2] + 3);//cpp[-2]等价于 *(cpp-2) 此时就指向cp[0]空间
（cpp自生没有发生改变）
//再次解引用就表示c[3]这块空间（指向FIRST中F的地址）
//+3操作执行S的地址分析图指向不变
执行第四个printf：
printf("%s\n", cpp[-1][-1] + 1);//代码可看作 *( *(cpp-1) -1) + 1
// *(cpp-1)表示的是：此时指向cp[1]这块空间，而cp[1]指向c[2]的地址
//再 -1操作表示指向c[1]的地址，再次解引用表示c[1]这块空间（NEW首元素地址）
// +1指向NEW中E的地址分析图指向不变
编译
