[C]基础13.深入理解指针(5)

算法歌者2025-04-30 10:57
  • 博客主页：向不悔
  • 本篇专栏：[C]
  • 您的支持，是我的创作动力。

文章目录

  • 0、总结
  • 1、sizeof和strlen的对比
    • [1.1 sizeof](#1.1 sizeof)
    • [1.2 strlen](#1.2 strlen)
    • [1.3 sizeof和strlen的对比](#1.3 sizeof和strlen的对比)
  • 2、数组和指针笔试题解析
    • [2.1 一维数组](#2.1 一维数组)
    • [2.2 字符数组](#2.2 字符数组)
      • [2.2.1 代码1](#2.2.1 代码1)
      • [2.2.2 代码2](#2.2.2 代码2)
      • [2.2.3 代码3](#2.2.3 代码3)
      • [2.2.4 代码4](#2.2.4 代码4)
      • [2.2.5 代码5](#2.2.5 代码5)
      • [2.2.6 代码6](#2.2.6 代码6)
    • [2.3 二维数组](#2.3 二维数组)
  • 3、指针运算笔试题解析
    • [3.1 题目1](#3.1 题目1)
    • [3.2 题目2](#3.2 题目2)
    • [3.3 题目3](#3.3 题目3)
    • [3.4 题目4](#3.4 题目4)
    • [3.5 题目5](#3.5 题目5)
    • [3.6 题目6](#3.6 题目6)
    • [3.7 题目7](#3.7 题目7)

0、总结

1、sizeof和strlen的对比

1.1 sizeof

sizeof计算变量所占内存内存空间大小的，单位是字节 。如果操作数是类型的话，计算的是使用类型创建的变量所占内存空间的大小。sizeof只关注占用内存空间的大小，不在乎内存中存放什么数据。如下：

c 复制代码 
#include <stdio.h>
int main()
{
	int a = 10;
	printf("%d\n", sizeof(a));
	printf("%d\n", sizeof a);
	printf("%d\n", sizeof(int));
	return 0;
}

1.2 strlen

strlen是C语言库函数，功能是求字符串长度。函数原型如下：

c 复制代码 
size_t strlen(const char* str);

统计的是从strlen函数的参数str中这个地址开始向后，\0之前字符串中字符的个数。

strlen函数会一直向后找\0字符，直到找到为止，所以可能存在越界查找。

c 复制代码 
#include <stdio.h>
int main()
{
	char arr1[3] = { 'a','b','c' };
	char arr2[] = "abc";
	printf("%d\n", strlen(arr1));  // unknown
	printf("%d\n", strlen(arr2));  // 3

	printf("%d\n", sizeof(arr1));  // 3
	printf("%d\n", sizeof(arr2));  // 4
	return 0;
}
c 复制代码 
运行：
15
3
3
4

1.3 sizeof和strlen的对比

sizeof strlen
1、sizeof是操作符。 2、sizeof计算操作数所占内存的大小，单位是字节。 3、不关注内存中存放什么数据。 1、strlen是库函数，使用需要包含头文件string.h 2、strlen是求字符串长度的，统计的是\0之前字符的隔个数。 3、关注内存中是否有\0，如果没有\0，就会持续往后找，可能会越界。

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

2.1 一维数组

做题之前，先理解概念：

  • 1、 数组名的理解：数组名是数组首元素（第一个元素的地址）
  • 2、 但有两个例外：
    • sizeof(数组名) - 数组名表示整个数组，计算的是整个数组的大小，单位是字节。
    • &数组名 - 数组名表示整个数组，取出的是整个数组的地址。
  • 3、 除此之外，所有的数组名是数组首元素的地址。
c 复制代码 
#include <stdio.h>

int main()
{
	int a[] = { 1,2,3,4 };

	printf("01:%zd\n", sizeof(a));          
	printf("02:%zd\n", sizeof(a + 0));      
	printf("03:%zd\n", sizeof(*a));         
	printf("04:%zd\n", sizeof(a + 1));     
	printf("05:%zd\n", sizeof(a[1]));       
	printf("06:%zd\n", sizeof(&a));         
	printf("07:%zd\n", sizeof(*&a));        
	printf("08:%zd\n", sizeof(&a + 1));               
	printf("09:%zd\n", sizeof(&a[0]));      
	printf("10:%zd\n", sizeof(&a[0] + 1));  
	return 0;
}
c 复制代码 
运行（32位环境）：
01:16
02:4
03:4
04:4
05:4
06:4
07:16
08:4
09:4
10:4
c 复制代码 
运行（64位环境）：
01:16
02:8
03:4
04:8
05:4
06:8
07:16
08:8
09:8
10:8

解析：

c 复制代码 
解析：
//01 : 16     because：sizeof(数组名)->求数组的大小。
//02 : 4/8    because：不是单独数组名，所以a是首元素的地址，类型为int*，a+0还是首元素地址。
//03 : 4      because：*a == *(a + 0) == a[0]，a是首元素的地址，*a就是首元素。
//04 : 4/8    because：a是首元素的地址，a+1跳过1个整型，a+1就是第二个元素的地址。
//05 : 4      because：a[1]就是第二个元素。
//06 : 4/8    because：&a是数组的地址，所以是4/8。再次总结，sizeof(数组名)是数组的大小，sizeof(&数组名)是数组的地址。
//07 : 16     because：*&相互抵消，所以等价于sizeof(a)。
//08 : 4/8    because：&a+1是跳过整个数组后的那个位置的地址。
//09 : 4/8    because：首元素的地址。
//10 : 4/8    because：数组第二个元素的地址。

2.2 字符数组

2.2.1 代码1

c 复制代码 
#include <stdio.h>

int main()
{
	char arr[] = { 'a','b','c','d','e','f' };
	printf("01：%zd\n", sizeof(arr));
	printf("02：%zd\n", sizeof(arr + 0));
	printf("03：%zd\n", sizeof(*arr));
	printf("04：%zd\n", sizeof(arr[1]));
	printf("05：%zd\n", sizeof(&arr));
	printf("06：%zd\n", sizeof(&arr + 1));
	printf("07：%zd\n", sizeof(&arr[0] + 1));
	return 0;
}
c 复制代码 
运行（32位）：
01：6
02：4
03：1
04：1
05：4
06：4
07：4
c 复制代码 
运行（64位）：
01：6
02：8
03：1
04：1
05：8
06：8
07：8

解析：

c 复制代码 
解析：
//01：6     because：数组名单独放在sizeof内部，计算的是数组的大小。  
//02：4/8   because：arr是数组名表示首元素的地址，arr+0还是首元素的地址。
//03：1     because：arr是首元素的地址，*arr就是首元素。
//04：1     because：arr[1]就是第二个元素。
//05：4/8   because：&arr是数组地址。
//06：4/8   because：跳过整个数组，指向了数组后边的空间。
//07：4/8   because：第二个元素的地址。

2.2.2 代码2

c 复制代码 
#include <stdio.h>

int main()
{
	char arr[] = { 'a','b','c','d','e','f' };
	printf("01：%zd\n", strlen(arr));
	printf("02：%zd\n", strlen(arr + 0));
	//printf("03：%zd\n", strlen(*arr));
	//printf("04：%zd\n", strlen(arr[1]));
	printf("05：%zd\n", strlen(&arr));
	printf("06：%zd\n", strlen(&arr + 1));
	printf("07：%zd\n", strlen(&arr[0] + 1));
	return 0;
}
c 复制代码 
运行：
01：42
02：42
05：42
06：36
07：41

解析：

c 复制代码 
解析：
//01：unknown because：arr   是首元素的地址，数组中没有\0，结果随机。
//02：unknown because：arr+0 是首元素的地址，数组中没有\0，结果随机。
//03：err     because：arr是首元素的地址，*arr是首元素，就是'a','a'的ascii码值是97
// 相当于把97作为地址传递给了strlen，strlen得到的就是野指针，代码有问题。
//04：err     because：arr[1]->'b'->98，传递给strlen也是错误的。
//05：unknown because：&arr是数组的地址，起始位置是数组的第一个元素的位置，结果随机。
//06：unknown because：随机值 x-6
//07：unknown because：随机值 x-1

2.2.3 代码3

c 复制代码 
#include <stdio.h>

int main()
{
	char arr[] = "abcdef";
	printf("01：%zd\n", sizeof(arr));
	printf("02：%zd\n", sizeof(arr + 0));
	printf("03：%zd\n", sizeof(*arr));
	printf("04：%zd\n", sizeof(arr[1]));
	printf("05：%zd\n", sizeof(&arr));
	printf("06：%zd\n", sizeof(&arr + 1));
	printf("07：%zd\n", sizeof(&arr[0] + 1));
	return 0;
}
c 复制代码 
运行（32位）：
01：7
02：4
03：1
04：1
05：4
06：4
07：4
c 复制代码 
运行（64位）：
01：7
02：8
03：1
04：1
05：8
06：8
07：8

解析：

c 复制代码 
解析：
//01：7     because：数组总大小，7个字节。
//02：4/8   because：首元素地址。
//03：1     because：首元素。
//04：1     because：第二个元素。
//05：4/8   because：数组地址。
//06：4/8   because：跳过整个数组的地址。
//07：4/8   because：第二个元素的地址。

2.2.4 代码4

c 复制代码 
#include <stdio.h>

int main()
{
	char arr[] = "abcdef";
	printf("01：%zd\n", strlen(arr));
	printf("02：%zd\n", strlen(arr + 0));
	//printf("03：%zd\n", strlen(*arr));
	//printf("04：%zd\n", strlen(arr[1]));
	printf("05：%zd\n", strlen(&arr));
	printf("06：%zd\n", strlen(&arr + 1));
	printf("07：%zd\n", strlen(&arr[0] + 1));
	return 0;
}
c 复制代码 
运行：
01：6
02：6
05：6
06：26
07：5

解析：

c 复制代码 
解析：
//01：6        because：6
//02：6        because：arr首元素的地址，arr+0还是首元素的地址。
//03：err      because：'a' ->97,err
//04：err      because：'b' ->98,err
//05：6        because：数组地址。
//06：unknown  because：跳过整个数组的地址。
//07：5        because：5

2.2.5 代码5

c 复制代码 
#include <stdio.h>

int main()
{
	char* p = "abcdef";
	printf("01：%zd\n", sizeof(p));
	printf("02：%zd\n", sizeof(p + 1));
	printf("03：%zd\n", sizeof(*p));
	printf("04：%zd\n", sizeof(p[0]));
	printf("05：%zd\n", sizeof(&p));
	printf("06：%zd\n", sizeof(&p + 1));
	printf("07：%zd\n", sizeof(&p[0] + 1));
	return 0;
}
c 复制代码 
运行（32位）：
01：4
02：4
03：1
04：1
05：4
06：4
07：4
c 复制代码 
运行（64位）：
01：8
02：8
03：1
04：1
05：8
06：8
07：8

解析：

c 复制代码 
解析：
//01：4/8      because：p是指针变量，计算指针变量的大小。
//02：4/8      because：b的地址。
//03：1        because：*p是char类型，1个字节。
//04：1        because：p[0] -> *(p+0) -> *p -> 'a' 大小1个字节。
//05：4/8      because：取出的是p的地址。
//06：4/8      because：跳过p指针变量后的地址。
//07：4/8      because：取出字符串首字符的地址，+1是第二个字符的地址。

2.2.6 代码6

c 复制代码 
#include <stdio.h>

int main()
{
	char* p = "abcdef";
	printf("01：%zd\n", strlen(p));
	printf("02：%zd\n", strlen(p + 1));
	//printf("03：%zd\n", strlen(*p));
	//printf("04：%zd\n", strlen(p[0]));
	printf("05：%zd\n", strlen(&p));
	printf("06：%zd\n", strlen(&p + 1));
	printf("07：%zd\n", strlen(&p[0] + 1));
	return 0;
}
c 复制代码 
运行：
01：6
02：5
05：3
06：11
07：5

解析：

c 复制代码 
解析：
//01：6       because：传入首元素的地址。
//02：5       because：传入第二个元素的地址。
//03：err     because：'a' -> 97,err
//04：err     because：'a' -> 97,err
//05：unknown because：&p是指针变量p的地址，和字符串"abcdef"关系不大
// 从p这个指针变量的起始位置开始向后数的，p变量存放的地址是什么，不知道，因此随机值。
//06：unknown because：随机值
//07：5       because：第二个字符的地址。

2.3 二维数组

c 复制代码 
#include <stdio.h>

int main()
{
	int a[3][4] = { 0 };
	printf("01：%zd\n", sizeof(a));
	printf("02：%zd\n", sizeof(a[0][0]));
	printf("03：%zd\n", sizeof(a[0]));
	printf("04：%zd\n", sizeof(a[0] + 1));
	printf("05：%zd\n", sizeof(*(a[0] + 1)));
	printf("06：%zd\n", sizeof(a + 1));
	printf("07：%zd\n", sizeof(*(a + 1)));
	printf("08：%zd\n", sizeof(&a[0] + 1));
	printf("09：%zd\n", sizeof(*(&a[0] + 1)));
	printf("10：%zd\n", sizeof(*a));
	printf("11：%zd\n", sizeof(a[3]));
	return 0;
}
c 复制代码 
运行（32位）：
01：48
02：4
03：16
04：4
05：4
06：4
07：16
08：4
09：16
10：16
11：16
c 复制代码 
运行（64位）：
01：48
02：4
03：16
04：8
05：4
06：8
07：16
08：8
09：16
10：16
11：16

解析：

c 复制代码 
解析:
//01：48       because：数组的大小，48 = 3*4*sizeof(int)
//02：4        because：第一行第一个元素。
//03：16       because：第一行的数组名，单独放在sizeof内部了。
//04：4/8      because：a[0]第一行的数组名，但是a[0]并没有单独放在sizeof内部，
// 所以这里的数组名a[0]是数组首元素的地址，+1就是a[0][1]的地址。
//05：4        because：第一行第二个元素。
//06：4/8      because：a作为数组名并没有单独放在sizeof内部，a表示数组首元素的地址，
// 是二维数组首元素的地址，也就是第一行的地址，a+1跳过一行，指向第二行。
//07：16       because：a+1是第二行的地址，*(a+1)就是第二行，计算的是第二行的大小。
// *(a+1) == a[1]，a[1]是第二行数组名。
//08：4/8      because：a[0]是第一行的数组名，&a[0]取出的是数组的地址，&a[0]+1就是第二行的地址。
//09：16       because：对第二行的地址解引用。
//10：16       because：a作为数组名并没有单独放在sizeof内部，所以a表示数组首元素的地址，是
// 二维数组首元素的地址，也就是第一行的地址，*a就是第一行，计算的是第一行的大小。
// *a == *(a+0) == a[0]
//11：16       because：a[3]无需真实存在，可以通过类型推断算出长度。a[3]是第四行的数组名。

3、指针运算笔试题解析

3.1 题目1

c 复制代码 
#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;
}
c 复制代码 
运行：
2,5

画图解析:

3.2 题目2

c 复制代码 
//在X86环境下  
//假设结构体的大小是20个字节  
//程序输出的结构是啥?  
#include<stdio.h>
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;
}
c 复制代码 
运行：
00100014
00100001
00100004

解析：

1、struct Test* p = (struct Test*)0x100000; // 将指针p强制指向内存地址 0x100000。

2、printf("%p\n", p + 0x1);

  • 当对指针进行加法（如p+0x1）时，实际地址的偏移量 = 指针指向类型的大小 * 加数。
  • p是struct Test*类型，0x100000 + 0x1 * 20 = 0x100000+0x14 = 0x100014。

3、printf("%p\n", (unsigned long)p + 0x1);

  • p被强制转化为unsigned long，此时是普通整数加法。

4、printf("%p\n", (unsigned int*)p + 0x1);

  • p被强制转化为unsigned int*，指针运算的单位是unsigned int的大小。

3.3 题目3

c 复制代码 
#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;
}
c 复制代码 
运行：
1

解析：

c 复制代码 
int* p = a[0];        // p 指向第一行首地址（即 &a[0][0]）
printf("%d", p[0]);   // 访问 p[0] = a[0][0]

3.4 题目4

c 复制代码 
//假设环境是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;
}
c 复制代码 
运行：
FFFFFFFC,-4

解析：

  • a[4][2]是第四行第2列的元素：
c 复制代码 
地址 = a基址 + 4行偏移 + 2列偏移  
     = a + (4×5 + 2)×4 = a + 88 字节
  • p[4][2]是第4个int[4]数组的第2个元素：
c 复制代码 
地址 = p基址 + 4个数组偏移 + 2列偏移  
     = a + (4×4 + 2)×4  = a + 72 字节
  • 地址差
c 复制代码 
&p[4][2] - &a[4][2] = (a + 72) - (a + 88) = -16 字节
  • 以int为单位的：
c 复制代码 
-16 字节 / sizeof(int) = -4

输出解释：

  • 在%p格式中，-4的补码表示为0xFFFFFFFC（32位系统）。

3.5 题目5

c 复制代码 
#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;
}
c 复制代码 
运行：
10,5

3.6 题目6

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

3.7 题目7

c 复制代码 
#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;
}
c 复制代码 
运行：
POINT
ER
ST
EW

完。

相关推荐
YuforiaCode2 小时前
第十六届蓝桥杯 2025 C/C++组 破解信息
c语言·c++·蓝桥杯
南玖yy2 小时前
C++ 成员变量缺省值：引用、const 与自定义类型的初始化规则详解，引用类型和const类型的成员变量自定义类型成员是否可以用缺省值？
c语言·开发语言·c++·后端·架构·c++基础语法
YuforiaCode2 小时前
第十六届蓝桥杯 2025 C/C++组 旗帜
c语言·c++·蓝桥杯
YuforiaCode2 小时前
第十六届蓝桥杯 2025 C/C++B组 第二轮省赛 全部题解（未完结）
c语言·c++·蓝桥杯
keep intensify3 小时前
数据结构---单链表的增删查改
c语言·数据结构·c++·经验分享·学习·算法·分享
XWXnb63 小时前
STM32 中断系统深度剖析
c语言·开发语言·stm32·嵌入式硬件
大模型铲屎官4 小时前
Unity C# 与 Shader 交互入门：脚本动态控制材质与视觉效果 (含 MaterialPropertyBlock 详解)(Day 38)
c语言·unity·c#·交互·游戏开发·材质·shader
夜夜敲码12 小时前
C语言教程（十八）：C 语言共用体详解
c语言·开发语言
努力创造奇迹20 小时前
C 语言联合体、枚举、typedef 详解
c语言·开发语言
热门推荐
01KGG转MP3工具|非KGM文件|解密音频02从零安装 LLaMA-Factory 微调 Qwen 大模型成功及所有的坑03西电B测-计算机网络综合实验(含验收问题)04Coze扣子平台完整体验和实践（附国内和国际版对比）05YOLOv8入门 | 重要性能衡量指标、训练结果评价及分析及影响mAP的因素【发论文关注的指标】06DeepSeek各版本说明与优缺点分析07【VIsion Master】机器视觉软件二次开发（C#版本）学习笔记08yolov8，yolo11，yolo12 服务器训练到部署全流程 笔记09我决定放弃搞 Java 了10Python基于Flask的豆瓣电影数据分析可视化系统（附源码，文档说明）