1.sizeof和strlen的对比

sizeof计算变量所占内存空间的大小的，单位是字节

sizeof只关注内存空间的大小，不在乎内存中方的什么数据

sizeof是操作符不是函数

sizeof会将\0算进去的

// sizeof计算变量所占内存空间的大小的，单位是字节int main(){ int a = 10; printf("%d\n", sizeof(int));//输出结果是4 printf("%d\n", sizeof(a));//输出结果是4 int arr[10] = { 0 }; printf("%d\n", sizeof(arr));//输出的结果是40 return 0;}//sizeof只管新占了多大的内存空间大小

那么strlen呢？

strlen是c语言里面的库函数，是函数

作用的求字符串长度的，只能针对字符串

strlen统计的是字符串\0之前的字符个数

只能指针字符串，求字符串长度

不能求整形数组的

strlen直到遇到\0,不然是不会停下来的

int main(){ char arr1[] = { 'a','b','c' }; char arr2[] = "abc";//字符串末尾隐藏着一个\0 printf("%zd\n", strlen(arr1));//15---往后找\0,直到找到\0才停止--那么这个15就是随机值 printf("%zd\n", strlen(arr2));//3---\0前面有三个字符 printf("%zd\n", sizeof(arr1));//3---只关乎arr1占了多大的空间 printf("%zd\n", sizeof(arr2));//4---放了4个字符，包括\0，总共占了4个字节 //strlen是用来求字符串长度的，不能用来求整型数组 return 0;}

2.数组和指针笔试题解析

sizeof---一维数组

//恢复：数组名是数组首元素的地址//但是有两个例外//sizeof(数组名)//&数组名//除了这两种，其他的都是数组首元素的地址int main(){ int a[] = { 1,2,3,4 }; printf("%zd\n", sizeof(a));//16---4个元素，每个元素4个字节 //数组名a单独放在sizeof内部，a表示的是整个数组，计算的是整个数组的大小，单位是字节 printf("%zd\n", sizeof(a+0));//4 //a是数组名，数组首元素的地址，a+0还是首元素的地址 //a+i就是数组内下标为i的数组元素 //这里的sizeof计算的是首元素地址的大小 printf("%zd\n", sizeof(*a));//4 //这里的a依然是首元素的地址，*a就是首元素，就是a[0] //因为arr[0]是一个整数，就是4个字节 printf("%zd\n", sizeof(a+1));//4 //因为数组名表示的是首元素的地址，那么首元素加1 //就是下标为1的数字的地址，就是这个数组内第二个元素的地址 //arr[1]的地址 //这里计算的是地址的大小 printf("%zd\n", sizeof(a[1]));//4 //a[1]就是数组内第二个元素，就是4个字节的大小 printf("%zd\n", sizeof(&a));//4 //取出整个数组的地址 //数组的地址也是一个地址啊，是地址就是4个字节的长度 printf("%zd\n", sizeof(*&a));//16 //取出a的地址，再进行解引用，就是整个数组， //*和&抵消了，就是整个数组 // sizeof(*&a)==sizeof(a) //&a是数组的地址，类型是int(*)[4]---数组指针类型 //那么*&a就是访问真个数组 printf("%zd\n", sizeof(&a+1));//4 //&a就是整个数组的地址，地址+1就是跳过整个数组后的那个地址， // 但是仍然是地址啊 //是地址就是4个字节 printf("%zd\n", sizeof(&a[0]));//4 //arr[0]是数组首元素的地址，再将其取出 //取出数组首元素的地址 printf("%zd\n", sizeof(&a[0]+1));//4 //将首元素的地址取出，再+1就是第二个元素的地址 return 0;}

 sizeof--字符数组

int main(){ char arr[] = { 'a','b','c','d','e','f' };//没有\0 printf("%d\n", sizeof(arr));//6 //整个数组的大小，6个字符就是6 printf("%d\n", sizeof(arr+0));//4 //arr是首元素的地址，arr+0还是首元素的地址，地址的字节就是4 printf("%d\n", sizeof(*arr));//1 //对数组首元素地址进行解引用就是数组首元素，字符就是1个字节 printf("%d\n", sizeof(arr[1]));//1 //数组中下标为1的字符，大小是1个字节 printf("%d\n", sizeof(&arr));//4 //取出整个数组的地址，仍然是地址，地址就是4个字节的大小 printf("%d\n", sizeof(&arr+1));//4 //取出整个数组的地址，+1跳过整个数组，还是地址，就是4个字节的大小 printf("%d\n", sizeof(&arr[0]+1));//4 //取出数组首元素的地址，再+1就是第二个元素的地址，地址是4个字节大小 return 0;}

 strlen---大括号--一堆字符

int main(){ char arr[] = { 'a','b','c','d','e','f' };//没有\0 printf("%zd\n", strlen(arr));//随机值 //这里的arr表示的是首元素的地址 //从首元素开始数字符，一直数到\0之前才停止 //那么这里的值就是随机值 printf("%zd\n", strlen(arr+0)); //arr+0还是数组名-----首元素的地址 //那么返回的值就是随机值，这个代码和上面的代码没有区别 //并且这两个随机值是一样的 printf("%zd\n", strlen(*arr)); //arr是首元素的地址，那么对其进行解引用就是数组第一个元素，就是'a'字符 //strlen(a)---'a'的ASCII的大小是97，strlen不能运行 //a的值传递给strlen，strlen会认为97是地址，然后会访问内存 //这个代码是有问题的 printf("%zd\n", strlen(arr[1])); //arr[1]是数组下标为1的元素 //strlen('b')---'b'的ASCII大小是98 //这个程序也会崩溃 printf("%zd\n", strlen(&arr));//随机值 //将数组的整个数组的地址传过去了 //strlen依然从首元素往后数 //依然没有遇到\0 //那么返回值就是随机值 //&arr的类型是----char(*)[6] printf("%zd\n", strlen(&arr+1));//随机值 //取出整个数字的地址，然后+1跳过整个数组 //也是随机值，不知道什么时候遇到\0 printf("%zd\n", strlen(&arr[0]+1));//随机值 //arr[0]是数组首元素，+1就是b，那么strlen往后直到遇到\0才停止，那么 //这个代码返回的也是随机值 return 0;}

 sizeof--字符串

//数组名是数组首元素的地址//两个例外：//sizeof(arr)//&arr---这里的数组名表示整个数组，取出的是数组的地址int main(){ char arr[] = "abcdef";//字符串初始化 //这个字符串末尾还有一个\0 printf("%zd\n", sizeof(arr));//7 //arr作为数组名，这里计算的是这个数组的大小 //一个字符一个字节，那么这里就是7个字节 //这里的数组名是单独的放在sizeof里面的 printf("%zd\n", sizeof(arr + 0));//4 //数组名--就是数组首元素的地址 //这里的arr并不是单独的放在sizeof里面 //那么这里的arr+0是首元素的地址 //既然是地址，那么大小就是4个字节 printf("%zd\n", sizeof(*arr));//1 //这里的arr是数组名--首元素的地址 //对arr进行解引用达到的就是首元素 //首元素的大小是1个字节--每个字符的大小是1个字节 printf("%zd\n", sizeof(arr[1]));//1 //数组下标为1的元素，字符，所以大小也是1 printf("%zd\n", sizeof(&arr));//4 //取出整个数组的地址，地址就是4个字节 printf("%zd\n", sizeof(&arr + 1));//4 //取出的是整个数组的地址，再+1，得到的就是跳过整个数组 //得到的也是地址，既然是地址就是4个字节的大小 printf("%zd\n", sizeof(&arr[0] + 1));//4 //arr[0]是数组首元素，取出数组首元素的地址再+1 //得到的就是数组内的第二元素的地址，地址就是4个字节大小 //首元素的地址类型是char* return 0;}

 strlen---字符串

int main(){ char arr[] = "abcdef";//字符串末尾放着\0的 printf("%d\n", strlen(arr));//6 //这里的arr是首元素的地址 // 从首元素开始数，数到\0之前就停止 //strlen是求字符串长度的 //因为末尾放着一个\0，那么strlen数的就是\0前面的字符个数 //strlen是从第一个元素开始统计\0之前的字符个数 printf("%d\n", strlen(arr + 0));//6 //arr是首元素的地址，那么arr+0还是首元素的地址 //那么把数组首元素的地址传给strlen，就是从首元素开始统计，直到遇到\0 printf("%d\n", strlen(*arr)); //arr是首元素的地址，那么解引用得到的就是首元素字符'a' //'a'的大小是97，将97当成地址传递给strlen，97这个地址不能被访问，这个程序就崩溃了 printf("%d\n", strlen(arr[1])); //arr[1]是数组下标为1的元素，第二个元素，访问的是'b' //这个代码的道理和上面的一样，一样会崩溃的 printf("%d\n", strlen(&arr));//6 //取出数组的地址，将取出的地址存放至数组指针变量里面这么写 //char(*pa)[7]=&arr//那么pa的类型是char(*)[7] //但是对于strlen这个库函数来说 //size_t strlen (const char* str) //硬要将char(*)[7]这个地址传过去，因为char(*)[7]与const char* str不一致，会导致将传过来的指向强制转换为strlen所需要的类型 // //数组的地址和数组首元素的地址是指向同一个位置的 //那么strlen也是从第一个元素的位置开始向后访问 //所以这个代码实现的数据是6 printf("%d\n", strlen(&arr + 1));//随机值 //取出数组的地址，再+1就是跳过整个数组，那么strlen遇到\0才会停止 //那么这里的就是随机值 printf("%d\n", strlen(&arr[0] + 1));//5 //取出的是首元素的地址，那么首元素的地址+1就是数组第二个元素的地址 //那么strlen就从第二个元素开始访问进行统计的 //那么这里的 数据就是5 return 0;}//在这些代码运行的时候//会出现很多警告//因为我们在传参的时候类型不一致//&arr的类型是char(*)[7]，而strlen只能接受const char* str这个类型的指针

 sizeof---指针

int main(){ char* p = "abcdef";//将首字符的地址存放在p中 printf("%zd\n", sizeof(p));//4 //p是指针变量。那么sizeof(p)计算的就是指针变量p的大小 //因为一个指针变量的大小是4个字节--x86的情况下，x64的情况下是8个字节 printf("%zd\n", sizeof(p + 1));//4 //p存的是首元素的地址，p的类型是char* //那么p+1得到的是b的地址，就是相当于跳过了一个字符 //地址的大小就是4个字节 printf("%zd\n", sizeof(*p));//1 //p是字符串首元素的地址，对p进行解引用，得到的就是首元素，首元素是字符a //a的字节大小是1 //因为p的类型是char*，只能访问一个字节，就是a printf("%zd\n", sizeof(p[0]));//1 //p[0]-->*(p+0)---得到的就是字符a---大小为1个字节 printf("%zd\n", sizeof(&p));//4 //取出p的地址，&p是p的地址，对p的地址进行大小计算，地址的大小就是4个字节 printf("%zd\n", sizeof(&p + 1));//4 //取出p的地址进行+1操作 // // // char* *ptr=&p ptr指向的p是一个类型为char*类型的指针，后面的*说明ptr是一个指针 //&p的指针类型是char * *,对&p+1就是跳过一个char* * 类型的对象 //举例：int *p 对p+1跳过的就是一个整型对象 //&p是p的地址，&p+1是跳过了p变量，指向了p的后面 //因为&p+1是地址，就是4个字节 printf("%zd\n", sizeof(&p[0] + 1));//4 //p[0]是*（p+0）---就是首元素a //前面加上&得到的就是a的地址，+1就是b的地址 //&p[0]就是p return 0;}

 strlen---指针

int main(){ char* p = "abcdef";//将这个字符串首元素的地址存储在p中,末尾有\0 printf("%zd\n", strlen(p));//6 //p里面放的是a的地址， //strlen(p)就是从a的地址开始统计这个字符串的长度 //得到的数据是6 printf("%zd\n", strlen(p + 1));//5 //p存的是a的地址，因为p是char*的指针，那么p+1就是指向b的地址 //就是从b的地址位置开始统计这个字符串的个数 //那么得到的数据就是5 printf("%zd\n", strlen(*p));//程序崩溃 //*p是a，a是97 //将97作为地址传给strlen,程序会崩溃的 printf("%zd\n", strlen(p[0]));//程序崩溃 //p[0]--->*(p+0)----*p---a----97 //那么这个程序就会崩溃的 printf("%zd\n", strlen(&p));//随机值 //取出指针变量p的地址，那么strlen就从指针变量p地址开始统计，在p这块空间进行统计 //那么得到的就是随机值 printf("%zd\n", strlen(&p + 1));//随机值 //&p是指针p的地址，+1就是跳过p的地址，开始进行统计 //所以数据就是随机值 printf("%zd\n", strlen(&p[0] + 1));//5 //p[0]--->*(p+0)----*p---a //那么&p[0]就相当于p, //p里面存的是a的地址，+1得到的是b的地址 //那么我们就从b的位置开始统计 //得到的数据是5 return 0;}//注意：p[0]--->*(p+0)----*p---a

 sizeof---二维数组

//二维数组int main(){ int a[3][4] = { 0 };//3行4列----每一行都输一维数组 //第一行的数组名叫arr[0]---每个元素的访问a[0][i] //第一行的数组名叫arr[1]---每个元素的访问a[1][i] //第一行的数组名叫arr[2]---每个元素的访问a[2][i] printf("%d\n", sizeof(a));//48 //a是二维数组的数组名，单独放在sizeof内部，a表示的是整个数组，计算的就是整个数组的大小，单位是字节 //12个元素，每个元素4个字节，总共就是48个字节大小 printf("%d\n", sizeof(a[0][0]));//4 //a[0][0]就是第一行第一个元素，大小是4个字节 printf("%d\n", sizeof(a[0]));//16 //a[0]是这个二维数组的第一行的数组名 //第一行的数组名单独放在sizeof内部，计算的就是整个一维数组的大小，就是4*4=16个字节的大小 printf("%d\n", sizeof(a[0] + 1));//4 //a[0]是第一行的数组名,但是没有单独放在sizeof里面，就说明这里的a[0]是第一行首元素的地址，那么首元素地址+1就是第一行第二个元素的地址 //就是a[0][0]的地址 //那么a[0] + 1--->&arr[0][0]+1--->&a[0][1] //因为这里是地址，那么就是4个字节大小 printf("%d\n", sizeof(*(a[0] + 1)));4 //上面说a[0]+1得到的是第一行第二个元素的地址 //那么我们解引用得到的就是第一行第二个元素，是一个整型，大小是4个字节 printf("%d\n", sizeof(a + 1));//4 //a + 1 //a是二维数组的数组名，并且没有单独放在sizeof内 //说明这个a是这个二维数组的首元素地址 //就是第一行的地址，那么a+1就是第二行的地址 //因为a+1是第二行的地址，传给sizeof，因为是地址，所以大小是4个字节 // printf("%d\n", sizeof(*(a + 1)));//16 //*(a+1)--->a[1]--第二行的数组名，单独放在sizeof内部，那么sizeof计算的就是第二行的大小 //因为a+1得到的是第二行的地址，那么对其进行解引用，得到的就是第二行整个数组 //a+1是第二行的地址，类型是int(*)[4],数组指针，基因用访问的是这个数组，大小是16个字节 printf("%d\n", sizeof(&a[0] + 1));//4 //a[0]是第一行的数组名，&数组名就是第一行的地址，&a[0]就是取出了第一行的地址 //那么&a[0] + 1得到的就是第二行的地址 //因为是地址，那么大小就是4个字节 printf("%d\n", sizeof(*(&a[0] + 1)));//16 //上面说到&a[0] + 1得到的是第二行的地址，那么对第二行的地址进行解引用得到的就是第二行数组 // printf("%d\n", sizeof(*a));//16 //a作为数组名没有单独放在sizeof内，那么a就不是整个数组 //a就是这个二维数组的首元素的地址 //对其进行解引用得到的就是第一行整个数组 //4*4=16 //*a-->*(a+0)-->a[0] printf("%d\n", sizeof(a[3]));//16 //这里是否越界 //sizeof内部的表达式是不会真实计算的,也不会真实去访问的 // 仅仅只是根据类型来推断长度的 //a[3]是第四行的数组名---那么计算的是第四行的大小 //第四行的类型是int[4] return 0;}//数组名在sizeof内单独使用，表示的就是整个数组//如果不是单独使用，我们就要考虑一下这个数组名是数组首元素的地址//sizeof内部的表达式是不会进行运算的int main(){ short s = 8;//short类型的数据是2个字节 int n = 12;//4个字节 printf("%zd\n", sizeof(s = n + 5));//2 //sizeof内部的表达式并没有进行运算 //sizeof(s = n + 5)这个表达式 最终结果取决于s printf("%zd\n", s);//8 return 0;}

数组名的意义：

1.sizeof(数组名)，这里的数组名表示的是整个数组，计算的是整个数组的大小

2.&数组名，这里的数组名表示整个数组，取出的是整个数组的地址

3.除此之外所有的数组名都表示数组首元素的地址

3.指针运算笔试题解析

题目一

#include <stdio.h>int main(){ int a[5] = { 1, 2, 3, 4, 5 }; int* ptr = (int*)(&a + 1); //&a是取出真个数组的地址，那么&a+1就是跳过了整个数组，指向的是这个数组的末尾的位置 //&a+1的地址类型是数组类型的地址int(*)[5] //将这个地址强制类型转换为int*类型的 //准换位int*类型的地址再赋值给ptr，那么ptr指向的也是这个数组的末尾位置 printf("%d,%d", *(a + 1), *(ptr - 1)); //这里的a是数组名--数组首元素的地址，那么a+1得到的就是第二个元素的地址，就是2的地址 //解引用得到的就是2 //因为ptr现在是整型指针，那么-1就是往回退，那么指向的就是5的位置 //*(ptr - 1)得到的就是5 return 0;}//&a+1就是取出整个数组再跳过这个数组，就是那么这个&a+1指向的就是这个数组的末尾//再将这个强制类型转换为int *类型的地址，再赋值给ptr//那么ptr也是指向这个数组的末尾的位置//因为ptr的类型是int *，-1就是往后退一个整型的距离，那么就是指向的5的位置

题目二 

//在X86环境下//假设结构体的⼤⼩是20个字节//程序输出的结果是啥？struct Test{ int Num; char* pcName; short sDate; char cha[2]; short sBa[4];}*p = (struct Test*)0x100000;//在这里括号前面的是结构体，加上*就是结构体指针类型，创建变量p//先将0x100000强制转换为结构体指针，再为b进行赋值，现在p里面放的就是0x100000这个地址int main(){ printf("%p\n", p + 0x1);//00100014 //指针+1和类型有关系 //整数+1就是+1 //0x1是16进制的1 //因为p是一个结构体指针，因为前面说了结构体的大小是20字节 // 那么p+1就是就是跳过跳过一个结构体20个字节 //0x100014//因为这个是16进制的，所以加20个字节就是在这个基础上+14//4*16的0次方+1*16的1次方就是20 //00100014 printf("%p\n", (unsigned long)p + 0x1);//0x00100001 //现在将p强制类型转换为整型，那么整型+1就是+1 //那么得到的就是0x00100001 printf("%p\n", (unsigned int*)p + 0x1);//00100004 //将p强制类型转换为int * //+1跳过一个unsigned int*类型的指针变量，是4个字节 return 0;}

题目三 

#include <stdio.h>int main(){ int a[3][2] = { (0, 1), (2, 3), (4, 5) }; //仔细看，这里用的是小括号不是大括号 //那么这里就成逗号表达式了 //(0, 1)的结果就是1 //(2, 3)的结果就是3 //(4, 5)的结果就是5 //int a[3][2] = { 1,3,5 }; //那么这个二维数组剩下的位置就被0给填充了 //1 3 //5 0 //0 0 int* p;//指针 p = a[0]; //a[0]是第一行的数组名， // 没有sizeof // 没有& // // 那么表示的就是首元素的地址 //那么p里面存的就是1的地址 printf("%d", p[0]); //p[0]===*p(0)--指向的还是1的位置 //那么打印出来的就是1 return 0;}

题目四 

//假设环境是x86环境，程序输出的结果是啥？#include <stdio.h>int main(){ int a[5][5];//5行5列 //每一行的数组名分别是a[0]、a[1]、a[2]、a[3]、a[4] int(*p)[4];//p是一个数组指针，p指向的数组有4个元素，每个元素是int p = a; //a是数组名，这个二维数组的数组名，就是第一行的地址，第一行整个一维数组的地址 //第一行的地址的类型就是一个数组指针int(*)[5] //p的类型是int(*)[4] a的类型是int(*)[5] //不管a原来是什么类型，现在赋值给p，那么现在就是p说的算 //因为a指向的是第一行的位置，那么p同样也指向那里 //对于p来说，一行只有4个元素 //p+1就是跳过一行，每行四个元素 printf("%p,%d\n", &p[4][2] - &a[4][2], &p[4][2] - &a[4][2]); //FFFFFFFC,-4 //p[4][2]==*(*(p+4)+2)-----解引用p+4就相当于拿到那一行的数组名 //两个地址相减是地址直接的元素个数，这中间差了4个元素 //小地址减去大地址得到的是-4 //第一个代码是打印地址的，因为相减的结果是-4，存在内存里面，那么直接把存放-4的地址打印出来了 //-4在内存里面存的是补码 //11111111111111111111111111111100 //打印地址直接将内存里面的这个二进制补码直接当成地址 //4个二进制的1就是一个F，最后剩下的1100就是12，转换成6进制就是C return 0;}//考察的是指针的运算，数组指针+1跳过的是多少//就是跳过一个指针类型，在这里p+1就是跳过一行

 题目五

#include <stdio.h>int main(){ int aa[2][5] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };//两行5列 int* ptr1 = (int*)(&aa + 1); //&aa就是取出整个二维数组的地址，+1就是跳过整个二维数组 //&aa+1得到的还是二维数组的地址，将这个地址强制类型转换为int * //因为&aa+1跳过的是整个数组，那么指向的位置就是这个二维数组的末尾 //因为被强制转换为int *后再赋值给ptr1,那么赋值后ptr1指向的位置也是这个二维数组的末尾 // int* ptr2 = (int*)(*(aa + 1));//aa+1--->aa[1]---第二行的数组名---第二行首元素的地址 //aa是数组名，表示的是首元素的地址，就是第一行的地址 //那么aa+1就是第一行的地址+1指向的就是第二行的地址 //那么对其进行解引用得到的就是第二行整个一维数组 //因为这个第二行的一维数组本身就是整型，那么前面的int *可以忽略 //现在将(int*)(*(aa + 1))赋值给ptr2，那么ptr2也是指向的第二行的数组 //aa + 1可以理解为aa[1]，就是第二行的数组名，就是第二行数组首元素的地址，就是指向的6 printf("%d,%d", *(ptr1 - 1), *(ptr2 - 1));//10,5 //在这里，因为ptr1指向的是数组的末尾，并且ptr1是整型指针，那么ptr1-1指向的就是10的位置 //那么对其进行解引用得到的就是10 //因为ptr2指向的是6，那么ptr2-1得到的就是5的地址，对其进行解引用得到的就是5 return 0;}

题目六 

#include <stdio.h>int main(){ char* a[] = { "work","at","alibaba" }; //正常是不能这么放的，那么就是把每个字符串的首元素地址存在这个指针数组里面了 //这里定义的指针数组里面存的分别是w、a、a的地址 char** pa = a;//a是数组名，表示的是首元素的地址，就是第一个元素的地址 //首元素的地址是char*类型的，那么存在pa里面，那么pa就是一个二级指针 //那么char**pa指向的就是首元素 pa++; //pa指向的是第一个元素，那么++就是指向的第二个元素，就是跳过提个char*类型的指针 //那么下面的*pa得到的就是第二个元素的地址 printf("%s\n", *pa);//at //得到了地址，那么就从地址开始打印对饮的字符串 return 0;}

 题目七--最难的

#include <stdio.h>int main(){ char* c[] = { "ENTER","NEW","POINT","FIRST" };//每个元素是char* //存放的是每个字符串首字符的地址， //分别是E、N、P、F char** cp[] = { c + 3,c + 2,c + 1,c }; //c是上面的指针数组的数组名，指向的就是首元素的地址，指向的就是第一个字符串 //c指向的就是"ENTER" //c+1指向的就是"NEW" //c+2指向的就是"POINT" //c+3指向的就是"FIRST" //将c里面首元素的地址存放在cp里面，那么cp的类型就是一个二级指针 char*** cpp = cp; //cp是数组名，表示的是首元素的地址，将二级指针的地址放在三级指针内 //cpp指向的是首元素的地址，就是c+3 //下面的++和--会有副作用的，会改变指 //int a=5 ++a 这个动作完了之后a的值就变为6了 printf("%s\n", **++cpp);//POINT //* * ++ cpp //先算++cpp,cpp本来放的是c+3的地址，那么现在进行++之后，就指向了c+2的地址 // 然后解引用，因为cpp现在指向的是c+2的地址，那么第一次解引用就得到了c+2 // 第二次解引用就是对c+2解引用，得到的就是"POINT" // // // printf("%s\n", *-- * ++cpp + 3);//ER //因为加法的优先级比较低，所以先算前面的 // 所以先算++，再解引用，再--，再解引用 // // 因为上面的cpp已经进行++操作了，指向的是c+2，那么再次++就是指向的c+1了 // 那么现在已经得到了c+1的地址了 // 现在进行解引用通过地址找到c+1， // // 原本放的是c+1,现在--就变成c了，就没有c+2了，--就是自减，c+1变成c了 // c是指向的是"ENTER"这个字符串首元素E的地址，那么解引用完+3指向的就是E // //那么就是从E开始打印，所以只能打印ER // // // // // // printf("%s\n", *cpp[-2] + 3);//ST //*cpp[-2]是**(cpp+(-2))就是**(cpp-2) // // 一开始cpp指向的是原先的c+1的地址，但是c+1自减了1，就成c了，那么现在cpp指向的就是c的地址了 // 那么cpp-2得到的就是c+3的地址 // 这里的cpp-2不会导致cpp的改变，还是指向c // // 那么cpp-2得到的是c+2的地址，解引用得到的就是c+3 // c+3指向的是这串字符串首元素字符F的地址---"FIRST" // // 最后F的地址+3就是S // 那么打印出来的就是ST // // 这里最关键的就是*cpp[-2]这个的理解 // printf("%s\n", cpp[-1][-1] + 1);// EW //cpp[-1][-1] + 1 //转换形式 // *(*(cpp-1)-1)+1 // 这里的cpp指向的是c的位置 // 那么cpp-1就指向了c+2的位置 // // *(cpp-1)拿到了c+2 // 那么就变成下面这样了 // *(（c+2）-1)+1 // c+2-1得到了c+1,就是现在的cpp指向的位置 // // c+1指向的就是"NEW" //对c+1进行解引用就拿到了"NEW"--N的地址 //然后N的地址+1得到的就是E的地址 //然后打印出来的就是EW return 0;}