指针笔试题
笔试题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;
}
//程序的结果是什么？*(a + 1)等同于a[1]，第一个是2，a的类型是int [5]，&a的类型就是int(*)[5]，
是个数组指针。所以给int(*)[5]类型加一，相当于加了一个int [5]的长度。也就
是这个指针直接跳过了a全部的元素，直接指在了刚好越界的位置上，然后转换成了
int *后再减一，相当于从那个位置向前走了一个int，从刚好越界的位置回到了5的
址处，所以第二个是5
笔试题2
由于还没学习结构体，这里告知结构体的大小是20个字节
struct Test
{
int Num;
char *pcName;
short sDate;
char cha[2];
short sBa[4];
}*p;
//假设p 的值为0x100000。 如下表表达式的值分别为多少？
//已知，结构体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;
}本质上考察指针加1的知识点：
p = 0x100000
p + 0x1 为跳过一个结构体指针（20字节），所以为0x100014
(unsigned long)p + 0x1 为强制类型转换为整型（1048576），整型数字加1（1048577），写成16进制就是0x100001
(unsigned int*)p + 0x1 为强制类型转换为整型指针，加的就是一个指针的大小4/8,就是0x100004/8
而在X86环境下打印，地址是4个字节
答案就是：
0010014
0010001
0010004
笔试题3
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 ] == *(ptr1-1) 因为ptr1直接指在了刚好越界的位置上，然后转换成了
int *后再减一，相当于从那个位置向前走了一个int，从刚好越界的位置回到了4的
址处，所以是4(int)a + 1 假设a的首元素地址为0x0012ff40，将它强制转换成 int 整型，整型数字加1，就是0x0012ff41，相当于往后移了一个字节，再将它强制转换成 int* 指针类型，假设是小端存储，存储形式就是 01 00 00 00 02 00 00 00 03 00 00 00 04 00 00 00 ，而 *ptr2 解引用就是往后读取4个字节（因为是int *）大小（00 00 00 02）0x02000000，又因为是以%x形式打印，所以就是16进制。答案是2000000
笔试题4
#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;
}答案是1
注意：(0, 1), (2, 3), (4, 5)是逗号表达式，不是每一行数组的内容，因为二维数组每一行也是一个数组，所以也要用{ }，所以{ (0, 1), (2, 3), (4, 5) }表示的其实是{1,3,5}，因为a[0] 是第一行的数组名，就是数组第一行的首元素地址（即a[0][0]）,p[0] == *(p+0) == *p ，所以就是a[0][0]
笔试题5
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;
}注：指针 - 指针 结果是指针之间的元素个数
a表示二维数组首元素地址，也就是数组第一行的地址，p = a 相当于将int(*)[ 5 ]类型的指针赋给 int(*)[ 4 ]类型的指针，而p+1 == &p[ 1 ]跨过的是四个整型大小，a+1跨过的是5个整型大小，所以算出&p[4][2] - &a[4][2]为-4（相差4个整型大小），而前面是用%p打印，相当于把-4当作地址，-4在内存中是以补码的形式存储的，就是11111111 11111111 11111111 11111100,16进制就是0xff ff ff fc
所以答案是：0xff ff ff fc，-4
笔试题6
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;
}&aa + 1 是整个二维数组的地址+1，就是刚好越界的位置，再强制转换成int *，所以*(ptr1 - 1)就是往前移一个int大小，就是指向9，再解引用
*(aa + 1) == aa[ 1 ] 中aa是二维数组首元素的地址，就是第一行的地址，再加1就是第二行的地址，解引用就变成第二行第一个元素的地址，再强制转换成int *，所以*(ptr2 - 1)就是往前移一个int大小，就是指向5，再解引用
笔试题7
#include <stdio.h>
int main()
{
char *a[] = {"work","at","alibaba"};
char**pa = a;
pa++;
printf("%s\n", *pa);
return 0;
}char *a[] = {"work","at","alibaba"}是将"work","at","alibaba"三个字符串的首元素（w , a , a）的地址放入a数组里
char**pa = a;就是pa指针的地址指向a数组首元素的地址（w）
pa++;就是pa指针的地址指向a数组第二个元素的地址（a）
最后以%s打印，就是从a的地址开始打印字符串，结果就是at
笔试题8
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"};是将"ENTER","NEW","POINT","FIRST"四个字符串的首元素（E , N , P , F）的地址放入c数组里
char**cp[] = {c+3,c+2,c+1,c};cp数组每个元素是char**，那么就是四个指针分别指向c的首元素地址+3（c的首元素地址+3又指向F地址）,c的首元素地址+2（P）,c的首元素地址+1（N），c的首元素地址（E）
char***cpp = cp;cpp就是三级指针，指向cp的首元素地址
printf("%s\n", **++cpp);cpp变成指向cp第二个元素地址的地址（发生变化了），解引用一次就是cp第二个元素（指向P的地址的地址），再解引用一次就是P的地址，最后以%s打印，就是从P的地址开始打印字符串，结果就是POINT
printf("%s\n", *--*++cpp+3);++cpp使cpp变成指向cp第三个元素地址的地址（发生变化了），再解引用得到cp第三个元素（指向N的地址的地址），再进行--，就是cp第三个元素变成指向E的地址的地址（发生变化了），就是存储的从c+1变成c，再解引用得到E的地址，再+3得到第二个E的地址，最后以%s打印，就是从第二个E的地址开始打印字符串，结果就是ER
printf("%s\n", *cpp[-2]+3); *cpp[-2]+3 == **(cpp-2)+3，cpp现在是指向cp第三个元素地址的地址，-2变成指向cp首元素地址的地址，解引用得到c+3，再解引用得到F的地址，再+3得到S的地址，最后以%s打印，就是从S的地址开始打印字符串，结果就是ST
printf("%s\n", cpp[-1][-1]+1);cpp[-1][-1] == *(*(cpp-1)-1)，cpp现在是指向cp第三个元素地址的地址，-1变成指向cp第二个元素地址的地址，再解引用得到c+2，再-1得到c+1，再解引用得到N地址，再+1变成E的地址，最后以%s打印，就是从E的地址开始打印字符串，结果就是EW
