指针习题组：

01：

int main()
{
    int a[5] = { 1, 2, 3, 4, 5 };
    int *ptr = (int *)(&a + 1);
    printf( "%d,%d", *(a + 1), *(ptr - 1));
    return 0;
}

运行结果：

原因：这里a是数组名，存放的是数组的首地址，&a是整个数组的地址，+1操作跳过了整个数组，所以ptr的指向如图所示，ptr被强制类型转换之前的类型是：int(*)[5];是数组指针，现在被强制转化成了 int*类型，所以进行加减操作时，跳过的是整型的大小了，解引用操作也是向后访问一个整型的大小。第5行中的a是数组首元素的地址，也就是int*类型的地址，+1操作会跳过一个整型。

指向如图所示，再解引用操作，最终的得到了2和5.

02：

这里告知结构体的大小是20个字节

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);//0x100014
    printf("%p\n", (unsigned long)p + 0x1);//0x100001
    printf("%p\n", (unsigned int*)p + 0x1);//0x100004
    return 0;
}

原因：p是结构体指针变量，由于结构体的大小是20个字节，所以对p进行加减操作时，会跳过20个字节。代码第14行，就会加上20，转化成16进制就是加上14。当p被转化成 unsigned long类型时，进行加减操作时会发生代数上的简单的加减，所以代码第15行只是单纯的加上1。当p被转化为 unsigned in*类型时，进行加减操作时跳过4个字节，所以代码第16行的运行结果就是0x100004。

03:

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);//4 33554432
    return 0;
}

此时的ptr1和ptr2都是int*类型的变量，访问时会访问一个整型的大小。

04：

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

原因：注意初始化数组时，括号里的是逗号表达式，所以数组中存储的是：135000 ，p指针变量等同于第一个一维数组的数组名，p[0]等同于a[0][0]，结果为1.

05：

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

运行结果：

原因分析：由于p的类型是; int(*)[4];所以p在进行加减操作时，跳过的是4个元素，而a的类型是 int(*)[5];所以a进行加减操作时，跳过的是5个元素，由图可知，p[4][2]和a[4][2]之间相差了4个元素，由于p处于低地址，所以得到的答案是-4，又因为地址就是内存中实际存储的补码，所以-4以%p打印出来时，-4将会被看作无符号数进行打印，因为在内存中地址是没有正负之分的。所以打印结果就是 FFFFFFFFFFFFFFFC。

06：

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和ptr2的指向如图所示，但由于他们都是int*类型的指针，所以进行加减操作时，会跳过一个整型，打印结果就是5和10了。

07：

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

运行结果：

原因分析：pa的指向如图所示，pa中存储的是数组首元素的地址，这里的a数组中存放的三个字符串的首字符的地址，所以每个元素都是char*类型的。pa的类型是char**类型的，所以pa在进行加减操作时会跳过一个char*类型。pa++之后就指向的数组中的第二个元素，*pa就是第二个字符串首元素的地址。所以打印出了 at。

08：

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语句之前，数据关系如图所示。++cpp之后，cpp就指向cp中的c+2了，**++cpp就拿到了 POINT 这个字符串的首字符的地址，打印出POINT。
• 接着，cpp再次进行++操作，此时cpp则指向了cp中的c+1了，*++cpp的类型是char**类型，进行–操作时，会向后跳过一个char*类型的数据，指向ENTER这个字符串，在进行解引用操作，此时类型就成了char*类型，再进行+3操作，就跳过了三个字符，此时则指向了ENTER这个字符串中的第三个字符，结果打印出ER。
• cpp[-2]又指向的cp中的c+3了。*cpp[2]的类型是char*类型，再进行+3操作会跳过三个字符，此时就指向了FIRST这个字符串中的第三个字符，打印出ST。
• cpp[-1]指向的是cp中的c+2， cpp[-1][-1]的类型为char* 类型，指向的是c中的NEW这个字符串，+1操作，指向NEW中的第二个字符，打印出EW。

这道题特别要注意的点是，cpp在前两次的++过程中，相应的cpp的指向是会被改变的，但是后面cpp[-1]这种操作，并不会改变cpp的指向。

完结

本章的内容就到这里啦，若有不足，欢迎评论区指正，下期见！