1.数组和指针笔试题
题目1
c
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 * ptr = (int * )(&a + 1);✍️.
&a------表示的是整个数组的地址，而在内存存储中，整个数组的地址其实是在首元素地址的前一个空间位置，所以&a所展示的位置如上图所示。✍️.
&a+1------在很多的数据类型中，+1表示的是加多少字节，字节数取决于类型数，而&a+1中的&a表示的是数组的地址，那么这就表示了加一个&a一样大小的字节数，然后抵达的地址。✍️.而这个地址也如图整个数组地址一样，处在下一个数组之前的空间位置，或者处在这个数组空间之后的一个空间位置。
✍️.
（int*）------&a+1表示的是数组的地址，而（int*）是进行强制类型转化，转化为int类型的指针地址
*(ptr - 1)✍️.如图，结合上一步的分析，
&a+1被强制类型转化为了int*类型的并赋予了同样类型的ptr✍️.
ptr的内部存放的是&a+1的地址，但是整个地址被转化为了int*类型✍️.进行
ptr-1后，这个-1的操作从数组数据类型变为了int类型的，因此-1减去的是四个字节，在int类型的数组中，四个字节表示一个元素，因此ptr-1便是如图中所示，移动到了数组的最后一个元素。✍️.所以
*（ptr-1）得到的结果是数组的最后一个元素 5
*(a + 1)✍️.
a------数组名，因为并不是在sizeof中，所以该处的a表示的是首元素的地址✍️.
a+1------在很多的数据类型中，+1表示的是加字节数，而加上的字节数取决于数据的类型，眼下的a表示的是首元素的地址，而首元素表示的是int类型，也因此+1表示的是加四个字节，也就从首元素地址变成了第二个元素的地址✍️.
*（a+1）------表示的就是第二个元素地址指向的元素，也就是第二个元素 2
结论：
1.&a+1 ------ &a 表示的是数组的地址，+1加的是这个数组的总字节数大小后，抵达的位置。
2.a+1 ------a表示的是首元素的地址，+1加的是同这个元素一样的字节数大小后，抵达的位置。
3.加上的字节大小，看数组的数据类型或者元素的数据类型。
题目2
c
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) };✍️.{ (0, 1), (2, 3), (4, 5) }内部并不是花括号括起来的，因此是逗号表达式！实际上{ }内只有三个元素。
✍️.
int a[3][2] = { (0, 1), (2, 3), (4, 5) };实际上是int a[3][2] = { 1，3，5 };而其余的未满的元素全是0✍️.所以，这个三行两列的矩阵应该是 第一行是 1 3 第二行是 5 0 第三行是0 0
p = a[0];✍️.
a[0]表达的是二维数组第一行的数组名，既然是数组名又不在sizeof内，那代表的就是首元素的地址，那就是a[0][0]的地址，也就是元素 1
p[0]✍️.
p[0]其实就是*（p+0）也就表示 元素 1✍️.因为
p = a[0] ；a[0]相当于数组名，而数组名[ ]的组合相当于是取数组中的某个元素的意思，所以p[0]相当于a[0] [0]其中的a[0]是数组名，所以取的是a[0]这个数组中下标位0的元素，a[0]表示的是第一行，所以取的是第一行中下标为0的元素。
题目3
c
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;
}图文解析：
int(*p)[4];✍️.定义了指针变量p是一个数组指针，且该数组指针指向的数组内具有四个元素。
✍️.当进行
p+1的时候，加上的就是四个元素的字节大小之和。
p = a;✍️.
a表示的是数组名，二维数组的数组名表示的是二维数组的第一行的地址，由于地址的特性，是处在数组元素之前的内存空间内。✍️.所以如上图所示
&p[4][2] - &a[4][2]；✍️.因为
p是一个int类型的指针数组，指针数组的跨度是4个元素，而p[4][2]相当于一个二维数组，取的是第四行下标为2的元素。✍️.
&a[4][2]取的就是a数组中第四行下标为2的元素的地址✍️.
&p[4][2]表示的就是p+4这一个跨度中，下标为2的元素地址和&a[4][2]相减，得到的是-4。
题目4
c
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;
}图文解析：
int *ptr1 = (int *)(&aa + 1);✍️.
&aa表示整个数组的地址，&aa+1表示越过了一个数组大小的地址位置，整个数组的地址在首元素地址之前的内存空间中，因此如上图所示。✍️.
（int*）是强制类型转化，将其转化为int类型的指针。
int *ptr2 = (int *)(*(aa + 1));✍️.
aa相当于首元素地址，在二维数组中首元素地址就是第一行的地址，而aa+1表示的就是第二行地址✍️.且
aa+1又可以转化为aa[1]表示数组名，表示的是第二行的数组名，那么可以表示第二行第一个元素的地址而就表示第二行第一个元素，此处的int强制类型转化是没有用的。
*(ptr1 - 1), *(ptr2 - 1)
*(ptr1 - 1)✍️.
*（ptr1-1）ptr因为是int类型的指针，且被传输了&aa+1的地址，那么ptr-1根据数据类型-1就是减去四个字节，所以根据上图所示，我们得知ptr-1就是指向整个数组的最后一个元素。✍️.
*（ptr-1）就是最后一个元素 10
*(ptr2 - 1)✍️,
ptr2-1就是第二行第一个元素减一，就是第一行最后一个元素，所以表示的就是元素5
结论：
在二维数组中，数组名+1 = 数组名[1] 即表示第二行的地址又表示了第二行第一个元素的地址。
题目5
c
int main()
{
char *a[] = {"work","at","alibaba"};
char**pa = a;
pa++;
printf("%s\n", *pa);
return 0;
}图文解析：
char *a[] = {"work","at","alibaba"};✍️.字符指针类型的数组，字符串传递地址时，是传递的首字符的地址。
char**pa = a;✍️.a是数组名，数组名就是首元素的地址，所以pa指向的就是首元素的地址，如上图所示。
pa++;✍️.pa++指向的是第二个元素的地址。
printf("%s\n", *pa);✍️.经历了
pa++后，pa指向的是字符指针数组的第二个元素，而在第二个元素中寄存的是字符串at的首字符地址，所以*pa也就是表示的是at的首字符a，但由于printf打印的是%s格式，%s是字符串格式，所以打印的是字符串at
题目6
c
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;
}图文解析：
char *c[] = {"ENTER","NEW","POINT","FIRST"};✍️.创建了一个字符指针数组，指针数组的内部存储的是各个字符串的首个字符的地址。
char**cp[] = {c+3,c+2,c+1,c};✍️.
cp是一个二级指针数组，数组的内部存储的是字符指针数组c的某些地址。✍️.
c+3------其中c是指针数组c的数组名，表示的是数组中首元素的地址，也便是c[0]的地址，而c+3表示的是往后加上三个元素的地址后抵达的位置，可以当作c[3]的地址。✍️.
c+2------同理，表示c[2]代表的元素地址✍️.
c+1------表示的是c[1]代表的元素地址✍️.
c------表示的是首元素地址
char***cpp = cp;✍️.
cpp是三级指针，cpp内存储的是cp的首元素地址。
printf("%s\n", **++cpp);✍️.
++使得cpp发生改变，原先的cpp内存储的是cp的首元素地址，在++后因为是指针数组，++表示的是向后加一个元素大小的地址，也就是第二个元素的地址。✍️.因此在
++后，这里的cpp存储的是cp1的第二个元素，c+2。✍️.于是乎就变成了
**（c+2），先解决第一个*，c+2在cp内，cp也是一个指针，所以c+2指向的是c中的第三个元素，POINT的首字符P的地址✍️.于是乎就变成了
*（P的首字符地址）✍️.最后在解除最后一个
*，且因为打印的格式是%s，所以打印除的结果是POINT
printf("%s\n", *--*++cpp+3)；✍️.按照优先级，先进行
++cpp运算，因为++是有累计性的，所以cpp此刻存储的是cp中第二个元素的地址，如上图所示，因此在进行++后，cpp指向（存储）的地址变成了cp的第三个元素地址，也就是c+1的地址，所以变成了*--*（&cp[2]）+3✍️.
(&cp[2])表示的是cp中第三个元素的地址，最后通过*得到了内部存储的元素c+1，所以现在的结果是*--（c+1）+3✍️.
*--（c+1）+3，在进行--，将c+1进行--得到的结果是c，于是变成了*（c）+3✍️.
c指向的内容是字符串ENTER的首字符E的地址，所以在*后得到的是'E'+3✍️.
'E'+3的E是字符类型，+3，相当于是加了三个字符类型的字节数大小，于是结果变成了ENTER中的第二个E✍️.最后打印的格式是
%s，所以打印的结果是ER
printf("%s\n", *cpp[-2]+3);✍️.由于
++是有累积性的，所以cpp中存储的地址是cp的第三个元素的地址✍️.
cpp[-2]，表示的是一个元素，根据*（数组名+ 0） =数组名[0]，数组名[0]也表示一个元素 ，而数组名又表示首元素地址，我们得到结论，*（数组名+0）=数组名[0] =*（ 首元素地址 +0）✍️.而
cpp是存储地址的指针，因此cpp[-2]我们可以得到，cpp现在所指向的地址-2之后得到的元素。✍️.
cpp当前的地址是经过了上一次的++累加后，变成了如上图所示，指向的是cp的第三个元素，所以在-2后得到的结果是指向了cp的第一个元素，而第一个元素的内容是c+3✍️.所以
cpp[-2]= c+3✍️.
*cpp[-2]+3 ------------> *（c+3）+3✍️.
c是一个数组名，表示的是数组首元素地址，而c+3根据数组名+n = &数组名[n]的原理，我们得到了c+3是表示首元素地址+3个元素的字节大小后后抵达的地址✍️.在
c中下标为3的元素是字符串FIRS的首字符地址，所以c+3表示的就是字符F的地址✍️.随后得到
*（c+3）+3------------>'F'+3✍️.因为
F是字符，且+3相当于是加上三个相同类型的字节数，又因为打印的各式是%s，所以得到的结果是ST
printf("%s\n", cpp[-1][-1]+1);✍️.
cpp内存储的依旧是cp中第三个元素的地址✍️.
cpp[-1][-1]并不是二维数组所表达的意思，根据数组名[n] = *（数组名+n）的原理，进行计算，可以先将cpp[-1]当作数组名，那么我们可以转化为*（cpp[-1] +（-1））✍️.而后，又将
cpp当作数组名进行运算，那么我们可以转化为*（*（cpp+（-1））+（-1））------>*(*(cpp-1)-1)✍️.而
cpp中存储的是cp中第三个元素的地址，在进行-1后cpp中存储的地址发生了改变，变成了cp中第二个元素的地址，也就是c+2整个元素所在的地址，而通过第一个*后得到的结果就是c+2✍️.所以式子变成了
*（c+2-1）✍️.内部运算，得到的结果是
*（c+1）✍️.最后整个式子是
*（c+1）+1，而c是数组名，表示的是数组c的首元素地址，于是c+1表示的就是第二个元素的地址，在通过*得到的就是数组c的第二个元素✍️.数组
c的第二个元素是字符串NEW的首字符地址，所以最后的+1就是首字符地址加一，通过同类型原理，得到的就是第二个字符的地址✍️.又因为打印的方式是
%s所以最后的结果是EW
结论：
✍️.*（数组名+ 0） =数组名[0]，这里的数组名表示的是首元素地址
✍️.数组名[n]表示的是在这个数组中，下标为n的元素的地址，也可以说为&数组名[n]
✍️.数组名[n][n]这个数组并不是二维数组时，可以得到数组名[n][n]= *（*（数组名+n）+n）