知识丰富人生，学习改变命运 ——加油啊！加油！
目录
后记：●由于作者水平有限，文章难免存在谬误之处，敬请读者斧正，俚语成篇，恳望指教！ ——By 作者：新晓·故知
9. 指针和数组笔试题解析
前章回顾:
编辑
分析以下代码:
int main() { //一维数组 int a[] = { 1,2,3,4 }; printf("%d\n", sizeof(a)); //数组名a单独放在sizeof内部，计算的整个数组的大小，单位是字节，4*4 = 16 printf("%d\n", sizeof(a + 0)); //a表示的首元素的地址，a+0还是数组首元素的地址，是地址大小4/8 printf("%d\n", sizeof(*a)); //a表示的首元素的地址,*a就是对首元素的地址的解引用，就是首元素，大小是4个字节 printf("%d\n", sizeof(a + 1)); //a表示的首元素的地址，a+1是第二个元素的地址，是地址，大小就4/8个字节 printf("%d\n", sizeof(a[1])); //a[1]是数组的第二个元素，大小是4个字节 printf("%d\n", sizeof(&a)); //&a 表示是数组的地址，数组的地址也是地址，地址大小就是4/8字节 printf("%d\n", sizeof(*&a)); //可以理解为*和&抵消效果，*&a相当于a,sizeof(a)是16 //&a -> int(*)[4] //&a是数组的地址，它的类型是int(*)[4]数组指针，如果解引用，访问的就是4个int的数组，大小是16个字节 printf("%d\n", sizeof(&a + 1)); //&a是数组的地址，&a+1 跳过整个数组后的地址，是地址就是4/8 printf("%d\n", sizeof(&a[0])); //&a[0]取出数组第一个元素的地址，是地址就是4/8 printf("%d\n", sizeof(&a[0] + 1)); //&a[0]+1就是第二个元素的地址,是地址大小就是4/8个字节 //&a[0] - int* return 0; }
编辑
编辑
编辑分析以下代码:
//字符数组 char arr[] = { 'a','b','c','d','e','f' }; printf("%d\n", sizeof(arr)); //arr作为数组名单独放在sizeof内部，计算的整个数组的大小，单位是字节，6 printf("%d\n", sizeof(arr + 0)); //arr就是首元素的地址，arr+0还是首元素的地址，地址大小就是4/8 printf("%d\n", sizeof(*arr)); //arr就是首元素的地址，*arr就是首元素，是一个字符，大小是一个字节，1 printf("%d\n", sizeof(arr[1])); //arr[1]就是数组的第二个元素，是一个字符，大小是1个字节 printf("%d\n", sizeof(&arr)); //&arr取出的是数组的地址，数组的地址也是地址，地址就是4/8个字节 printf("%d\n", sizeof(&arr + 1)); //&arr取出的是数组的地址，&arr+1，跳过了整个数组，&arr+1还是地址，地址就是4/8个字节 printf("%d\n", sizeof(&arr[0] + 1)); //&arr[0]是第一个元素的地址，&arr[0]+1就是第二个元素的地址，地址就是4/8个字节
编辑
编辑
#include<string.h> int main() { char arr[] = { 'a','b','c','d','e','f' }; printf("%d\n", strlen(arr)); //arr是首元素的地址，但是arr数组中没有\0，计算的时候就不知道什么时候停止，结果是：随机值 printf("%d\n", strlen(arr + 0)); //arr是首元素的地址，arr+0还是首元素的地址，结果是：随机值 printf("%d\n", strlen(*arr)); //err,strlen需要的是一个地址，从这个地址开始向后找字符,直到\0，统计字符的个数。 //但是*arr是数组的首元素，也就是'a',这是传给strlen的就是'a'的ascii码值97，strlen函数会把97作为起始地址，统计字符串，会形成内存访问冲突 printf("%d\n", strlen(arr[1])); //err 和上一个一样，内存访问冲突 printf("%d\n", strlen(&arr)); //&arr是arr数组的地址，虽然类型和strlen的参数类型有所差异，但是传参过去后，还是从第一个字符的 //位置向后数字符，结果还是随机值。 printf("%d\n", strlen(&arr + 1)); //随机值 printf("%d\n", strlen(&arr[0] + 1)); //随机值 }
分析以下代码:
int main() { char arr[] = "abcdef"; printf("%d\n", sizeof(arr)); //arr单独放在sizeof中，计算的是整个数组大小，又因为是字符串，所以自动添加'\0',总共7个字节 printf("%d\n", sizeof(arr + 0)); //arr是首元素的地址，arr+0还是首元素的地址，地址就是4/8个字节 printf("%d\n", sizeof(*arr)); //arr是首元素的地址，*arr解引用就是首元素a，char类型,占用1个字节 printf("%d\n", sizeof(arr[1])); //arr[1]是第二个元素的大小，char类型，占用1个字节 printf("%d\n", sizeof(&arr)); //&arr取出的是整个数组的地址，地址就是4/8个字节 printf("%d\n", sizeof(&arr + 1)); //&arr+1跳过了是整个数组的地址，是'\0'的地址，是地址就是4/8个字节 printf("%d\n", sizeof(&arr[0] + 1)); //&arr[0] + 1是第二个元素b的地址，是地址就是4/8个字节 }
编辑
#include<string.h> int main() { char arr[] = "abcdef"; printf("%d\n", strlen(arr)); //arr在strlen中，表示的是首元素a的地址，依次往后直至'\0'终止，共6个字节 printf("%d\n", strlen(arr + 0)); //arr是首元素的地址。arr+0还是首元素的地址，效果等同于strlen(arr),共6个字节 printf("%d\n", strlen(*arr)); //*arr是首元素a，ASCII码值为97，而strlen求地址，将97当成地址，非法访问内存，报错！ printf("%d\n", strlen(arr[1])); //arr[1]是第二个元素b，ASCII码值为98，strlen将98当成地址，非法访问内存，报错！ printf("%d\n", strlen(&arr)); //&arr取出的是整个数组的地址，整个数组的地址还是起始地址，共6个字节 printf("%d\n", strlen(&arr + 1)); //&arr+1跳过了整个数组的地址，后面的未知，则为随机值 printf("%d\n", strlen(&arr[0] + 1)); //这是b的地址，依次往后直至'\0'终止，总共5个字节 }
编辑
编辑
编辑
编辑
编辑
编辑
编辑
编辑
编辑
分析以下代码：
int main() { char* p = "abcdef"; printf("%d\n", sizeof(p)); //p是一个指针变量，sizeof(p)计算的就是指针变量的大小，4/8个字节 printf("%d\n", sizeof(p + 1)); //p是指针变量，是存放地址的，p+1也是地址，地址大小就是4/8字节 printf("%d\n", sizeof(*p)); //p是char*的指针，*p访问的是1个字节,sizeof(*p)大小是1个字节 printf("%d\n", sizeof(p[0])); //p[0]--> *(p+0) -> *p，1个字节 printf("%d\n", sizeof(&p)); //&p也是地址，是地址就是4/8字节，&p是二级指针 printf("%d\n", sizeof(&p + 1)); //&p是地址， + 1后还是地址，是地址就是4 / 8字节 //&p + 1,是p的地址+1，在内存中跳过p变量后的地址 printf("%d\n", sizeof(&p[0] + 1)); //p[0]就是a，&p[0]就是a的地址，&p[0]+1就是b的地址，是地址就是4/8字节 }
编辑sizeof只关注其所占内存空间的大小。
#include<string.h> int main() { char* p = "abcdef"; printf("%d\n", strlen(p)); //p中存放的是'a'的地址，strlen(p)就是从'a'的位置向后求字符串的长度，长度是6 printf("%d\n", strlen(p + 1)); //p+1是'b'的地址，从b的位置开始求字符串长度是5 printf("%d\n", strlen(*p)); //*p是首元素a,ASCII码值为97，非法访问内存，报错！ printf("%d\n", strlen(p[0])); //p[0] <==> *(p+0) <==>*p,报错！ printf("%d\n", strlen(&p)); //&p取p的地址，但结束标志未知，随机值 printf("%d\n", strlen(&p + 1)); //&p + 1跳过整个p的地址，但结束标志未知，随机值 printf("%d\n", strlen(&p[0] + 1)); //p[0] -> *(p+0) -> *p ->'a' ,&p[0]就是首字符的地址，&p[0]+1就是第二个字符的地址 //从第2 字符的位置向后数字符串，长度是5 //注：！！！ &p是取出的是变量p的地址，而变量p的内存中存放的是字符串的地址 }
编辑
strlen针对的是字符串长度，也会比较类型！
分析以下代码：
int main() { //二维数组 int a[3][4] = { 0 }; printf("%d\n", sizeof(a)); //数组名单独放在sizeof内部，计算的是整个数组的大小 printf("%d\n", sizeof(a[0][0])); //第一行第一列的元素，int型，4个字节 printf("%d\n", sizeof(a[0])); //a[0]表示第一行的数组名，a[0]作为数组名单独放在sizeof内部，计算的是第一行的大小，共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))); //第一行第二个元素，int型，4个字节 printf("%d\n", sizeof(a + 1)); //a是二维数组的数组名，综合以上分析，a+1是第二行的地址 //是类型为int(*)[4]的数组指针，是地址就是4/8个字节 printf("%d\n", sizeof(*(a + 1))); //*(a+1)就是第二行，相当于第二行的数组名，*(a+1)<==>a[1], //sizeof(*(a + 1))计算的是第二行的大小，总共16个字节 printf("%d\n", sizeof(&a[0] + 1)); //a[0]是第一行的地址，&a[0]是第一行的地址，&a[0]+1是第二行的地址，4/8个字节 printf("%d\n", sizeof(*(&a[0] + 1))); //*(&a[0] + 1)<==>a[1],sizeof(a[1])大小是16个字节 printf("%d\n", sizeof(*a)); //a二维数组的数组名，未满足sizeof的两种特殊情形，*a就是二维数组的首元素， //即第一行。（*a<==>*(a+0)<==>a[0]） printf("%d\n", sizeof(a[3])); //感觉a[3]是越界了，但是没关系，sizeof(a[3])反推其一维数组及其类型， //a[3]是第四行的数组名4个int型，16个字节 printf("%d\n", sizeof(&a+1)); //a是二维数组的地址，&a+1跳过整个二维数组的地址(跳过了48字节），是地址就是4/8个字节 printf("%p\n", &a[0][0]); printf("%p\n", &a+1); printf("%p\n", a[0] + 1); printf("%p\n", a + 1); int* p = a + 1; return 0; }
编辑
编辑
编辑
编辑
总结：
数组名的意义：
1. sizeof(数组名)，这里的数组名表示整个数组，计算的是整个数组的大小。
2. &数组名，这里的数组名表示整个数组，取出的是整个数组的地址。 3. 除此之外所有的数组名都表示首元素的地址。
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; }
输出：2,5
解析：*（a+1）是数组第二个元素2，（&a+1）跳过整个数组，强制转换成（int*），*（ptr-1）是数组第五个元素5
笔试题2:
//这里告知结构体的大小是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); printf("%p\n", (unsigned long)p + 0x1); printf("%p\n", (unsigned int*)p + 0x1); return 0; }
输出：
00000014
00000001
00000004
解析：p+0x1相当于跳过了整个结构体，而一个结构体的大小为20个字节，又"%p"打印（编译器设置打印的地址为16进制（地址本来是2进制，但可以用8、16进制表示），14转化成10进制为20）；
（unsigned long）p将p强制转换成整型，p代表数字，整数+1为00000001；
（unsigned int*）p将p强制转换成整型指针，整形指针+1，跳过1个整型，4个字节为00000004
笔试题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; }
输出：4,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
笔试题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; }
输出：FFFFFFFC,-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; }
输出:10,5
笔试题7:
#include <stdio.h> int main() { char* a[] = { "work","at","alibaba" }; char** pa = a; pa++; printf("%s\n", *pa); return 0; }
输出：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; }
输出：
POINT
ER
ST
EW
编辑
编辑
注：
（1）**++cpp: ++cpp指向的是c+2的地址，*++cpp是解引用一次得到的是c+2，**++cpp解引用两次得到的是POINT.
（2）*-- * ++cpp + 3：先计算++cpp，接上题，此时cpp指向c+1的地址，*++cpp解引用后，是c+1，--*++cpp是指（c+1）-1，即得c再进行解引用后（*-- * ++cpp）得到char*中ENTER里E的地址，*-- * ++cpp + 3得到ENTER中第三个E的地址，再进行%s打印，得到ER。
（3）*cpp[-2] + 3：因为从cpp一直在改动，并且 *cpp[-2] + 3 <==> **（cpp-2）+3。而（cpp-2）指向cp数组中的c+3的地址，*（cpp-2）得到c中的char*的地址**（cpp-2）的得到FIRST中F的地址，**（cpp-2）+3得到FIRST中的S进行%s打印后得到ST
（4）cpp[-1][-1] + 1：cpp[-1][-1] + 1<==>*（*（cpp-1）-1）+1，（cpp-1）指向cp中c+2 的地址，*（cpp-1）得到cp中的c+2，*（cpp-1）-1即（c+2）-1得到c+1再进行解引用*（*（cpp-1）-1）得到c中的指向NEW中N的地址，*（*（cpp-1）-1）+1得到NEW中E的地址，再进行%s打印，得到EW。
