【C语言进阶学习】二、指针的进阶（3）(数组与指针笔试题，熟练掌握sizeof与strlen以及指针的运用)

最新推荐文章于 2022-07-13 16:15:11 发布

Clumsy、笨拙

最新推荐文章于 2022-07-13 16:15:11 发布

阅读量188

点赞数 1

分类专栏： C语言文章标签： c语言

本文链接：https://blog.csdn.net/m0_58124165/article/details/120147673

版权

C语言专栏收录该内容

17 篇文章 1 订阅

订阅专栏

本篇文章的内容为指针进阶的相关练习题目，主要是进行指针的练习和巩固，继续上一篇指针相关的内容。

文章目录

一、数组笔试题

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

提示：
数组名表示首元素地址，但有两个例外：

sizeof(数组名)-- - 此时数组名表示整个数组
& 数组名-- - 此时数组名表示整个数组

除了上面两个例外情况外，余下遇到的所有情况数组名均表示首元素地址

解析：

#include <stdio.h>
int main()
{
	int a[] = { 1, 2, 3, 4 };
	printf("%d\n", sizeof(a));//16
	//数组名a单独放在sizeof内部，数组名表示整个数组，计算的是整个数组的大小
	printf("%d\n", sizeof(a + 0));//4/8
	//a表示首元素的地址，a+0还是首元素的地址，地址的大小是4/8字节
	printf("%d\n", sizeof(*a));//4
	//a表示首元素的地址，*a 就是首元素 ==> a[0] ,大小就是4
	//*a <==> *(a+0) <==> a[0]
	printf("%d\n", sizeof(a + 1));//4/8
	//a表示首元素的地址,a+1是第二个元素的地址，地址大小为4/8个字节
	printf("%d\n", sizeof(a[1]));//4
	//a[1] 就是第二个元素 - 4
	printf("%d\n", sizeof(&a));//4/8
	//&a - 数组的地址 - 4/8 - int(*)[4]
	printf("%d\n", sizeof(*&a));//16
	//*&a - &a是数组的地址，对数组的地址解引用拿到的是数组，所以大小时候16
	//等价于printf("%d\n", sizeof(a));
	
	printf("%d\n", sizeof(&a + 1));//4/8 
	//&a是数组的地址，&a+1 是数组的地址+1，跳过整个数组，虽然跳过了数组，还是地址  
	printf("%d\n", sizeof(&a[0]));//4/8
	//a[0]表示第一个元素，&a[0]则表示取出第一个元素的地址，地址大小为4/8个字节
	printf("%d\n", sizeof(&a[0] + 1));//4/8
	//&a[0]是第一个元素的地址，&a[0]+1就是第二个元素的地址，地址大小为4/8个字节

	return 0;
}

运行结果：
在这里插入图片描述

2.请写出下面程序执行的结果

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

详细解析及运行结果：

#include <stdio.h>
#include <string.h>
//字符数组
int main()
{
	char arr[] = { 'a', 'b', 'c', 'd', 'e', 'f' };
	printf("%d\n", sizeof(arr));//6
	//数组名arr单独放在sizeof内部，数组名表示整个数组，计算的是整个数组的大小
	printf("%d\n", sizeof(arr + 0));//4/ 8
	//arr表示首元素的地址，arr+0还是首元素的地址，地址的大小是4/8字节
	printf("%d\n", sizeof(*arr));//1
	//arr表示首元素的地址，*arr 就是首元素 ==> arr[0] ,大小就是1
	//*arr <==> *(arr+0) <==> arr[0]
	printf("%d\n", sizeof(arr[1]));//1
	//arr[1]就是下标为1的元素，所以arr[1]就是第二个元素，大小是1
	printf("%d\n", sizeof(&arr));//4/8
	//&arr - 取出整个数组的地址，地址的大小是4/8字节
	printf("%d\n", sizeof(&arr + 1));//4/8
	//&arr是数组的地址，&arr+1 是数组的地址+1，跳过整个数组，虽然跳过了数组，还是地址，地址的大小是4/8字节
	printf("%d\n", sizeof(&arr[0] + 1));//4/8
	//&arr[0]取出第一个元素的地址，&arr[0]+1就是第二个元素的地址，地址的大小是4/8字节

	printf("%d\n", strlen(arr));//随机值
	//arr表示首元素地址，数组中没有'\0'，所以用strlen计算长度的时候不知道会在哪里停止，所以是随机值
	printf("%d\n", strlen(arr + 0));//随机值
	//arr+0表示首元素地址，数组中没有'\0'，所以用strlen计算长度的时候不知道会在哪里停止，所以是随机值

	//printf("%d\n", strlen(*arr));
	//错误写法 ,strlen后面需要传递一个地址，*arr表示首元素，首元素是字符'a',其ASCII码是97，strlen会将97当作地址来处理
	//此时会造成越界访问，运行时会报错
	//printf("%d\n", strlen(arr[1]));
	//错误写法，strlen后面需要传递一个地址，而arr[1]表示数组第二个元素字符'b'，其ASCII码是98，strlen会将97当作地址来处理
	//此时会造成越界访问，运行时会报错

	printf("%d\n", strlen(&arr));//随机值
	//&arr表示取出整个数组的地址，而数组中没有'\0',所以用strlen计算长度的时候不知道会在哪里停止，所以是随机值
	printf("%d\n", strlen(&arr + 1));//随机值
	//&arr+1表示跳过整个数组后的地址，后面不知道什么时候遇到'\0',所以是随机值
	printf("%d\n", strlen(&arr[0] + 1));//随机值
	//&arr[0]+1表示第二个元素的地址，但数组中没有'\0'，所以用strlen计算长度的时候不知道会在哪里停止，所以是随机值
	return 0;
}

在这里插入图片描述

3.请写出下面程序执行的结果

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

详细解析及运行结果：

#include <stdio.h>
#include <string.h>
int main()
{
	char arr[] = "abcdef";
	printf("%d\n", sizeof(arr));//7
	//数组名arr单独放在sizeof内部，数组名表示整个数组，计算的是整个数组的大小
	//数组arr中实际存放 abcdef+\0 7个元素 所以sizeof(arr)求数组的大小是 1*7=7个字节
	printf("%d\n", sizeof(arr + 0));//4/8
	//arr+0表示首元素的地址，地址的大小是4/8个字节
	printf("%d\n", sizeof(*arr));//1
	//数组名arr不是单独放在sizeof内部，所以arr表示首元素的地址，*arr 就是首元素 ==> arr[0] ,大小就是1
	//*arr <==> *(arr+0) <==> arr[0]
	printf("%d\n", sizeof(arr[1]));//1
	//arr[1]表示数组第二个元素，所以大小为1
	printf("%d\n", sizeof(&arr));//4/8
	//&arr - 取出整个数组的地址，地址的大小是4/8字节
	printf("%d\n", sizeof(&arr + 1));//4/8
	//&arr是数组的地址，&arr+1 是数组的地址+1，跳过整个数组，虽然跳过了数组，还是地址，地址的大小是4/8字节
	printf("%d\n", sizeof(&arr[0] + 1));//4
	//&arr[0]+1表示第二个元素的地址，地址的大小是4/8字节

	printf("%d\n", strlen(arr));//6
	//数组arr中实际包含"abcdef \0"，arr表示数组首元素地址，strlen在往后找\0的时候，经过6个字符刚好找到\0
	//strlen在计算字符串长度的时候，'\0'不计算到长度中
	printf("%d\n", strlen(arr + 0));//6
	//arr+0表示首元素地址，strlen计算的是\0之前的字符个数，所以答案是6

	//printf("%d\n", strlen(*arr));
	// 错误写法，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));//6
	//&arr是取出整个数组的地址，但我们知道一开始指针指向的也是首元素的地址，所以strlen计算的是数组的长度,即6
	printf("%d\n", strlen(&arr + 1));//随机值
	//&arr+1是跳过整个数组得到数组后面的地址，什么时候会遇到'\0'不确定，所以是随机值
	printf("%d\n", strlen(&arr[0] + 1));//5
	//&arr[0]+1表示数组第二个元素的地址，即指针指向字符'b',所以计算的是从b开始到\0之间的字符个数

	return 0;
}

在这里插入图片描述

4.请写出下面程序执行的结果

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

详细解析及运行结果：

#include <stdio.h>
#include <string.h>
int main()
{
	char* p = "abcdef";
	//指针变量p存放的不是常量字符串"abcdef"本身，而是存放其首元素的地址,
	//即字符串"abcdef"中字符'a'的地址
	printf("%d\n", sizeof(p));
	//4/8 p是一个指针，指针大小32位/64位平台为4/8
	printf("%d\n", sizeof(p + 1));
	//4/8 p是一个字符指针，所以p+1跳过一个字节，指向字符'b'的地址，地址大小为4/8
	printf("%d\n", sizeof(*p));
	//1  * p表示字符'a', 类型是char，大小为1个字节
	printf("%d\n", sizeof(p[0]));//p[0]-->*(p+0) --> *p 1
	//1  p[0]常量字符串第一个元素，即'a',类型是char，大小为1个字节
	printf("%d\n", sizeof(&p));
	//4/8 &p表示取出指针p的地址，地址大小为4/8
	printf("%d\n", sizeof(&p + 1));
	//4/8 &p+1表示取出p后面的地址，地址大小为4/8
	printf("%d\n", sizeof(&p[0] + 1));
	//4/8 &p[0] + 1表示第二个元素的地址，即'b'的地址，地址大小为4/8

	printf("%d\n", strlen(p));
	//6 p存储的是'a'的地址，strlen从a开始往后计数，直到'\0'结束
	//所以strlen计算的字符串长度为6
	printf("%d\n", strlen(p + 1));
	//5  p + 1是'b'的地址,strlen从b开始往后计数，直到'\0'结束
	//所以strlen计算的字符串长度为5

	//printf("%d\n", strlen(*p));
	//错误写法 *p为字符‘a’，ASCII码是97，strlen会将97当作地址来处理
	//此时会造成越界访问，运行时会报错
	//printf("%d\n", strlen(p[0]));
	//错误写法 p[0]为字符‘a’，ASCII码是97，strlen会将97当作地址来处理
	//此时会造成越界访问，运行时会报错

	printf("%d\n", strlen(&p));
	//随机值  取出p的地址，传给strlen，strlen在往后寻找'\0', 不知道什么时候遇到'\0',所以是随机值
	printf("%d\n", strlen(&p + 1));
	//随机值 取出p后面的地址，传给strlen，strlen在往后寻找'\0',不知道什么时候遇到'\0'，所以是随机值
	printf("%d\n", strlen(&p[0] + 1));
	//5  p[0]表示首元素，&p[0]表示首元素地址，&p[0] + 1表示第二个元素'b'的地址
	//strlen从'b'开始计算字符串长度
	return 0;
}

在这里插入图片描述

5.请写出下面程序执行的结果

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

注：二维数组的数组名表示首元素地址时，首元素指的是第一行数组，也就是说首元素可以看作是一个一维数组，数组名表示的是第一行数组的地址

在这里插入图片描述

详细解析及运行结果：

#include <stdio.h>
#include <string.h>
int main()
{
	//二维数组
	int a[3][4] = { 0 };
	printf("%d\n", sizeof(a));//3*4*4=48
	//a数组名单独放在sizeof内部，表示求整个二维数组的大小
	printf("%d\n", sizeof(a[0][0]));//4
	//a[0][0]表示第一行第一个元素
	printf("%d \n", sizeof(a[0]));//4*4=16
	//a[0]相当于把第一行作为一维数组的数组名，
	//sizeof(a[0])把数组名单独放在sizeof()内，计算的是第一行的大小
	printf("%d\n", sizeof(a[0] + 1));//4/8
	//a[0]是第一行的数组的数组名，并没有单独放在sizeof内部，也没有&，所以a[0]表示首元素的地址
	//就是第一行这个数组第一个元素的地址
	//所以a[0] + 1就是第一行，第二个元素的地址
	printf("%d\n", sizeof(*(a[0] + 1)));//4
	//a[0]+1表示第一行第二个元素的地址 *(a[0] + 1)表示第一行第二个元素，类型是int
	printf("%d\n", sizeof(a + 1));//4/8 
	//二维数组的数组名a表示【首元素】地址，即第一行的地址，则a + 1表示第二行的地址，地址的大小为4/8
	printf("%d\n", sizeof(*(a + 1)));//4*4=16
	//a + 1表示第二行的地址,*(a + 1)表示第二行数组，数组有4个元素，均为int类型
	printf("%d\n", sizeof(&a[0] + 1));//4/8 
	//a[0]放到表达式中了，是把第一行作为数组的数组名，此时表示首元素地址
	//&a[0] + 1表示第二行数组的地址，地址的大小是4/8
	printf("%d\n", sizeof(*(&a[0] + 1)));//4*4=16
	//&a[0] + 1表示第二行数组的地址,*(&a[0] + 1)表示第二行数组，数组有4个元素，均为int类型
	printf("%d\n", sizeof(*a));//4*4=16
	//a表示二维数组首元素地址，即第一行数组的地址，*a表示第一行数组，大小为4*4
	printf("%d \n", sizeof(a[3]));//4*4=16
	//a[3]假设存在，就是第四行的数组名，sizeof(a[3])，就相当于把第四行的数组名单独放在sizeof内部，此时第四行数组的大小是4*4=16
	//sizeof操作符()内部不参与真实运算，所以实际上没有去越界访问，不会报错
	return 0;
}

在这里插入图片描述
总结：

二、指针笔试题

笔试题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;
}

详细解析及运行结果：
在这里插入图片描述

#include <stdio.h>
int main()
{
	int a[5] = { 1, 2, 3, 4, 5 };
	int* ptr = (int*)(&a + 1);
	//&a表示取出数组a的地址，&a+1表示跳过该数组，指向数组后面的地址
	printf("%d,%d", *(a + 1), *(ptr - 1));
	// 此时a表示首元素地址，a + 1表示第二个元素地址， * (a + 1)表示第二个元素-- - 2
	// ptr表示数组后面的地址，ptr - 1表示数组末尾的地址，* (ptr - 1)表示数组最后一个元素---5
	return 0;
}

在这里插入图片描述

笔试题2:

#include<stdio.h>
struct Test
{
	int Num;
	char* pcName;
	short sDate;
	char cha[2];
	short sBa[4];
}*p;
//已知结构体Test类型的变量大小是20个字节
//假设p 的值为0x100000。如下表表达式的值分别为多少?
int main()
{
	p = (struct Test*)0x100000;
	printf("%p\n", p + 0x1);//0x1---十六进制的1，对应到十进制也是1	
	printf("%p\n", (unsigned long)p + 0x1);
	printf("%p\n", (unsigned int*)p + 0x1);
	return 0;
}

详细解析及运行结果：

这道题考察的就是指针+ -整数的意义，指针 + 1到底是加几个字节。

struct Test
{
	int Num;
	char* pcName;
	short sDate;
	char cha[2];
	short sBa[4];
}*p;
//已知结构体Test类型的变量大小是20个字节
//假设p 的值为0x100000。如下表表达式的值分别为多少?
int main()
{
	p = (struct Test*)0x100000;
	printf("%p\n", p + 0x1);//0x1---十六进制的1，对应到十进制也是1
	//p是一个结构体指针，所以p+1代表跳过一个结构体大小，
	//及 0x100000 + 20  而20转换为十六进制就是14
	//所以打印  0x00100014
	printf("%p\n", (unsigned long)p + 0x1);
	//将p被强制类型转换成 unsigned long 类型，所以p+1就是整型+1
	//所以打印  0x00100001
	printf("%p\n", (unsigned int*)p + 0x1);
	//将p强制类型转换成unsigned int*类型的指针，所以p+1就是跳过一个整型大小
	//及 0x100000 + 4
	//所以打印  0x00100004
	return 0;
}

在这里插入图片描述

笔试题3：

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

详细解析及运行结果：
在这里插入图片描述

#include<stdio.h>
int main()
{
	int a[4] = { 1,2,3,4 };
	int* ptr1 = (int*)(&a + 1);
	//&a表示取出数组的地址，&a+1表示跳过数组，到数组后面的地址，类型是int(*)[4]
	//(int*)(&a+1)将这个地址强制类型转换成int*，放到ptr1里面
	int* ptr2 = (int*)((int)a + 1);
	//a表示数组首元素地址，（int）a将这个地址强制类型转换成int类型
	//(int)a + 1,就是地址+1
	//(int*)((int)a + 1)将这个地址强制类型转换成int*，放到ptr2里面
	printf("%x,%x", ptr1[-1], *ptr2);
	//4 ptr[-1]==>*(ptr-1)得到数组最后一个元素，即4
	//02 00 00 00 *ptr2得到的就是被强制类型转换为int类型的地址的值+1，地址的单位是字节
	//ptr2解引用就是访问 00 00 00 02 （小端字节序存储），打印的时候就是 02 00 00 00
	return 0;
}

在这里插入图片描述

笔试题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;
}

详细解析及运行结果：

#include<stdio.h>
int main()
{
	int a[3][2] = { (0,1),(2,3),(4,5) };
	//初始化{}内部的( )是逗号表示式，结果是最后一个表达式的结果
	//相当于{1,3,5}
	//如果想写成数组形式是：{{0，1}，{2，3}，{4，5}}
	int* p;
	p = a[0];
	//将二维数组第一行第一个元素的地址赋值给p
	printf("%d", p[0]);
	//1
	return 0;
}

在这里插入图片描述

笔试题5：

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

详细解析及运行结果：
在这里插入图片描述

#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]);
	//指针-指针得到两者之间元素的个数
	//&p[4][2] - &a[4][2]之间相差4个元素，且p<a 得到-4 用%p打印就是FFFFFFFC
	//%p是打印地址，其实是和打印无符号整型一样
	//用%d打印就是-4
	return 0;
}

在这里插入图片描述

笔试题6：

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

详细解析及运行结果：
在这里插入图片描述

#include<stdio.h>
int main()
{
	int aa[2][5] = { 1,2,3,4,5,6,7,8,9,10 };
	int* ptr1 = (int*)(&aa + 1);
	//&aa + 1 跳过整个数组，指向数组后面的地址
	int* ptr2 = (int*)(*(aa + 1));
	//*(aa + 1) 等价与aa[1]，第二行首元素地址
	printf("%d,%d", *(ptr1 - 1), *(ptr2 - 1));
	//10,5
	return 0;
}

在这里插入图片描述

笔试题7：

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

详细解析及运行结果：
在这里插入图片描述

#include<stdio.h>
int main()
{
	char* a[] = { "work","at","alibaba" };
	//a是一个字符指针数组，每个元素类型是char*类型，存放的是每个字符串的首元素字符的地址
	char** pa = a;
	pa++;
	//pa指向a[1]的地址，a[1]存放"at"常量字符串的首地址
	printf("%s\n", *pa);
	//*pa找到a[1]，打印 at
	return 0;
}

在这里插入图片描述

笔试题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;
}

详细解析及运行结果：
在这里插入图片描述

#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);
	//"POINT"
	printf("%s\n", *-- * ++cpp + 3);
	//"ER"
	printf("%s\n", *cpp[-2] + 3);
	//"ST"
	printf("%s\n", cpp[-1][-1] + 1);
	//"EW"
	return 0;
}