1.数组和指针笔试题

题目1

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

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

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

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

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

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）