深入理解指针(5)

在之前的深入理解指针(4)中我们学习了回调函数相关知识，并且学会了如何使用库函数qsort，以及模拟实现了qsort，接下来在本篇中将对srtlen和sizeof进行细致的讲解，并对相关的题型进行讲解，一起加油吧！！！

---

1.strlen与sizeof的区别

1.sizeof

在之前学习操作符的时候就已经了解过了sizeof这个操作符，sizeof计算变量所占内存内存空间大小，单位是字节 ，例如当变量类型是整形时，变量大小和变量类型的大小都是一样的

#inculde <stdio.h>
int main()
{
int a = 10;
printf("%d\n", sizeof(a));
printf("%d\n", sizeof(int));
return 0;
}

例如以上代码打印结果都是4

---

2.strlen

strlen是一个用来求字符串长度的函数，计算的是字符串**\0之前的字符的个数**
strlen 函数会从起始地址一直向后找**\0** 字符，直到找到为止，所以可能存在越界查找

函数的原型如下：

size_t strlen(const char * str );

#include<string.h>
#include<stdoio.h>
int main()
{
 char arr1[]="abc";
 char arr2[]={'a','b','c'};
 printf("%d\n",strlen(arr1));
 printf("%d\n",strlen(arr2));

 return 0;
}

在以上代码中数组arr1中存放的是字符串，数组的末尾包含\0 ;而数组arr2中存放的是字符,数组的末尾不包含\0 ，因此当使用strlen函数时，当参数为arr1时，可以求出地址arr1到\0之前元素的个数为3，所以打印结果为3. 但当参数为arr2时，由于原arr2数组中无\0因此会一直向后直到找到\0为止，所以打印出结果为随机数

---

3.sizeof与strlen的区别

|--------------------------|----------------------------------------|
| sizeof | strlen |
| sizeof是操作符 | strlen是库函数，使⽤需要包含头⽂件 string.h |
| sizeof计算操作数所占内存的大小，单位是字节 | srtlen是求字符串（字符数组）⻓度的，统计的是 \0 之前字符的个数 |
| 不关注内存中存放什么数据 | 关注内存中是否有 \0 ，如果没有 \0 ，就会持续往后找，可能 会越界 |

---

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

2.1 一维数组

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

以上各代码输出结果及解析：
int a[ ] = {1,2,3,4};

printf("%d\n",sizeof(a));

数组名a单独放在sizeof中，a表示的是整个数组，计算的是整个数组的大小，单位是字节，又因为数组a中元素类型都为int大小为4字节，所以整个数组大小就为16字节，打印结果为16

printf("%d\n",sizeof(a+0));

数组名a不是单独放在sizeof内，所以a表示的是数组首元素的地址，所以sizeof求出的是数组首元素指针的大小，在32位环境下为4字节，在64位环境下位8字节，打印结果为4或者8

printf("%d\n",sizeof(*a));

数组名a不是单独放在sizeof内，在此a表示的是数组首元素的地址，所以对a解引用后得出的就是数组首元素，因为数组元素为int类型，所以求出结果为4，打印结果为4

printf("%d\n",sizeof(a+1));

在此a表示的是数组首元素的地址，在对指针a加一后表示的是数组的第二个元素的地址，所以sizeof求出的是数组首元素指针的大小，在32位环境下为4字节，在64位环境下位8字节，打印结果为4或者8

printf("%d\n",sizeof(a[1]));

在此a[1]表示的是数组的第一个元素1，因为数组元素为int类型，所以结果为4，打印结果为4

printf("%d\n",sizeof(&a));

取地址取出的是整个数组的地址，所以sizeof求出的是整个数组的指针大小，在32位环境下为4字节，在64位环境下位8字节，打印结果为4或者8

printf("%d\n",sizeof(*&a));

有两种角度分析以上代码：

1.在此次*可以与&消除后sizeof中就剩a，这里的a单独放在sizeof内，sizeof求出的是整个数组的大小，为16字节，打印结果为16

2.在此&a取出的是整个数组的地址，类型为int(*)[4],解引用&a后访问的就是整个数组，数组大小为16字节，打印结果为16

printf("%d\n",sizeof(&a+1));

首先&a取出的是整个数组的地址，之后&a+1后的步长就为sizeof(int(*)[4]),为16字节，所以&a+1表示的是跳过整个数组后那个位置的地址，sizeof(&a+1)求出的就是这个位置地址的大小，在32位环境下为4字节，在64位环境下位8字节，打印结果为4或者8

printf("%d\n",sizeof(&a[0]));

a[0]表示的是数组首元素1，&a[0]就是将首元素1的地址取出，因此sizeof(&a[0])求出的就是首元素的地址大小，在32位环境下为4字节，在64位环境下位8字节，打印结果为4或者8

printf("%d\n",sizeof(&a[0]+1));

a[0]表示的是数组首元素1，&a[0]就是将首元素1的地址取出，再对&a[0]+1得出的就是数组第二个元素的地址，在32位环境下为4字节，在64位环境下位8字节，打印结果为4或者8

---

2.2 字符数组

代码1

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

char arr[ ] = {'a','b','c','d','e','f'};

printf("%d\n", sizeof(arr));

**在此数组名单独在sizeodf内表示的是整个数组，有因为每个数组元素为char类型，大小为1字节，**所以结果就为6字节，输出结果为6

printf("%d\n", sizeof(arr+0));

**在此数组名arr不是单独放在sizeof内，因此arr表示的就是数组首元素的地址，又因为sizeof(arr)=sizeof(arr+0),求出的为首元素地址大小，**在32位环境下为4字节，在64位环境下位8字节，打印结果为4或者8

printf("%d\n", sizeof(*arr));

在此数组名arr不是单独放在sizeof内，因此arr表示的就是数组首元素的地址，再对arr解引用后表示的就是数组首元素，所以sizeof(*arr)计算的就是首元素大小，大小为1，输出结果为1

printf("%d\n", sizeof(arr[1]));

**arr[1]表示的是数组第二个元素b，因为数组arr每个元素类型为都为char，大小为1字节，**所以sizeof(arr[1])大小为1，输出结果为1

printf("%d\n", sizeof(&arr));

**在此&arr取出的是整个数组arr的地址，sizeof(&arr)求出的就是整个数组地址大小，**在32位环境下为4字节，在64位环境下位8字节，打印结果为4或者8

printf("%d\n", sizeof(&arr+1));

在此&arr取出的是整个数组arr的地址，再加一求出的是跳过整个数组那个位置的地址，

在32位环境下为4字节，在64位环境下位8字节，打印结果为4或者8

printf("%d\n", sizeof(&arr[0]+1));

**arr[0]表示的是数组第一个元素，再&得出首元素的地址，再对该地址加一得到的就是数组第二个元素的地址，**在32位环境下为4字节，在64位环境下位8字节，打印结果为4或者8

---

代码2：

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

char arr[ ] = {'a','b','c','d','e','f'};

printf("%d\n", strlen(arr));

在此数组名arr表示的是数组首元素的地址，由于字符数组arr种无\0，所以从首元素到\0之间的元素个数为随机值，输出结果为随机值

printf("%d\n", strlen(arr+0));

在此数组名arr表示的是数组首元素的地址，arr+0表示的还是首元素，由于字符数组arr种无\0，所以从首元素到\0之间的元素个数为随机值，输出结果为随机值

printf("%d\n", strlen(*arr));

在此*arr得出的是数组首元素a，在strlen中传参数不为指针时，程序会奔溃

printf("%d\n", strlen(arr[1]));

在此arr[1]表示的是数组第二个元素b，在strlen中传参数不为指针时，程序会奔溃

printf("%d\n", strlen(&arr));

在此&arr得出的是数组arr的地址，由于字符数组arr种无\0，所以从首元素到\0之间的元素个数为随机值，输出结果为随机值

printf("%d\n", strlen(&arr+1));

在此&arr得出的是数组arr的地址， **再加一求出的是跳过整个数组那个位置的地址，**由于字符数组arr种无\0，所以从这个元素到\0之间的元素个数为随机值，输出结果为随机值

printf("%d\n", strlen(&arr[0]+1));

在此&arr[0]得出的是数组首元素的地址，再加一得到的就是第二个元素的地址， 由于字符数组arr种无\0，所以从第二个元素到\0之间的元素个数为随机值，输出结果为随机值

---

代码3：

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

char arr[ ] = "abcdef";

printf("%d\n", sizeof(arr));

在此数组名arr表示的是数组首元素的地址，所以sizeof内求出的是整个数组的大小为6字节，输出结果为6

printf("%d\n", sizeof(arr+0));

在此数组名arr表示的是数组首元素的地址，arr+0表示的还是首元素地址，所以sizeof内求出的是整个数组的大小为6字节，输出结果为6

printf("%d\n", sizeof(*arr));

在此*arr得出的是数组首元素a，所以sizeof内求出的是数组首元素的大小为1字节，输出结果为1

printf("%d\n", sizeof(arr[1]));

在此arr[1]表示的是数组第二个元素b，所以sizeof内求出的是数组第二个元素的大小为1字节，输出结果为1

printf("%d\n", sizeof(&arr));

在此&arr得出的是整个数组arr的地址，在32位环境下为4字节，在64位环境下位8字节，打印结果为4或者8

printf("%d\n", sizeof(&arr+1));

在此&arr得出的是数组arr的地址， **再加一求出的是跳过整个数组那个位置的地址，**在32位环境下为4字节，在64位环境下位8字节，打印结果为4或者8

printf("%d\n", sizeof(&arr[0]+1));

在此&arr[0]得出的是数组首元素的地址，再加一得到的就是第二个元素的地址，所以sizeof内求出的是数组第二个元素的大小为1字节，输出结果为1

---

代码4：

char arr[] = "abcdef";
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));

char arr[ ] = "abcdef";

printf("%d\n", strlen(arr));

在此数组名arr表示的是数组首元素的地址，由于字符串arr末尾含有\0，所以从首元素到\0之间的元素个数为6，输出结果为6

printf("%d\n", strlen(arr+0));

在此数组名arr表示的是数组首元素的地址，arr+0表示的还是首元素，由于字符串arr末尾含有\0，所以从首元素到\0之间的元素个数为6，输出结果为6

printf("%d\n", strlen(*arr));

在此*arr得出的是数组首元素a，在strlen中传参数不为指针时，程序会奔溃

printf("%d\n", strlen(arr[1]));

在此arr[1]表示的是数组第二个元素b，在strlen中传参数不为指针时，程序会奔溃

printf("%d\n", strlen(&arr));

在此&arr得出的是数组arr的地址，由于字符串arr末尾含有\0，所以从首元素到\0之间的元素个数为6，输出结果为6

printf("%d\n", strlen(&arr+1));

在此&arr得出的是数组arr的地址， **再加一求出的是跳过整个数组那个位置的地址，而字符数组内的\0已经在该指针前，**所以到下一个\0之间的元素个数为随机值，输出结果为随机值

printf("%d\n", strlen(&arr[0]+1));

在此&arr[0]得出的是数组首元素的地址，再加一得到的就是第二个元素的地址， 由于字符串arr末尾含有\0， 所以从第二个元素到\0之间的元素个数为5，输出结果为5

---

代码5：

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

char *p = "abcdef";

在此字符指针中存放了一个常量字符串首元素的地址，指针p表示的是字符串首元素的地址

printf("%d\n", sizeof(p));

**在此计算的是指针变量p的大小，**在32位环境下为4字节，在64位环境下位8字节，打印结果为4或者8

printf("%d\n", sizeof(p+1));

p+1得到的是字符串中第二个元素b的地址，在32位环境下为4字节，在64位环境下位8字节，打印结果为4或者8

printf("%d\n", sizeof(*p));

**在此p表示的是字符串首元素a的地址，*p是对指针p进行解引用，得到的就是字符串的首元素，**在内存空间所占大小为1字节，输出结果为1

printf("%d\n", sizeof(p[0]));

**p[0]=*(p+0),在此p[0]得到的就是字符串的首元素，**在内存空间所占大小为1字节，输出结果为1

printf("%d\n", sizeof(&p));

在此&p得到的是指针变量p的地址， 在32位环境下为4字节，在64位环境下位8字节，打印结果为4或者8 （注：在此&p是一个二级指针）

printf("%d\n", sizeof(&p+1));

在此&p得到的是指针变量p的地址，后再加一是跳过了p变量，指向了p后面的地址，在32位环境下为4字节，在64位环境下位8字节，打印结果为4或者8

printf("%d\n", sizeof(&p[0]+1));

**在此p[0]=*(p+0，这时&就可以与*相抵消，得到sizeof(p+1),**p+1得到的是字符串中第二个元素b的地址，在32位环境下为4字节，在64位环境下位8字节，打印结果为4或者8

---

代码6：

char *p = "abcdef";
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));

char *p = "abcdef";

在此指针变量p存放的是常量字符串中a的地址，同时常量字符串末尾包含\0

printf("%d\n", strlen(p));

**strlen求出的是首元素到\0之间的元素个数，也就字符串中的元素个数为6，**输出结果为6

printf("%d\n", strlen(p+1));

**p+1得到的是字符串中第二个元素b的地址，strlen求出的是第二个元素到\0之间的元素个数，也就字符串中的元素个数为5，**输出结果为5

printf("%d\n", strlen(*p));

***p得到的是字符串的首元素a，**程序会奔溃

printf("%d\n", strlen(p[0]));

**在此p[0]=*(p+0),得到就是字符串的首元素a，**程序会崩溃

printf("%d\n", strlen(&p));

**在此&p得到的是指针变量p的地址，而在此地址中无\0需要向后找到\0才停止，所以结果为随机值，**输出结果为随机值

printf("%d\n", strlen(&p+1));

**在此&p得到的是指针变量p的地址，再加上一得到的是跳过过了变量p，指向了后边，****而在此地址中无\0需要向后找到\0才停止，所以结果为随机值，**输出结果为随机值

printf("%d\n", strlen(&p[0]+1));

**在此p[0]=*(p+0),&可与*相抵消，最终只剩strlen(p+1),****strlen求出的是第二个元素到\0之间的元素个数，也就字符串中的元素个数为5，**输出结果为5

---

2.3 二维数组

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]));

int a[3][4] = {0};

二维数组a可以看作是由3个一维数组组成的，每个一维数组有4个元素

printf("%d\n",sizeof(a));

**数组名单独放在sizeof内得出的是整个数组的大小，a数组元素类型为int，所以整个数组大小为48字节，**输出结果为48

printf("%d\n",sizeof(a[0][0]));

**在此a[0][0]=*(*(a+0)+0),得到的是数组第一个元素，该元素大小为4，**输出结果为4

printf("%d\n",sizeof(a[0]));

在此a[0]得到的是二维数组中的第一行的数组名，单独放在sizeof内，第一行有4个元素，大小为16字节，输出结果为16

printf("%d\n",sizeof(a[0]+1));

**在此a[0]+1=*(a+0)+1,得到是第一行的第二个元素的地址，**在32位环境下为4字节，在64位环境下位8字节，打印结果为4或者8

printf("%d\n",sizeof(*(a[0]+1)));

*(a[0]+1))=*(*(a+0)+1)得到的是二维数组内第一行的第二个元素，大小为4，输出结果为4

printf("%d\n",sizeof(a+1));

**在此a表示二维数组首元素的地址也就是数组第一行的地址，再加上一得到的就是数组第二行的的地址，**在32位环境下为4字节，在64位环境下位8字节，打印结果为4或者8

printf("%d\n",sizeof(*(a+1)));

a+1得到的是二维数组第二行的地址，再解引用后得到是二维数组内第二个一维数组的数组名，单独放在sizeof内求出是整个一维数组的大小，一共有4个元素，大小为16字节，输出结果为16

printf("%d\n",sizeof(&a[0]+1));

**在此&a[0]得到就是二维数组第一行的地址，再加一得到为第二行的地址，**在32位环境下为4字节，在64位环境下位8字节，打印结果为4或者8

printf("%d\n",sizeof(*(&a[0]+1)));

**在此&a[0]得到就是二维数组第一行的地址，再加一得到为第二行的地址，再进行解引用后得到是二维数组内第二个一维数组，sizeof求出的就是这个一维数组的大小，有4个元素，大小为16字节，**输出结果为16

printf("%d\n",sizeof(*a));

**在此a不是单独放在sizeof内，所以a表示的是二维数组首元素的地址即是第一个一维数组的地址，再进行解引用因为指针a类型为int(*)[4],所以sizeof求出的是数组第一行的大小，大小为16字节，**输出结果为16

printf("%d\n",sizeof(a[3]));

**a[3]=*(a+3),得到的是数组第四行的数组名，也有4个int类型的元素（****虽然a[3]不存在，但我们知道sizeof内部表达式时不会真正计算的）大小为16字节，**输出结果为16

3. 指针运算笔试题解析

3.1 题目1

#include <stdio.h>
//以上程序的结果是什么呢？
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表示数组首元素的地址，再加一解引用得到就是数组第二个元素2
&a+1原来的类型是int(*)[5]后强制类型转换为int*，这就改变了指针加减时的步长，所以str再减一步长就为4，得到的是数组第五个元素的地址，再解引用后就得到第五个元素5

所以输出结果为2 5

3.2 题目2

//在X86环境下
//假设结构体的⼤⼩是20个字节
//以上程序输出的结果是什么呢？
struct Test
{
int Num;
char *pcName;
short sDate;
char cha[2];
short sBa[4];
}*p = (struct Test*)0x100000;
int main()
{
printf("%p\n", p + 0x1);
printf("%p\n", (unsigned long)p + 0x1);
printf("%p\n", (unsigned int*)p + 0x1);
return 0;
}

在以上代码中先创建了一个struct Test的结构体类型 ，后再创建一个结构体指针变量p，并将0x00100000这个整形的16进制数字强制类型转换为struct Test*后存储在p指针变量内
因此对指针变量p+0x1，因为指针变量类型为struct Test*，该结构体大小为20字节 ，所以指针加1后步长为20字节 ，又因为%p打印的是16进制的数，所以指针变量变为0x00100014

将指针变量强制类型转换为unsigned long 后，因为对整型变量加一就是直接加一又因为%p打印的是16进制的数，所以变量就变为0x00100001

将指针变量强制类型转换为unsigned int*后，因为unsigned int的大小是4个字节 ，所以指针变量加一的步长是4个字节 ，又因为%p打印的是16进制的数，所以指针变量变0x00100004

最终输出结果为：
0x00100014
0x00100001
0x00100004

3.3 题目3

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

由于二维数组内存在逗号表达式，括号内最终结果为逗号最后的值
因此最终应为int a[3][2]={1,3,5}

所以p[0]就为数组中首元素1
输出结果为1

3.4 题目4

//假设环境是x86环境，程序输出的结果是啥？
#include <stdio.h>
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中，当a的类型是int(*)[5],而int(*)[4],两个变量类型不同，这时在变量p就会遵循int(*)[4]这个类型，&p[4][2]就是指针变量p跳过4个16字节后再跳过2个4字节得到处的地址，又因为&a[4][2]得到的是数组a第5行第2列的元素地址，这两地址处相减后就得到之间的元素个数为-4

%p就是将-4的补码按照16进制的方式打印出，因为4个二进制位数表示一个16进制数
所以补码转换为16进制就为：0xFFFFFFFC

输出结果为0xFFFFFFFC

3.5 题目5

#include <stdio.h>
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强制类型转换为int*后存储在指针变量ptr1中，再将 *(aa+1)也就是aa[1]强制类型转换为int*后存储在指针变量ptr2中，因此在对str1和str2减一时步长为4 ，再解引用后分别得到为10 5

所以输出结果为10 5

3.6 题目6

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

a是一个字符指针数组，存放的是w，a，a三个字符的地址 ，而pa指针变量是一个二级指针，存放p指针变量的地址，同时指向的是存放p中首元素w的地址的地址

再对pa++后就使得pa变量指向的为p中第二个元素，也就是存放a的地址的地址，再*pa后就得到a的地址，再%s打印就可以将字符串at打印出

输出结果为at

3.7 题目7

#include <stdio.h>
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;
}

以上图示就将各指针数组和指针变量之间的关系清晰的展现出

后先是**++cpp关系图就变为了以下形式

先是++cpp就使cpp指针变量指向为cp[1]，再*得到c+2,再*得到字符P的地址
之后 *--*++cpp+3关系图就变为了以下形式

先++cpp后就使cpp指针变量指向为cp[2]，再*得到cp[2],再--使cp[2]指向变为c[0],再*得到c[0]也就是字符E的地址,再对该地址+3就使指针指向了ENTER中的第四个字符

在 *cpp[-2]+3=**(cpp-2)+3关系图就变为了以下形式

先cpp-2后就使cpp指针变量指向为cp[0]，再*得到cp[0],再*得到c[3]也就是字符F的地址,再对该地址+3就使指针指向了ENTER中的第四个字符
cpp[-1][-1]+1=*(*(cpp-1)-1)+1关系图就变为了以下形式

先cpp-1后就使cpp指针变量指向为cp[1]，再*得到cp[1],再-1使cp[1]指向变为c[1],再*得到c[1]也就是字符N的地址,再对该地址+1就使指针指向了NEW中的第二个字符

所以以上代码输出结果为:
POINT
ER
ST
EW

以上就**深入理解指针(5)**的全部内容，希望看完以上内容你能有所收获，到此就是深入理解指针章节的全部内容了，感谢你的支持，接下来我将会继续带来c语言其他的知识，希望能得到你的点赞，收藏