【C语言进阶】——指针（三) (练习篇）

推荐原创

Perceus 2021-08-18 15:37:50 博主文章分类：【 C语言】 ©著作权

文章标签 C语言指针指针练习题指针进阶 文章分类 C/C++ 后端开发

©著作权归作者所有：来自51CTO博客作者Perceus的原创作品，请联系作者获取转载授权，否则将追究法律责任

(目录)

前言

本篇文章的内容为指针进阶的相关练习题目，主要是进行指针的练习和巩固，继续上两篇指针相关的内容练习。【C语言进阶】——指针（一） (字符指针，数组指针，指针数组) 【C语言进阶】——指针（二） (函数指针，回调函数，qsort排序)

一、指针和数组经典笔试题解析：

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.& 数组名-- - 此时数组名表示整个数组。 注意：上面这两种例外的情况都需要 sizeof / &后面直接跟数组名，如果不是直接 + 数组名，则不是表示整数数组。 除了上面两个例外情况外，余下遇到的所有情况数组名均表示首元素地址

详解及结果展示：

#include<stdio.h>
int main()
{
	//一维数组
	int a[] = { 1,2,3,4 };
	printf("%d\n", sizeof(a));
	// 16 sizeof(数组名)，数组名表示整个数组，大小为4*4=16个字节
	printf("%d\n", sizeof(a + 0));
	//4/8 此时数组名表示首元素地址，a+0首元素地址+0仍表示首元素地址，地址大小为4/8个字节
	printf("%d\n", sizeof(*a));
	// 4  此时数组名表示首元素地址,*a表示首元素，为int类型，大小为4个字节
	printf("%d\n", sizeof(a + 1));
	//4/8 此时数组名表示首元素地址，a+1 首元素地址+1表示第二个元素地址，地址大小为4/8个字节
	printf("%d\n", sizeof(a[1]));
	//4 此时数组名表示首元素地址 a[1]表示第二个元素，为int类型，大小为4个字节
	printf("%d\n", sizeof(&a));
	//4/8 &数组名表示取出数组的地址，地址大小为4/8个字节
	printf("%d\n", sizeof(*&a));
	//16 &a是取出数组地址，*&a是对数组地址解引用，得到是数组，sizeof(数组)计算数组大小--16
	printf("%d\n", sizeof(&a + 1));
	//4/8 &a是取出数组地址,&a+1表示跳过整个数组，指向整个数组后面的地址，地址大小为4/8个字节
	printf("%d\n", sizeof(&a[0]));
	//4/8 &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>
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;
}

详解及结果展示：

#include<stdio.h>
int main()
{
	//字符数组
	char arr[] = { 'a ', 'b', 'c', 'd', 'e', 'f' };
	printf("%d \n", sizeof(arr));
	//6  计算的是数组大小，每个元素是一个字符，6*1=1
	printf("%d\n", sizeof(arr + 0));
	//4/8 arr+0还是表示首元素地址，地址大小是4/8个字节
	printf("%d\n", sizeof(*arr));
	//1 *arr表示首元素，类型是char，char大小是1个字节
	printf("%d\n", sizeof(arr[1]));
	//1 arr[1]表示第二个元素，类型是char，char大小是1个字节
	printf("%d\n", sizeof(&arr));
	//4/8 &arr表示取出数组的地址，地址大小是4/8个字节
	printf("%d\n", sizeof(&arr + 1));
	//4/8 &arr表示取出数组的地址,&arr+1表示跳过整个数组，到数组后面的地址，地址大小是4/8个字节 
	printf("%d \n", sizeof(&arr[0] + 1));
	//4/8 &arr[0]表示取出首元素的地址，&arr[0]+1表示取出第二个元素的地址，地址大小是4/8个字节
    return 0;
}

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

strlen函数是求字符串长度，需要找到 ' /0 '

#include<stdio.h>
#include<string.h>
int main()
{
	//字符数组
	char arr[] = { 'a ', 'b', 'c', 'd', 'e', 'f' };
    printf("%d\n", str1en(arr));
	printf("%d\n", strlen(arr + 0));
	printf("%d\n", str1en(*arr));
	printf("%d\n", strlen(arr[1]));
	printf("%d\n", str1en(&arr));
	printf("%d\n", str1en(&arr + 1));
	printf("%d\n", str1en(&arr[0] + 1));
    return 0;
}

详解及结果展示：

#include<stdio.h>
#include<string.h>
int main()
{
	//字符数组
	char arr[] = { 'a ', 'b', 'c', 'd', 'e', 'f' };
	printf("%d\n", strlen(arr));
	//随机值， arr表示首元素地址，数组中没有\0，所以用strlen计算长度的时候不知道会在哪里停止，所以是随机值
	printf("%d\n", strlen(arr + 0));
	//随机值， arr+0表示首元素地址，数组中没有\0，所以用strlen计算长度的时候不知道会在哪里停止，所以是随机值
	printf("%d\n", str1en(*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',所以是随机值
	return 0;
}

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

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

	return 0;
}

详解及结果展示：

#include<stdio.h>
int main()
{
	char arr[] = "abcdef";
	printf("%d\n", sizeof(arr));
	//7  用字符串来初始化字符串数组时，最后会自动添加字符串结束标志'\0'
	//数组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表示首元素，arr首元素是一个字符char类型'a',大小是1个字节
	printf("%d\n", sizeof(arr[1]));
	//1  arr[1]表示第二个元素，arr首元素是一个字符char类型'a',大小是1个字节
	printf("%d \n", sizeof(&arr));
	//4/8  &arr表示取出数组的地址，地址的大小是4/8个字节
	printf("%d\n", sizeof(&arr + 1));
	//4/8   &arr + 1表示跳过数组的地址，得到数组后面的地址，地址的大小是4/8个字节
	printf("%d\n", sizeof(&arr[0] + 1));
	//4/8   &arr[0]表示首元素地址，&arr[0] + 1表示第二个元素的地址，地址的大小是4/8个字节
	return 0;
}

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

#include<stdio.h>
#include<string.h>
int main()
{
	char arr[] = "abcdef";
	printf("%d\n", strlen(arr));
	printf("%d\n", strlen(arr + 0));
	printf("%d\n", strlen(*arr));
	printf("%d\n", str1en(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", strlen(arr));
	//6 数组arr中实际包含"abcdef \0"，strlen在往后找\0的时候，经过6个char刚好找到\0
	//strlen在计算字符串长度的时候，'\0'不计算到长度中
	printf("%d\n", strlen(arr + 0));
	//6 arr + 0表示首元素地址，与'\0'差6个字符，所以strlen计算长度为6
	printf("%d\n", strlen(*arr)); 
	//错误写法 *arr表示首元素，为字符‘a’，ASCII码是97，strlen会将97当作地址来处理
	//此时会造成越界访问，运行时会报错
	printf("%d\n", str1en(arr[1])); 
	//错误写法 arr[1]表示第二个元素，为字符‘b’，ASCII码是98，strlen会将98当作地址来处理
	//此时会造成越界访问，运行时会报错
	printf("%d\n", strlen(&arr));
	//6 &arr取出数组的地址，strlen在接收地址的时候是char*,会将数组的地址当作char*来使用
	//往后寻找'\0',经过6个char刚好找到\0
	printf("%d\n", strlen(&arr + 1));
	//随机值 &arr + 1跳过数组得到数组后面的地址，什么时候会遇到'\0'不确定，所以是随机值
	printf("%d\n", strlen(&arr[0] + 1));
	//5  &arr[0] + 1表示第二个元素的地址，经过5个char遇到'\0'，所以strlen计算长度为5
	return 0;
}

6、请写出下面程序执行的结果

#include<stdio.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));
	return 0;
}

详解及结果展示：

#include<stdio.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+1是一个地址，字符'b'的地址，地址大小为4/8
	printf("%d\n", sizeof(*p));
	//1  *p表示字符'a',类型是char，大小为1个字节
	printf("%d\n", sizeof(p[0]));
	//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
	return 0;
}

7、请写出下面程序执行的结果

#include<stdio.h>
#include<string.h>
int main()
{
	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));
	return 0;
}

详解及结果展示：

#include<stdio.h>
#include<string.h>
int main()
{
	char* p = "abcdef";
	//指针变量p存放的不是常量字符串"abcdef"本身，而是存放其首元素的地址,
	//即字符串"abcdef"中字符'a'的地址
	printf("%d\n", strlen(p));
	//6 p存储的是'a'的地址，strlen从a开始往后找6个字符，找到'\0'
	//所以strlen计算的字符串长度为6
	printf("%d\n", strlen(p + 1));
	//5 p + 1是'b'的地址,strlen从b开始往后找5个字符，找到'\0'
	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;
}

8、请写出下面程序执行的结果

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>
int main()
{
	//二维数组
	int a[3][4] = { 0 };
	printf("%d\n", sizeof(a));
	//3*4*4=48
	printf("%d\n", sizeof(a[0][0]));
	//4
	printf("%d \n", sizeof(a[0]));
	//4*4=16  a[0]相当于第一行作为一维数组的数组名，
	//sizeof(arr[0])把数组名单独放在sizeof()内，计算的是第一行的大小
	printf("%d\n", sizeof(a[0] + 1));
	//4/8   a[0]+1， a[0]放到表达式中了，是第一行作为数组的数组名，此时表示首元素地址
	//a[0]+1表示第一行第二个元素的地址，地址的大小为4/8
	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即第一行数组的地址，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   假设有第四行的数组，此时第四行数组的大小是4*4=16
	//sizeof操作符()内部不参与真实运算，所以实际上没有去越界访问
	return 0;
}

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

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

2.& 数组名-- - 此时数组名表示整个数组

3.除上面两个例外，数组名都是首元素地址

二、指针笔试题：

笔试题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
	//程序的结果是什么?
	//2,5
	return 0;
}

写代码三种境界 1.看代码是代码 2.看代码是内存 3.看代码还是代码

笔试题2：

#include<stdio.h>
//由于还没学习结构体，这里告知结构体的大小是20个字节
struct Test
{
	int Num;
	char* pcName;
	short sDate;
	char cha[2];
	short sBa[4];
}*p;                      

//假设p 的值为0x100000。如下表表达式的值分别为多少?
int main()
{
	printf("%p\n", p + 0x1);
	printf("%p\n", (unsigned long)p + 0x1);
	printf("%p\n", (unsigned int*)p + 0x1);
	return 0;
}

详解及结果展示：

这个题目考察的就是指针类型的意义，指针 + -的步长，指针 + 1到底是加几个字节。

#include<stdio.h>
//由于还没学习结构体，这里告知结构体的大小是20个字节
struct Test
{
	int Num;
	char* pcName;
	short sDate;
	char cha[2];
	short sBa[4];
}*p;
//假设p 的值为0x100000。如下表表达式的值分别为多少?
int main()
{
	p = (struct Test*)0x100000;
	printf("%p\n", p + 0x1);
	//0x1---十六进制的1，对应到十进制也是1
	//0x100014 此时p是结构体指针，结构体大小是20个字节，p+1其地址+20
	printf("%p\n", (unsigned long)p + 0x1);
	//0x100001，此时p被强制类型转换成 unsigned long 类型，p+1就是地址+1（整数+1）
	printf("%p\n", (unsigned int*)p + 0x1);
	//0x100004,p被强制类型转换成unsigned int*类型，p+1就是跳过一个int类型，地址+4
	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*)(&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，%x八进制打印结果也是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;
}

详解及结果展示：

a[3] [2] = { (0,1),(2,3),(4,5) }

#include<stdio.h>
int main()
{
	int a[3][2] = { (0,1),(2,3),(4,5) };
	//初始化{}内部的( )是逗号表示式，结果是最后一个表达式的结果
	//相当于{1,3,5}
	int* p;
	p = a[0];//a[0]是第一行数组名，没有&，没有单独放到sizeofn（）内，表示首元素地址
	//将二维数组第一行第一个元素的地址赋值给p
	printf("%d", p[0]);//等价*(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
	//用%d打印就是-4
	printf("%p,%d\n", &a[4][2] - &p[4][2], &a[4][2] - &p[4][2]);
	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" };
	char** pa = a;
	pa++;
	//pa指向a[1]的地址，a[1]存放"at"常量字符串的首地址
	printf("%s\n", *pa);
	//*pa找到a[1]，打印 at
	return 0;
}

笔试题8：

下面代码打印的结果是什么？

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

详解及结果展示：( 画图很重要！！！！！ )

#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);//先看（*++cpp）解引用拿到C+1内容，然后(*--c+1)，内容由（c+1）变成了（c）了，就由c的地址解引用指向"ENTER",最后+3移动3个字节，打印"ER"
	//"ER"
	printf("%s\n", *cpp[-2] + 3);
	//"ST"
	printf("%s\n", cpp[-1][-1] + 1);
	//"EW"
	return 0;
}

上一篇：【C语言进阶】——指针（二） (函数指针，回调函数，qsort排序)

下一篇：【C语言进阶】—— 字符操作函数+内存操作函数详解（吐血爆肝 !!!）

提问和评论都可以，用心的回复会被更多人看到评论

发布评论

相关文章

官方博客	全部文章	热门标签	班级博客
了解我们	网站地图	意见反馈

鸿蒙开发者社区	51CTO学堂
51CTO	软考资讯