【C语言学习】C语言指针（习题篇）

已于 2023-06-05 19:43:26 修改
阅读量1.1w 收藏 393
点赞数 92
分类专栏： C语言学习 文章标签： c语言 开发语言
于 2022-07-05 19:17:19 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_63726869/article/details/125613906
版权

🐱作者：一只大喵咪1201
🐱专栏：《C语言学习》
🔥格言：你只管努力，剩下的交给时间！
请添加图片描述

C语言指针（习题篇）

经过前面四篇文章对指针详细讲解，相信各位小伙伴已经了解到了各种各样的指针以及它们的使用方法，下面本喵带着大家做一些习题来检验下学习成果吧。

🐨指针和数组

🐼一维数组

习题一：

#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. &数组名
  2. sizeof(数组名)

这俩个特例中，数组名表示的是整个数组。

知道了这个知识点后便可以解决上面的代码，上面代码的输出结果是什么呢？可以自己尝试着做一下。
下面本喵进行一下详细的分析。

  • 首先创建了一个一维数组
int a[] = { 1,2,3,4 };

该数组有4个元素，每个元素的整型。

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

操作符sizeof中的操作数只有数组名，所以此时求的是整个数组所占内存空间的大小，结果是16，也就是16个字节。

printf("%d\n", sizeof(a + 0));
  • 操作数是数组名加一个整型0，所以不是单独的一个数组名，此时数组名的本质就是数组首元素的地址。
  • 首元素地址加一个0得到的还是首元素的地址。
  • 首元素的地址是一个int*类型的指针变量，所以其结果是4或者8，在32位平台上是4，在64位平台上是8。
printf("%d\n", sizeof(*a));
  • 操作数是数组名解引用，不是单独的数组名。
  • 此时数组名的本质是数组首元素的地址。
  • 对首元素地址解引用后得到的是数组中第一个元素。
  • 所以它的大小是一个整型的大小，结果是4。
printf("%d\n", sizeof(a + 1));
  • 操作数是数组名加整型1，不是单独的数组名
  • 此时数组名的本质是数组首元素的地址。
  • 加1后变成了数组中第二个元素的地址，也就是元素2的地址。
  • 该地址是int*类型的指针变量。
  • 所以大小是4或者8个字节（32位平台是4，64位平台是8）。
printf("%d\n", sizeof(a[1]));
  • 操作数是数组中下标为1的元素，也就是第二个元素。
  • 其大小是4个字节，所以结果是4。
printf("%d\n", sizeof(&a));
  • 操作数是&数组名，此时取出的是整个数组的地址。
  • 该地址的数据类型是int (*)[4]，是一个数组指针变量类型。
  • 归根到底还是一个地址，所以结果是4或者8。
printf("%d\n", sizeof(*&a));
  • 操作数是*&a。
  • 解引用操作符*和取地址操作符&相互抵消，剩下的只有数组名。
  • sizeof的操作数只有数组名时，其本质是整个数组。
  • 结果是16。
printf("%d\n", sizeof(&a + 1));
  • 操作数是&a+1
  • &a得到的是整个数组的地址，该指针针的类型是int (*)[4]。
  • 加1后跳过了整个数组，指向了内存中下一个int (*)[4]的地址。
    图
  • 归根到底还是一个地址，所以结果是4或者8。
printf("%d\n", sizeof(&a[0]));
  • 操作数是&a[0]。
  • a[0]得到的是数组中的第一个元素，再对其取地址。
  • 得到的就是数组首元素的地址。
  • 所以结果是4或者8。
printf("%d\n", sizeof(&a[0] + 1));
  • 操作数是&a[0]+1。
  • &[0]得到的是数组首元素的地址。
  • 加1后得到的是数组中第二个元素的地址
  • 数据类型是int*类型的指针变量。
  • 所以结果是4或者8。

综合上面的分析，由于本喵使用的编译器是32位的，将每行代码所分析的结果注释到对应代码的后面
图
可以看到输出的结果与我们所分析的一致。

🐼字符数组

习题一：

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

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

这是一个字符数组，数组中有6个元素。

printf("%d\n", sizeof(arr));
  • 操作数是数组名。
  • 此时数组名的本质是整个数组。
  • 所以结果是整个数组的大小，结果是6。
printf("%d\n", sizeof(arr + 0));
  • 操作数是arr+0
  • 并不是一个单独的数组名，此时数组名的本质是数组首元素的地址
  • 加0后仍然是数组首元素的地址
  • 该地址是char*类型的指针
  • 结果是4或者8
printf("%d\n", sizeof(*arr));
  • 操作数是*arr，不是单独的数组名
  • 此时数组名的本质是数组首元素的地址
  • 解引用后得到的是数组中的第一个元素
  • 该元素的数据类型是char类型
  • 结果是1
printf("%d\n", sizeof(arr[1]));
  • 操作数是arr[1]
  • 得到是数组中下标为1的元素
  • 该元素的数据类型是char类型
  • 结果是1
printf("%d\n", sizeof(&arr));
  • 操作数是&arr，取出的是整个数组的地址
  • 数据类型是char (*)[6]，是一个数组指针
  • 归跟到底还是一个地址
  • 结果是4或者8
printf("%d\n", sizeof(&arr + 1));
  • 操作数是&arr+1
  • &arr取出的是整个数组的地址，是一个数据类型是char (*)[6]类型的指针
  • 加1后跳过了整个数组，指向了下一个char (*)[6]类型数组的地址
    图
  • 下一个数组的地址归根到底还是一个地址
  • 结果是4或者8
printf("%d\n", sizeof(&arr[0] + 1));
  • 操作数是&arr[0]+1
  • &arr[0]得到的是数组首元素的地址
  • 加1后得到的是数组中第二个元素的地址
  • 数据类型是char*类型的指针
  • 所以结果是4

综合上面的分析，由于本喵使用的编译器是32位的，将每行代码所分析的结果注释到对应代码的后面
图
可以看到输出的结果与我们所分析的一致。

习题二：

#include <string.h>

int main()
{
	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));

	return 0;
}
  • 这段代码中使用的是strlen()库函数来求字符串的长度。
  • strlen库函数的本质是寻找字符串中的字符结束标志\0
  • 然后将\0之前的字符个数统计出来
char arr[] = { 'a','b','c','d','e','f' };

这是一个字符数组，有6个元素，每个元素都是char类型的。

printf("%d\n", strlen(arr));
  • 实参是arr，并不是特例中的情况
  • 此时数组名的本质是数组首元素的地址
  • 由于该数组中没有\0，所以strlen函数找不到统计结束的标志
  • 所以结果是一个随机数，但是这个随机数一定大于等于6
printf("%d\n", strlen(arr + 0));
  • 实参是arr+0
  • arr是数组首元素的地址，加0后仍然是数组首元素的地址
  • 所以结果与上语句代码的结果一样
printf("%d\n", strlen(*arr));
  • 实参是*arr
  • 此时的arr是数组首元素的地址
  • 解引用后得到的是数组中的第一个元素，也就是字符’a’
  • 此时将字符a当作是一个地址传参给了strlen库函数
  • 因为字符a的ASCII码值是97，所以相当于传参了一个char*类型的指针，其值是97
  • 地址为97的内存空间是供内核使用的，用户没有访问权限，所以编译器就会报错。
    图
  • 十进制97转化成16进制后便是61
  • 报错内容中告诉我们访问地址0x00000061时发生错误
  • 就是说这个内存空间是不允许我们访问的
printf("%d\n", strlen(arr[1]));
  • 实参是arr[1]
  • 得到的是数组中第二个元素，也就是’b’
  • 字符b的ASCII码值是98，转化成16进制后是62
  • 与上面的代码一样，同样是将62作为地址传给了strlen库函数
  • 而0x00000062的内存空间同样是不可访问的，也会报错
    图
printf("%d\n", strlen(&arr));
  • 实参是&arr，是特例中的一种情况
  • 取出的是整个数组的地址
  • 但是整个数组的地址表现形式就是数组首元素的地址，其值与arr一样
  • 虽然&arr的数据类型是char (* )[6]，但是在传给strlen库函数后会被强制转化成为cahr* 类型的指针
  • 所以结果也是一个随机值，结果大于等于6，与第一个输入语句结果相同。
printf("%d\n", strlen(&arr + 1));
  • 实参是&arr+1
  • &arr取出的是整个数组的地址
  • 加一后就跳过了该数组，指向了下一个char (*)[6]类型数组的地址
    图
  • 由于并不知道此时指向数组中的元素分布情况，所以得出的结果是一个随机值。
printf("%d\n", strlen(&arr[0] + 1));
  • 实参是&arr[0]+1
  • &arr[0]得到的是数组首元素的地址
  • 加1后得到的是数组第二个元素的地址
  • 将此地址传给strlen库函数后，由于没有\0，所以仍然不知道要统计到哪里结束
  • 但是这个随机值要必上面的随机值小一个数。

综合上面的分析，将每行代码所分析的结果注释到对应代码的后面
图
结果与我们所分析的一致。
该代码在指向过程中会报一些警告，我们直接忽略就好了，有兴趣的小伙伴可以尝试修复一下。

习题三：

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

char arr[] = "abcdef";

这是一个字符串数组，数组中有7个元素，每个元素都是char类型。
相当于

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

printf("%d\n", sizeof(arr));
  • 操作数是arr，只有一个数组名
  • 此时arr的本质是整个数组
  • 所以结果是7
printf("%d\n", sizeof(arr + 0));
  • 操作数是arr+0，不是单独的一个数组名
  • 此时arr的本质是数组首元素的地址
  • 加0后仍然是数组首元素的地址
  • 该地址是char*类型的指针
  • 所以结果是4或者8
printf("%d\n", sizeof(*arr));
  • 操作数是*arr，不是单独的数组名
  • 此时arr的本质是数组首元素的地址
  • 解引用后得到的是数组中的第一个元素
  • 所以结果是1
printf("%d\n", sizeof(arr[1]));
  • 操作数是arr[1]
  • 得到的是数组中下标为1的元素，也就是第二个元素
  • 所以结果是1
printf("%d\n", sizeof(&arr));
  • 操作数是&arr，取出的是整个数组的地址
  • 该地址是一个char (*)[7]类型的指针
  • 归根到底还是一个指针
  • 所以结果是4或者8
printf("%d\n", sizeof(&arr + 1));
  • 操作数是&arr+1
  • &arr取出的是整个数组的地址
  • 加1后跳过了该数组，指向下一个char (*)[7]的地址
    图
  • 此时的地址仍然是一个指针
  • 所以结果是4或者8
printf("%d\n", sizeof(&arr[0] + 1));
  • 操作数是&arr[0]+1
  • &arr[0]得到的是数组首元素的地址
  • 加1后得到的是数组中第二个元素的地址
  • 该地址的是数据类型是char*
  • 所以结果是4或者8

综合上面的分析，由于本喵使用的编译器是32位的，将每行代码所分析的结果注释到对应代码的后面
图
可以看到，与我们所分析的结果一致。
习题四：

int main()
{
	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));

	return 0;
}

char arr[] = "abcdef";

这是一个数组，有7个元素，每个元素都是char类型。

printf("%d\n", strlen(arr));
  • 实参是arr
  • 此时的arr的本质是数组首元素地址
  • 将arr传参给strlen库函数后，便从这里开始统计字符个数，直到\0结束统计
  • 所以结果就是字符的个数，但是不包括\0
  • 所以结果是6
printf("%d\n", strlen(arr + 0));
  • 实参是arr+0
  • 此时arr的本质是数组首元素地址
  • 加0后仍然是数组首元素地址
  • 所以结果与上面语句的结果一样，也是6
printf("%d\n", strlen(*arr));
  • 实参是*arr
  • 此时arr的本质是数组首元素地址
  • 解引用后得到的是数组中的第一个元素，也就是’a’
  • 字符a的ASCII码值是97
  • 此时相当于将地址为97的指针传参给类strlen库函数
  • 该地址转化成16进制后是0x00000061
  • 该地址是不允许访问的，所以在执行的时候会报错
  • 具体结果和前面习题中报错的错过一样
printf("%d\n", strlen(arr[1]));
  • 实参是arr[1]
  • 得到的是数组中第二个元素，也就是’b’
  • 字符b的ASCII码值是98
  • 同样是相当与将地址98，也就是0x00000062传参给了strlen
  • 在执行的时候也会报错
printf("%d\n", strlen(&arr));
  • 实参是&arrr，取出的是整个数组的地址
  • 此时实参的数据类型是char (*)[7]
  • 将该类型的指针传参给strlen库函数后会被强制转换为char*类型的指针
  • 虽然是整个数组的地址，但是它的值和数组首元素地址相同
  • 所以也是从字符a开始统计字符的个数，直到遇到\0
  • 所以结果是6
printf("%d\n", strlen(&arr + 1));
  • 实参是&arr+1
  • &arr取出的是整个数组的地址
  • 加1后跳过了该数组，指向了下一个char (*)[7]类型的地址
    图
  • 由于不知道该数组后面的元素分布情况
  • 所以结果是一个随机值
printf("%d\n", strlen(&arr[0] + 1));
  • 实参是&arr[0]+1
  • &arr[0]取出的是数组首元素的地址
  • 加1后得到是数组中第二个元素的地址
  • 将该地址传参给strlen库函数后
  • 便从第二个元素开始统计字符的个数，直到\0结束
  • 所以结果是5

综合上面的分析，将每行代码所分析的结果注释到对应代码的后面
图
可以看到，与我们所分析的结果一致。

习题五：

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

char* p = "abcdef";
  • 字符串存在内存中的常量区，它们也有地址
  • 该语句是将字符串中字符a的地址符给了指针变量p
printf("%d\n", sizeof(p));
  • 操作数是p
  • p是一个指针变量
  • 其实质是sizeof(char*)
  • 所以结果是4或者8
printf("%d\n", sizeof(p + 1));
  • 操作数是p+1
  • 此时变量p中的值是字符b的地址
  • 所以结果是4或者8
printf("%d\n", sizeof(*p));
  • 操作数是*p
  • p中的值是字符a的地址
  • 解引用后得到是字符a
  • 所以结果是1
printf("%d\n", sizeof(p[0]));
  • 操作数是p[0]
  • p[0]可以写成*(p+0)
  • p中的值是字符a的地址
  • 加0后仍然是a的地址
  • 解引用后得到字符a
  • 所以结果是1
printf("%d\n", sizeof(&p));
  • 操作数是&p
  • 数据类型是char** 的一个二级指针
  • 归根到底还是一个指针
  • 所以结果是4或者8
printf("%d\n", sizeof(&p + 1));
  • 操作数是&p+1
  • &p得到的是一个二级指针
  • 加1后是对二级指针加1，但是它仍然是一个指针
  • 所以结果是4或者8
printf("%d\n", sizeof(&p[0] + 1));
  • 操作数是&p[0]+1
  • p[0]可以写成*(p+0)
  • p中的值是字符a的地址
  • 加0后仍然是字符a的地址
  • 解引用后得到的是字符a
  • 再对字符a取地址，得到的是字符a的地址
  • 再加1后得到的是字符b的地址
  • 仍然是一个地址
  • 所以结果是4或者8

综合上面的分析，由于本喵使用的编译器是32位的，将每行代码所分析的结果注释到对应代码的后面
图
习题六：

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

char* p = "abcdef";

同样是将字符a的地址赋值给了指针变量p。

printf("%d\n", strlen(p));
  • 实参是p，放的值是字符a的地址
  • 传参给strlen库函数后便向后统计字符的个数，直到\0结束，但是不包括\0
  • 所以结果是6
printf("%d\n", strlen(p + 1));
  • 实参是p+1
  • p中的值是字符a的地址
  • 加1后就变成了字符b的地址
  • 传参给strlen库函数后便从字符b开始统计字符个数，直到\0结束
  • 所以结果是5
printf("%d\n", strlen(*p));
  • 实参是*p
  • p中是字符a的地址
  • 解引用后得到的是字符a
  • 字符a的ASCII码值是97，转换成16进制后是61
  • 相当于将字符a当作地址传参给strlen库函数，也就是传的0x00000061
  • 而该地址是不允许用户访问的
  • 所以编译的结果会报错
    图
printf("%d\n", strlen(p[0]));
  • 实参是p[0]
  • 可以写成*(p+0)
  • p中放的是字符a的地址
  • 加0后仍然是字符a的地址
  • 解引用后得到的是字符a
  • 所以结果和上面的输出语句是一样的，也会报错
printf("%d\n", strlen(&p));
  • 实参是&p
  • p中放的是字符a的地址
  • 取地址后得到的是一个变量类型为char**的二级指针
    图
  • 红色方框是字符串的存放空间
  • 蓝色方块是指针变量p，其值是字符a的地址，假设它是0x0012ff40
  • 绿色方块是&p，也就是二级指针变量，其值是一级指针变量p的地址，假设是0x0034ff23
    图
    本喵使用的编译器是32位的，且是按照小端字节序存储方式存储的
  • p变量是一个一级指针变量，其大小是4个字节，里面放的是字符a的地址
  • p中的地址在内存中存储的样子如上图中的蓝色框框
  • &p得到的是指针变量p的地址，该地址的值与指针变量p中四个字节里低字节序字节的地址相同
  • 将该地址传参给strlen库函数后又被强制转换成了char*类型的地址
  • 所以每次加1只向后跳一个字节
  • 所以再统计的时候会将指针变量p中的值也当作是字符统计，如40，ff，12，当遇到00的时候便结束了统计
  • 所以输出的结果是一个随机值
printf("%d\n", strlen(&p + 1));
  • 实参是&p+1
  • &p和上面的一样，得到的是一个二级指针
  • 而加1后就会跳过一个二级指针类型，也就是跳过四个字节
    图
  • 此时的二级指针是存放在下一个内存空间中的
  • 将该二级指针传参给strlen库函数后，便从此开始统计字符个数
  • 由于不知道在哪里停止，所以结果是一个随机值
printf("%d\n", strlen(&p[0] + 1));
  • 实参是&p[0]+1
  • p[0]可以写成*(p+0)
  • p中放的是字符a的地址
  • 加0后仍然是a的地址
  • 解引用后得到的是字符a
  • 再对字符a取地址后加1
  • 得到的是字符b的地址
  • 将此地址传参给strlen库函数后便开始向后统计字符个数，直到\0结束
  • 所以结果是5

注意

  • 最后的俩个随机值之间没有必然的联系，都是随机的。

综合上面的分析，由于本喵使用的编译器是32位的，将每行代码所分析的结果注释到对应代码的后面

图
可以看到，所得结果与我们分析的一致。

🐼二维数组

习题一：

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

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

这是一个三行四列的二维数组，初始化全部为0，每个元素的类型都是整型

printf("%d\n", sizeof(a));
  • 操作数是a，单独的数组名
  • 此时数组名的本质是整个数组
  • 所以结果是整个数组所占内存空间的大小
  • 结果是48
printf("%d\n", sizeof(a[0][0]));
  • 操作数是a[0][0]
  • 得到是第0行第0列的元素
  • 所以结果是4
printf("%d\n", sizeof(a[0]));
  • 操作数是a[0]
  • a[0]只有行标没有列标
  • 二维数组可以看成是每个元素是一维数组的一维数组
  • a[0]就代表首行数组的数组名
  • 由于只有单独的一个数组名，所以代表整个首行数组
  • 所以结果是16
printf("%d\n", sizeof(a[0] + 1));
  • 操作数是a[0]+1
  • a[0]代表的是首行一维数组的数组名，且不是单独的数组名
  • a[0]的本质是首行数组的首元素地址
  • 加1后得到的是首数组的第二个元素的地址，也就是a[0][1]元素的地址
  • 其是一个int*类型的指针变量
  • 所以结果是4或者8
printf("%d\n", sizeof(*(a[0] + 1)));
  • 操作数是*(a[0]+1)
  • 根据上面语句的分析我们知道a[0] +1得到的是第0行第1列的元素的地址
  • 解引用后就得到了a[0][1]
  • 所以结果是4
printf("%d\n", sizeof(a + 1));
  • 操作数是a+1
  • 二维数组的数组名的实质是首行元素的地址
  • 此时a是一个数组指针，其类型是int (*)[4]
  • 加1后指向了第二行元素
  • 其类型仍然是int (*)[4]
  • 归根到底其还是一个地址
  • 所以结果是4或者8
printf("%d\n", sizeof(*(a + 1)));
  • 操作数是*(a+1)
  • 由对上面语句的分析我们知道a+1得到的是第二行元素的地址
  • 对其解引用后得到的是第二行整个一维数组
  • 所以其结果就是第二行一维数组的大小
  • 结果是16
printf("%d\n", sizeof(&a[0] + 1));
  • 操作数是&a[0]+1
  • a[0]是首行一维数组的数组名
  • 对其取地址&a[0]得到的是整个首行的一维数组的地址，类型是int (*)[4]
  • 再加1后得到的是第二行一维数组的地址，同样是一个数组指针
  • 归根到底还是指针
  • 所以结果是4或者8
printf("%d\n", sizeof(*(&a[0] + 1)));
  • 操作数是*(&a[0]+1)
  • 根据上面的分析我们知道&a[0]+1得到的是第二行整个一维数组的地址
  • 解引用后得到的是第二行的整个一维数组
  • 所以结果是第二行数据所占的内存空间
  • 结果是16
printf("%d\n", sizeof(*a));
  • 操作数是*a，不是单独的数组名
  • 此时数组名a的本质是数组首行元素的地址，是一个int (*)[4]类型的指针
  • 对首行元素的地址解引用得到的就是首行元素
  • 所以结果是16
printf("%d\n", sizeof(a[3]));
  • 操作数是a[3]
  • a[3]表示的是第四行一维数组的数组名
  • 由于代码中的数组是3行4列的，所以这里的第4行已经越界访问
    图
  • 数组虽然越界了，但是指向数组只外的那一行也是一个4列的一维数组
  • 此时相当于只有数组名单独出现
  • 所以结果是16

综合上面的分析，由于本喵使用的编译器是32位的，将每行代码所分析的结果注释到对应代码的后面

在这里插入图片描述
可以看到，结果与我们分析的一致。

🐨指针笔试题

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

图

  • 绿色框框内是数组a在内存中的分布
  • 数组名a是数组首元素的地址，也就是元素1的地址
  • &a得到的是整个数组的地址，是一个int (*)[5]的数组指针
  • &a+1跳过了整个数组a，指向了后面另一个同样大小的数组
  • 将此时的数组指针强制类型转换成为int*的指针，并赋值给指针变量ptr
  • 此时ptr-1向左移动了一个int类型，也就是4个字节，指向了元素5的地址
  • a的本质是数组首元素的地址
  • 加1后得到的是数组中第二个元素的地址，也就是元素2的地址
printf("%d,%d", *(a + 1), *(ptr - 1));
  • 对a+1解引用得到的是元素2
  • 对ptr-1解引用得到的是元素5
  • 所以结果是2，5

图
与我们所分析的一致。

  • 笔试题2：
struct Test
{
	int Num;
	char* pcName;
	short sDate;
	char cha[2];
	short sBa[4];
}*p = 0x10000000;

int main()
{
	printf("%p\n", p + 0x1);
	printf("%p\n", (unsigned long)p + 0x1);
	printf("%p\n", (unsigned int*)p + 0x1);
	return 0;
}
  • 创建了一个结构体，以32位的机器为例，该结构体所占内存空间大小是20个字节
  • 用一个结构体指针变量指向该结构体，此时指针变量p中放的就是结构体所在的地址
printf("%p\n", p + 0x1);
  • p中放的是结构体的地址，0x10000000
  • 加0x1后相当于加1，跳过的是整个结构体，也就是加20
  • 转换成16进制后结果是0x10000014
printf("%p\n", (unsigned long)p + 0x1);
  • 将指针变量p强制类型转换位unsigned long类型
  • 此时p中的值便不再是结构体的地址，而是一个无符号的长整型数字
  • 加0x1后，也就是加1后，就是在进行算术运算
  • 所以结果是0x10000001
printf("%p\n", (unsigned int*)p + 0x1);
  • 将指针变量p强制类型转换位unsigned int*类型
  • 此时p中的值便不再是结构体的地址，而是一个unsgined int*类型的指针变量，它的值是一个指向unsigned int类型数据的地址。
  • 加0x1后，也就是加1后，跳过的是一个unsigned int类型的数据，也就是4个字节
  • 所以结果是0x10000004

图
可以看到，与我们分析的结果一致。
在运行过程中会报警告，但是并不影响我们结果的输出。

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

图

  • 以VS2019为例
  • 按照小端字节序存储方式储存数据
  • 是32位的平台
  • 如上图，数组名a的本质是数组首元素的地址，指向的是第一个元素的地址
  • 又因为是小端字节序储存，所以首元素的地址就是首元素中最低字节01的地址
int* ptr1 = (int*)(&a + 1);
  • 原本a的数据类型是int*类型的指针，强制类型转换位整型，此时它的意义便不再是指针，而是一个数字
  • 加1后是在进行算术运算，其值增加1
  • 将其结果再强制类型转换为int*类型的指针变量
  • 此时该指针指向的是第一个元素四个字节中第二低字节序字节的地址，如上图中的00
  • 将该地址赋值给指针变量ptr2
int* ptr1 = (int*)(&a + 1);
  • &a得到是整个数组的地址
  • 加1后跳过的是整个数组，此时该指针指向的是下一个int (*)[4]类型的地址
  • 将该指针强制类型转换为int*类型后赋值给指针变量ptr1
printf("%x,%x", ptr1[-1], *ptr2);
  • ptr1[-1]可以写成*(ptr1-1)
  • ptr1-1得到的值指向数组中的最后一个元素4的地址
  • 解引用后得到元素4
  • ptr2解引用后得到的是从ptr2开始往后的4个字节组成的int类型的数据
  • 由于是小端字节序存储方式
  • 所以去出后该int类型的数据是02 00 00 00
  • 按照16进制打印
  • 所以结果是2000000
  • 所以最后的结果是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;
}

int a[3][2] = { (0, 1), (2, 3), (4, 5) };
  • 这是一个三行二列的二维数组，且是不完全初始化，每个元素的类型是int类型
  • 在大括号内的内容是逗号表达式
  • { (0, 1), (2, 3), (4, 5) }最终给二维数组初始的值是1，3，5
  • 第一行的元素是1，3
  • 第二行的元素是5，0
  • 第三行的元素是0，0
  • 此时的a[0]的本质是数组首行一维数组的数组名，也就是第0行第0列元素的地址
  • 将该地址赋值给指针变量p
printf("%d", p[0]);
  • p[0]可以写成*(p+0)
  • p中的值是a[0][0]的地址
  • 加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;
}

图
我们知道，二维数组在内存中也是连续存放的

  • 如上图是二维数组在内存中的分布
int(*p)[4];
	p = a;
  • 这里创建了一个数组指针，但是该指针指向的数组是4个元素的，每个元素的类型是int类型的
  • 而数组名a的数据类型是int (*)[5]的
  • 将a代表的指针强制赋值给数组指针p
  • 此时站在p的角度来看，它就是一个有4个元素的数组指针
  • p+1会跳过一个4个元素的一维数组，指向原本5个元素数组的最后一个元素的，如上图中的p+1
printf("%p,%d\n", &p[4][2] - &a[4][2], &p[4][2] - &a[4][2]);
  • 分析&p[4][2] - &a[4][2]
  • p[4][2]可以写成*(*(p+4)+2)
  • p中放的是第一个4个元素的数组的地址
  • 加4后指向了第4个4个元素的一维数组，如上图中的p+4所指向的位置
  • 对p+4解引用后得到的是第4个4个元素的一维数组，也就是这个数组的数组名
  • 因为只有数组名可以代表一个数组
  • 数组名的本质是数组首元素的地址，所以*(p+2)是该数组首元素的地址
  • *(p+4)+2指向的是该数组中的第3个元素
  • 再将该地址解引用得到的就是该元素
  • 再对该元素取地址得到就是其地址，如上图中的绿色方框所指向的空间
  • &a[4][2]得到就是第4行第2列的元素的地址，如上图中黑色方框所指向的空间
  • 又因为地址减地址得到的是俩个地址之间的元素个数
  • &p[4][2]的值小于&a[4][2]的值
  • &p[4][2] - &a[4][2]的结果是-4
  • -4在存在中的补码是111111111111111111111111111100
  • 按照%p打印，打印出来的就是内存中数的样子，是FFFFFFFC
  • 按照%d打印，打印出来的是它的补码，是-4

图
可以看到，与我们所分析的结果一致。

  • 笔试题6：
int main()
{
	int a[2][5] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
	int* ptr1 = (int*)(&a + 1);
	int* ptr2 = (int*)(*(a + 1));
	printf("%d,%d", *(ptr1 - 1), *(ptr2 - 1));
	return 0;
}

图

  • 数组元素的分布如上图
  • &a中的a表示的是整个数组
  • &a+1就跳过了整个二维数组，指向下一个二维数组，如图中的&a+1所示位置
  • 此时的地址强制转换为int*类型的指针，赋值给ptr1
  • 数组名a表示的是二维数组首行元素的地址
  • a+1后指向的是二维数组第二行元素的地址
  • 强制类型转换为int*类型的指针，赋值给ptr2
  • 此时，ptr1-1指向的是数字10所在的空间，ptr2-1指向的是数字5指向的空间
  • 解引用后得到的结果分别是10和5

图
可以看到，与我们分析的结果一致。

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

图

  • 3个字符串存储在常量区，如图中的红色框所示
  • 创建了一个指针数组，该数组有3个元素，每个元素的类型都是char*类型
  • 将3个字符串各自首字符的地址放在指针数组a中，如图中蓝色框所示
  • 创建一个二级指针变量pa
  • 此时数组a的数组名是数组首元素的地址，它的类型是一个二级指针
  • 将数组首元素地址赋值给pa
  • pa++是将pa中的值加1，此时pa中的值就是数组中第二个元素的地址
  • 对pa解引用得到数组中的第二个元素，该元素是第二个字符串首字符的地址
  • 打印字符串从这里开始
  • 所以打印的结果是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;
}

图

  • 四个字符串存放在常量区，如上图红色框所示
  • 创建一个一级指针数组c
  • 将四个字符串的首元素地址依次放入数组c中，如上图蓝色框所示
  • 再创建一个二级指针数组cp
  • 将一级指针数组的4个元素的地址倒序放入二级指针数组cp中，如上图绿色框所示
  • 再创建一个三级指针变量pp
  • 将二级指针数组cp的首元素地址赋值给三级指针变量cpp，如上图黑色框所示
printf("%s\n", **++cpp);
  • ++cpp后，三级指针变量cpp中的值变成了cp+1
  • cp+1是二级指针数组cp的第二个元素的地址
  • 第一次解引用是对地址cp+1解引用，得到的内容是c+2
  • c+2是一级指针数组c的第三个元素的地址
  • 第二次解引用相当于对地址c+2解引用，得到的内容是字符串POINT首字符的地址
  • 所以打印的结果是字符串POINT
printf("%s\n", *-- * ++cpp + 3);
  • ++cpp后，三级指针变量cpp中的值便成了cp+2
  • cp+2是二级指针数组cp的第三个元素的地址
  • 解引用是对地址cp+2解引用，得到的内容是c+1
  • c+1是一级指针数组c的第二个元素的地址
  • 再进行自减1后，就是将c+1减1，得到的是c
  • c是一级指针数组c的第一个元素
  • 再次进行解引用是对地址c进行解引用，得到的是字符串ENTER首字符的地址
  • 然后再将该地址加3，得到的是字符串ENTER中字符E的地址
  • 所以打印的结果是ER
printf("%s\n", *cpp[-2] + 3);
  • cpp[-2]可以写成*(cpp-2)
  • cpp-2等价于cp+2-2，得到的结果是cp
  • cp是二级指针数组cp中首元素的地址
  • 解引用是对地址cp解引用，得到的结果是c+3
  • 再次解引用是对地址c+3解引用，得到的结果是字符串FIRST首字符的地址
  • 再加3后得到的是字符串FIRST中字符S的地址
  • 所以打印的结果是ST
printf("%s\n", cpp[-1][-1] + 1);
  • cpp[-1][-1]可以写成*(*(cpp-1)-1)
  • 此时cpp中的值仍然是cp+2，因为只有自增才改变了它的值
  • cpp-1等价于cp+2-1，结果是cp+1
  • 对cp+1进行解引用，得到的结果是c+2
  • c+2是一维数组c中第三个元素的地址
  • 然后再将c+2-1得到的结果是c+1
  • 对c+1解引用得到的结果是字符串NEW首字符的地址
  • 再进行加1，得到的是字符串NEW中字符W的地址
  • 所以打印的结果是EW

图
可以看到，与我们分析的结果一致。

一只大喵咪1201
关注
  • 92
    点赞
  • 踩
  • 393
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 18
    评论
专栏目录
C语言之指针练习题
m0_70469414的博客
11-20 2914
数组是特殊的指针，运用指针数组计算
C语言题库数组，指针，结构体，链表习题
12-28
整理的一些关于C语言的练习题，题目答案都有，需要的可以下载看一下
c语言指针习题及答案
01-30
c语言中指针是较为重要的知识点，掌握指针你会更上一层楼。
【C语言进阶8——指针的进阶（5）- 指针的练习】
taibudong1991的博客
04-19 2187
数组和指针的练习（2）- 指针练习前言1、指针的练习题1.1 练习 11.2 练习 21.3 练习 31.4 练习 41.5 练习 51.6 练习 61.7 练习 71.8 练习 8总结 前言 本文继续通过练习题来复习数组和指针的知识点，主要是指针的练习题目。 1、指针的练习题 1.1 练习 1 int main() { int a[5] = { 1, 2, 3, 4, 5 }; int *ptr = (int *)(&a + 1); printf( "%d,%d", *(
C语言——指针进阶(含例题及详细代码分析)
Dirty_artist的博客
01-17 1191
指针就是地址！
【C语言进阶】指针例题大杂烩，阁下是高手还是菜鸟？
weixin_74113106的博客
04-22 533
指针例题汇总，敢不敢来测一测你的水平？答对百分之50就不用怕学校期末C语言考试啦。
【C语言学习】指针练习例题
热门推荐
m0_46447700的博客
07-10 1万+
1.用函数和指针完成下述程序功能：有两个整数a和b，由用户输入1,2或3。如输入1，程序就给出a和b中大者，输入2，就给出a和b中小者，输入3，则求a与b之和。 代码： #include <iostream> using namespace std; int func(int *a,int *b,int num){ int temp = 0; if(num == 1){ if(*a > *b) temp = *a; else temp = *b; }e
C语言必知-指针练习题（附答案）
CrazyRabbitttt
01-06 8579
C语言的三道经典指针运用的例题
C语言——指针练习题
weixin_47921628的博客
06-06 3684
内容 1.sizeof与strlen计算 2.指针面试题 *1.sizeof与strlen计算 *2.指针面试题 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; } 1>下面这段程序的输出结果为？ 1>下面这段程序的输出结果为？ 1>下面这
c语言指针练习题
寄蜉蝣于天地，渺沧海之一粟
08-09 4295
1、使用指针方法，计算两个数组中各元素对应位置的和，和的结果存入第三个数组中，然后输出。 2、利用指针，顺序输出字母表，然后反序输出。
c语言指针习题及答案.doc
11-29
C语言指针习题及答案 C语言指针是指向变量的内存地址的变量，指针习题是C语言学习的重点内容...C语言指针习题及答案涵盖了指针的基本概念、指针赋值、指针的应用等知识点，了解这些知识点对于C语言学习是非常重要的。
c语言学习部分-习题题
07-01
【C语言基础知识】 ...通过这些习题，我们可以看到C语言涵盖了变量、类型、运算符、控制结构、函数、数组、指针等多个核心概念。通过不断地练习和理解，初学者能够逐步掌握C语言的编程思想和技能。
C语言循环、数组、函数及指针练习题精选及答案
03-28
结合“习题+答案”这个文件，你可以通过练习和解答来巩固这些概念。解决实际问题和编写代码是掌握这些知识点的最佳方式。做题时，可以尝试不同方法，理解各种情况下循环、数组、函数和指针的使用技巧。同时，详细的...
C语言深度解剖 + C语言练习题
03-18
"C语言深度解剖 + C语言练习题"这个资料包旨在帮助学习者深入理解C语言的基础和高级概念，并通过实践来巩固知识。 首先，我们要理解C语言的基础部分。C语言的核心包括数据类型（如整型、浮点型、字符型等）、变量、...
C语言：指针典型例题详解
Harper.Lee的博客
03-16 1452
基于对前面的深入理解指针1,2,3,4的学习，本篇文章带来指针的典型例题。俗话说：光说不练假把戏。在指针的学习过程中最重要的还是要学会动手实操。学习本节内容之前，先复习一下涉及的相关知识，以便更好的理解。
5 C 语言数组与字符串的全面解析
Thanks_ks的IT探秘之旅
07-22 942
本文整理自王道考研C语言督学营第5章课程视频，全面覆盖了数组与字符串的基本概念、定义与初始化、内存存储、访问越界问题、传递机制以及字符串的输入输出与操作函数。通过详细讲解一维数组的特性、字符数组的定义与操作、字符串处理函数（如strlen、strcpy、strcmp、strcat）的使用，并结合CLion调试工具示例，帮助读者深入理解C语言中数组与字符串的核心知识。同时，通过OJ练习巩固所学知识，提升编程实践能力。
C语言 打印菱形的程序（Program to print the Diamond Shape）
csdn_aspnet的专栏
07-22 2203
O(n*n)，因为我们正在遍历网格的行和列来打印空格 ' '和星号 '*'。给定一个数字n ，编写一个程序来打印一个有2n行的菱形。O(1)，不使用额外空间。
C语言 | Leetcode C语言题解之第279题完全平方数
最新发布
m0_59237910的博客
07-24 431
C语言 | Leetcode C语言题解之第279题完全平方数
c语言指针练习题实验
07-29
在这个实验中，有三个源程序被引用。第一个源程序是用指针变量实现数的比较，输入两个整数，并使其从大到小输出。\[1\]第二个源程序是用指针法输入12个数，然后按每行4个数输出。\[2\]第三个源程序是用函数实现数的交换，输入两个整数，并使其从大到小输出。\[3\] 在第一个源程序中，通过指针变量p1和p2来比较两个整数的大小，并使用指针变量p来交换两个整数的值。最后输出a和b的值以及最大值和最小值。\[1\] 在第二个源程序中，使用指针变量p来遍历数组a，并按每行4个数的格式输出数组中的元素。\[2\] 在第三个源程序中，使用函数as来实现两个整数的交换。通过指针变量p1和p2来传递两个整数的地址，并在函数内部交换它们的值。最后输出a和b的值以及最大值和最小值。\[3\] 这些实验都是为了练习和理解C语言中指针的使用。通过这些实验，可以加深对指针的理解，并掌握指针在程序中的应用。 #### 引用[.reference_title] - *1* *2* *3* [C语言实验十一 指针（一）](https://blog.csdn.net/qq_64314976/article/details/126123133)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^insert_down1,239^v3^insert_chatgpt"}} ] [.reference_item] [ .reference_list ]
评论 18
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

一只大喵咪1201

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值