9.指针和数组笔试题解析
9.1一维数组
看下面一段代码，分析其打印结果：
#define _CRT_SECURE_NO_WARNINGS 1 #include<stdio.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; }
以上代码大家可以自行运行一下。这里我们只做分析。
在分析之前，再次强调一下对于数组名的理解：
数组名代表数组的首元素的地址。
但是有两个例外：
1.sizeof(数组名)，这里的数组名表示整个数组，计算的是整个数组的大小，单位是字节
2.&(数组名)，这里的数组名表示整个数组，取出的是整个数组的地址
下面我们就可以来分析一下代码了：
#define _CRT_SECURE_NO_WARNINGS 1 #include<stdio.h> int main() { //一维数组 int a[] = { 1,2,3,4 }; printf("%d\n", sizeof(a));//数组名单独放在sizeof中，计算的整个数组的大小，4*4=16个字节 printf("%d\n", sizeof(a + 0));//数组名a是数组首元素的地址，a+0还是首元素的地址，地址大小是4/8个字节 printf("%d\n", sizeof(*a));//*a就是数组首元素，大小是4个字节 printf("%d\n", sizeof(a + 1));//a是数组首元素地址，a+1是数组第二个元素地址，是地址，大小就是4/8个字节 printf("%d\n", sizeof(a[1]));//数组第二个元素，大小是4个字节 printf("%d\n", sizeof(&a));//&a取出整个数组的地址，它也是地址，是地址，大小就是4/8个字节 printf("%d\n", sizeof(*&a));//*&a --> a 计算的依旧是整个数组的大小，4*4=16 printf("%d\n", sizeof(&a + 1));//&a+1是跳过整个数组后的地址，是地址，大小就是4/8个字节 printf("%d\n", sizeof(&a[0]));//数组首元素的地址，大小是4/8个字节 printf("%d\n", sizeof(&a[0] + 1));//数组第二个元素的地址，大小是4/8个字节 return 0; }
注意其中 a+1和&a+1的区别：
a+1:a是数组名，数组名是数组首元素地址，a+1就是数组第二个元素的地址。
&a+1:&a取出的是整个数组的地址，所以&a+1是跳过整个数组之后的地址。
它们在内存中的关系如下图：
9.2字符数组
看下面一段代码：
#define _CRT_SECURE_NO_WARNINGS 1 #include<stdio.h> int main() { //字符数组 char arr[] = { 'a','b','c','d','e','f' }; 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; }
分析之前首先要知道数组arr中存储的数据是什么：
这段代码和上文中一维数组类似，只不过int型数据是4个字节，char型数据是1个字节：
#define _CRT_SECURE_NO_WARNINGS 1 #include<stdio.h> int main() { //字符数组 char arr[] = { 'a','b','c','d','e','f' }; printf("%d\n", sizeof(arr));//1*6=6 printf("%d\n", sizeof(arr + 0));//arr是数组首元素地址，arr+0还是首元素地址，是地址，大小就是4/8个字节 printf("%d\n", sizeof(*arr));//数组首元素的大小是1个字节 printf("%d\n", sizeof(arr[1]));//数组第二个元素的大小是1个字节 printf("%d\n", sizeof(&arr));//&arr取出整个数组的地址，但依然是地址，大小是4/8个字节 printf("%d\n", sizeof(&arr + 1));//&arr+1是跳过整个数组后的地址，是地址，大小就是4/8个字节 printf("%d\n", sizeof(&arr[0] + 1));//数组第二个元素的地址，是地址，大小就是4/8个字节 return 0; }
接着再看一段代码，我们把上述代码用strlen来计算：
#define _CRT_SECURE_NO_WARNINGS 1 #include<stdio.h> #include<string.h> 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)); return 0; }
先来明确一下strlen函数的功能：求字符串长度，统计的是在字符串\0之前的字符的个数，如果没有\0就会一直往后找。
代码分析：
#define _CRT_SECURE_NO_WARNINGS 1 #include<stdio.h> #include<string.h> int main() { char arr[] = { 'a','b','c','d','e','f' }; printf("%d\n", strlen(arr));//因为字符数组中没有\0，所以strlen函数会一直往后找，直到找到\0，此时打印一个随机值 printf("%d\n", strlen(arr + 0));//arr+0是首元素地址，所以和第一个一样，还是随机值 //printf("%d\n", strlen(*arr));//error //printf("%d\n", strlen(arr[1]));//error printf("%d\n", strlen(&arr));//&arr是数组的地址，数组的地址和数组首元素的地址，值是一样的，所以strlen还是从数组第一个元素往后找，这里依然是随机值 printf("%d\n", strlen(&arr + 1));//随机值 printf("%d\n", strlen(&arr[0] + 1));//随机值 return 0; }
注意其中的这两句代码运行时会出现错误：
printf("%d\n", strlen(*arr)); printf("%d\n", strlen(arr[1]));
原因是strlen函数的参数要求接收的是一个地址，而*arr传给它的是数组首元素‘a’，a的ASCII值是97，所以会将97作为地址传参，此时strlen函数从97这个地址开始统计字符串长度，这就非法访问内存了，此时运行就会报错（如下图）。
通过在www.cplusplus.com中查询strlen函数会发现，strlen函数的参数类型如下：
那这时有人要有疑问了，上图中strlen函数的参数类型是const char*型的，而&arr的类型明明是数组指针 char(*)[6]， 那为什么这段代码能运行呢？
printf("%d\n", strlen(&arr));
其实这无关紧要，只要把&arr的值传过去，它就会自然而然变成const char*型，而&arr和arr一个是数组地址，一个是数组首元素地址，但它们的值是一样的， 所以strlen还是从数组第一个元素往后找，这里依然是随机值。
下面我们继续看下一段代码：
#define _CRT_SECURE_NO_WARNINGS 1 #include<stdio.h> #include<string.h> int main() { char arr[] = "abcdef"; 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)); 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)); return 0; }
在分析这段代码前，我们先要明确字符数组中存放的内容：
代码分析：
#define _CRT_SECURE_NO_WARNINGS 1 #include<stdio.h> #include<string.h> int main() { char arr[] = "abcdef"; printf("%d\n", sizeof(arr));//7 printf("%d\n", sizeof(arr + 0));//数组首元素地址，大小是4/8 printf("%d\n", sizeof(*arr));//数组首元素，大小是1 printf("%d\n", sizeof(arr[1]));//数组第二个元素，大小是1 printf("%d\n", sizeof(&arr));//整个数组地址，大小是4/8 printf("%d\n", sizeof(&arr + 1));//跳过整个数组之后的地址，大小是4/8 printf("%d\n", sizeof(&arr[0] + 1));//数字第二个元素地址，大小是4/8 printf("%d\n", strlen(arr));//6 printf("%d\n", strlen(arr + 0));//数组组首元素地址，往后统计，直到\0，结果是6 //printf("%d\n", strlen(*arr));//error //printf("%d\n", strlen(arr[1]));//error printf("%d\n", strlen(&arr));//&arr是数组的地址，数组的地址和数组首元素的地址，值是一样的，所以strlen还是从数组第一个元素往后找,结果是6 printf("%d\n", strlen(&arr + 1));//跳过整个数组，同时跳过了\0，往后找是随机值 printf("%d\n", strlen(&arr[0] + 1));//从数组第二个元素往后找，结果是5 return 0; }
注意其中的这代码：
printf("%d\n", strlen(&arr + 1));//跳过整个数组，同时跳过了\0，往后找是随机值
接着看下面一段代码：
#define _CRT_SECURE_NO_WARNINGS 1 #include<stdio.h> #include<string.h> int main() { char* p = "abcdef"; 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)); 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", strlen(&p[0] + 1)); return 0; }
我们前面学过，可以把字符串存放在字符指针中，字符指针变量中存放的是字符串首字符的地址。
代码分析：
#define _CRT_SECURE_NO_WARNINGS 1 #include<stdio.h> #include<string.h> int main() { char* p = "abcdef"; printf("%d\n", sizeof(p));//p是一个指针变量，大小是4/8 printf("%d\n", sizeof(p + 1));//p+1是字符'b'的地址，大小是4/8 printf("%d\n", sizeof(*p));//p中存放的是字符串首字符'a'的地址，*p就是字符'a'，大小是1 printf("%d\n", sizeof(p[0]));//p[0]是字符'a'，大小是1 printf("%d\n", sizeof(&p));//&p的类型是char**，二级指针，大小是4/8 printf("%d\n", sizeof(&p + 1));//依然是地址，大小是4/8 printf("%d\n", sizeof(&p[0] + 1));//字符串第二个字符的地址，大小是4/8 printf("%d\n", strlen(p));//6 printf("%d\n", strlen(p + 1));//从第二个字符往后统计，是5 //printf("%d\n", strlen(*p));//error //printf("%d\n", strlen(p[0]));//error printf("%d\n", strlen(&p));//随机值 printf("%d\n", strlen(&p + 1));//随机值 printf("%d\n", strlen(&p[0] + 1));//从第二个字符往后统计，是5 return 0; }
注意这两句代码为什么打印出来的是随机值：
printf("%d\n", strlen(&p));//随机值 printf("%d\n", strlen(&p + 1));//随机值
先来看看他们在内存中的关系图：
由此我们可以看到，p中存放的是字符a的地址，&p就是p这4字节空间中的第一个字节的地址，而&p+1是跳过这4个字节后的地址 ，无论是从&p，还是从&p+1往后统计，我们都不清楚什么时候回遇到\0，所以打印出来的结果是个随机值。
9.3二维数组
接下来的内容有点难了，打起精神哦。
#define _CRT_SECURE_NO_WARNINGS 1 #include<stdio.h> int main() { //二维数组 int a[3][4] = { 0 }; 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; }
在这之前，我们先来回顾一些关于二维数组的知识：
代码分析：
#define _CRT_SECURE_NO_WARNINGS 1 #include<stdio.h> int main() { //二维数组 int a[3][4] = { 0 }; printf("%d\n", sizeof(a));//4*12=48 printf("%d\n", sizeof(a[0][0]));//4 printf("%d\n", sizeof(a[0]));//a[0]代表第一行的一维数组的数组名 //数组名单独放在sizeof内部，sizeof(a[0])计算的是一维数组的大小，大小是16 printf("%d\n", sizeof(a[0] + 1)); //a[0]没有单独放在sizeof内部,也没有& //a[0]表示数组首元素的地址，也就是a[0][0]的地址 //a[0]+1就是第一行第二个元素的地址，是地址大小就是4/8 printf("%d\n", sizeof(*(a[0] + 1)));//*(a[0] + 1)是数组第一行第二个元素，大小是4 printf("%d\n", sizeof(a + 1)); //a是二维数组首元素的地址，也就是第一行的地址 //a+1就是第二行的地址，是地址大小就是4/8 printf("%d\n", sizeof(*(a + 1)));//*(a+1) --> a[1]，这里计算的是第二行数组的大小，大小是16 printf("%d\n", sizeof(&a[0] + 1));//&a[0]取出第一行数组的地址，&a[0]+1就是第二行的地址，大小是4/8 printf("%d\n", sizeof(*(&a[0] + 1)));//第二行的大小，16 printf("%d\n", sizeof(*a)); //a是a是二维数组首元素的地址，也就是第一行的地址 //所以计算的是第一行大小，16 printf("%d\n", sizeof(a[3]));//16 return 0; }
注意这段代码：
printf("%d\n", sizeof(a[3]));//16
有人说，这明显越界访问了呀，为什么还能打印出来16？
因为这里的a[3]它的类型是 int [4]，当我们知道这一点的时候，它就不会真的去访问内存，而是直接打印出16，因为在计算机中sizeof计算大小是根据类型来计算的。
为了验证sizeof只关注类型，我们用以下代码来证明：
#define _CRT_SECURE_NO_WARNINGS 1 #include<stdio.h> int main() { int a = 3; short s = 4; printf("%d\n", sizeof(s = a + s)); printf("%d\n", s); return 0; }
运行结果：
造成这种结果的原因就是：sizeof只关注类型，当我们执行sizeof(s=s+a)时，我们最终的结果会赋给s，而且已经知道了s是短整型，它的大小就是2，此时计算机就不再执行后面的a+s，所以最终s的值没有改变。
10.指针笔试题
笔试题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取出的是整个数组的地址，那&a+1就是跳过数组之后的地址，此时&a+1的类型是数组指针int(*)[5]，通过强制类型转化为（int*），然后将其赋给指针变量ptr，ptr指向的就是跳过数组后的地址，所以*(ptr-1)就是数组最后一个元素5。而*(a+1)是数组第二个元素2。
所以最终的打印结果应该是：2 5。
笔试题2：注意此题是在x86环境下运行的。
//由于还没学习结构体，这里告知结构体的大小是20个字节 struct Test { int Num; char *pcName; short sDate; char cha[2]; short sBa[4]; }*p=(struct test*)0x100000; //假设p 的值为0x100000。 如下表表达式的值分别为多少？ //已知，结构体Test类型的变量大小是20个字节 int main() { printf("%p\n", p + 0x1); printf("%p\n", (unsigned long)p + 0x1); printf("%p\n", (unsigned int*)p + 0x1); return 0; }
注意上述代码中的已知条件，p=0x100000，结构体的大小给出是20个字节。
先来看 p+0x1，p是一个结构体指针，我们讲过，指针的类型决定了指针+-1操作跳过的字节，所以p+0x1跳过20个字节，打印出来的16进制地址是0x100014。
(unsigned long)p现将p的值转换为一个无符号整型数据，此时+0x1，就是在16进制数字0x100000上直接加一，打印出来的应该是0x100001。
(unsigned int*)p将结构体指针p强制类型转换成(unsigned int*)，此时进行+1操作跳过4个字节，所以打印结果应该是0x100004。
笔试题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; }
运行结果：
%x打印16进制数。
先来看ptr1[-1]，它其实就相当于*(ptr-1)，我们在第一题中讲过类似的，显然它打印出来的是4。
而(int)a将a强制类型转换成 int型，此时进行加一操作就是对a的值加一，假设a中的值是0x0012ff40，那(int)a+1的值就是0x0012ff41，而又将0x0012ff41作为地址给ptr2，此时就相当于跳过一个字节，然后向后访问4个字节，此时是小端存储，所以访问到的是00 00 00 02，还原以后就是02 00 00 00，打印时省略第一个0，结果就是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
诶？为什么是1？结果不应该是0吗？
注意这个题有一个小小的坑，它在初始化二维数组时，大括号中用的是小括号，而不是{}，所以()里面的是逗号表达式，逗号表达式的值是其中最后一个表达式的值，所以只将1,3,5存放了进去。
而p[0]等价于*(p+0) --> *(a[0]+0) --> *(a[0])，a[0]是二维数组第一行数组的数组名，数组名又是数组首元素的地址，所以访问的是第一行第一个元素1。
笔试题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的类型是 int(*)[5]，而p的类型是 int(*)[4]，它们都是数组指针，a+1每次跳过5个整型，p+1每次跳过4个整型，p=a让它们的起始地址都是相同的，此时它们在内存中的关系如下图：
把p也看做一个二维数组会找到&p[4][2]的位置，而&p[4][2] - &a[4][2]，两个指针相减得到的是他们之间的元素的个数，又因为随着下标的增长，地址是由低到高变化的，所相减得到的是-4，而-4用%p打印时，它在内存中的补码（11111111111111111111111111111110）作为地址是FFFFFFFC。
笔试题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; }
打印结果：10 5
这个题比较简单，&aa取出整个二维数组的地址，&a+1跳过二维数组后的地址，赋给ptr1，所以*(ptr1-1)是数组最后一个元素10，而*(aa+1)就相当于aa[1]，是第二行数组的数组名，即就是aa[1][0]的地址，所以*(ptr2-1)就是aa[1][0]的上一个元素aa[0][5]=5。
笔试题7：
#include <stdio.h> int main() { char *a[] = {"work","at","alibaba"}; char**pa = a; pa++; printf("%s\n", *pa); return 0; }
打印结果：at
char*a[]是一个指针数组，其中存放的是三个char*型的指针，分别指向三个字符串首字符'w'，'a'，'a'的地址，而pa是二级指针变量，指向的是'w'的地址，所以pa++后，pa指向‘a’的地址，然后*pa通过%s打印出字符串“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; }
打印结果： 
首先，我们来看一下，c、cp、cpp在内存中的关系：
先来看**++cpp：
cpp先++，然后经过两次解引用，因为cpp中存放是cp，所以cp++指向cp+1，而cp+1解引用找到c+2，对c+2解引用找到字符'P'的地址，通过%s打印出POINT。（如下图）
再来看*--*++cpp+3：
明确这条代码中运算符的优先级由高到低依次是：++、*、+,所以+3一定是最后进行的，先进行++cpp，注意经过上条代码后，cpp中存放的是cp+1，所以再进行++cpp，指向的是cp+2，对cp+2解引用得到c+1，对--(c+1)得到c，对c解引用得到字符'E'的地址，+3得到字符'E'的地址，通过%s往后打印出ER。
接着来看*cpp[-2]+3：
它可以写成 **(cpp-2)+3， 经过前两条代码，此时cpp中存放的内容又变成了cp+2，所以cpp-2指向的就是cp+2-2=cp，对cp解引用得到c+3，对c+3解引用得到字符'F'得地址，+3得到字符'S'的地址，通过%s往后打印出ST。
最后来看一下cpp[-1][-1]+1：
它可以写成*(*(cpp-1)-1)+1，此时cpp中的内容还是cp+2，所以cpp-1得到cp+1，对cp+1解引用得到c+2，对c+2-1得到c+1，对c+1解引用得到字符'N'的地址，+1得到字符'E'的地址，通过%s往后打印出EW。
以上就是关于一些关于指针的笔试题及详细解析，
那么今天就学到这里啦，未完待续。。。
