系统性学习C语言-第十一讲-深入理解指针（1）

已于 2025-05-31 19:18:39 修改
阅读量1.1k 收藏 28
点赞数 22
分类专栏： 系统性学习 C语言 文章标签： 学习 c语言 microsoft
于 2025-05-30 23:20:21 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2401_87023016/article/details/148306982
版权

系统性学习C语言-第十一讲-深入理解指针（1）

1. 内存和地址

1.1 内存

在讲内存和地址之前，我们先举出一个⽣活中的案例：

假设有⼀栋宿舍楼，把你放在楼⾥，楼上有100个房间，但是房间没有编号，你的⼀个朋友来找你玩，

如果想找到你，就得挨个房⼦去找，这样效率很低，但是我们如果根据楼层和楼层的房间的情况，给每个房间编上号，如：

⼀楼：101，102，103...
⼆楼：201，202，203...
...

有了房间号，如果你的朋友得到房间号，就可以快速的找房间，找到你。

⽣活中，每个房间有了房间号，就能提⾼效率，能快速的找到房间。

如果把上⾯的例⼦对照到计算机中，⼜是怎么样呢？

我们知道计算机上CPU（中央处理器）在处理数据的时候，需要的数据是在内存中读取的，处理后的数据也会放回内存中，

那我们买电脑的时候，电脑上内存是 8GB/16GB/32GB 等，那这些内存空间如何⾼效的管理呢？

其实也是把内存划分为⼀个个的内存单元，每个内存单元的⼤⼩取1个字节。

计算机中常⻅的单位（补充）：

⼀个⽐特位可以存储⼀个2进制的位1或者0

bit - ⽐特位            
Byte - 字节             1Byte = 8bit
KB                     1KB = 1024Byte
MB                     1MB = 1024KB
GB                     1GB = 1024MB
TB                     1TB = 1024GB
PB                     1PB = 1024TB

在这里插入图片描述

其中，每个内存单元，相当于⼀个学⽣宿舍，⼀个字节空间⾥⾯能放8个⽐特位，就好⽐同学们住的⼋⼈间，每个⼈是⼀个⽐特位。

每个内存单元也都有⼀个编号（这个编号就相当于宿舍房间的⻔牌号），有了这个内存单元的编号，CPU就能快速找到⼀个内存空间。

⽣活中我们把⻔牌号也叫地址，在计算机中我们把内存单元的编号也称为地址。C语⾔中给地址起了新的名字叫：指针。

所以我们可以理解为：

内存单元的编号 == 地址 == 指针

1.2 究竟该如何理解编址

⾸先，必须理解，计算机内是有很多的硬件单元，⽽硬件单元是要互相协同⼯作的。所谓的协同，⾄少相互之间要能够进⾏数据传递。

但是硬件与硬件之间是互相独⽴的，那么如何通信呢？答案很简单，⽤"线"连起来。

⽽CPU和内存之间也是有⼤量的数据交互的，所以，两者必须也⽤线连起来。

不过，我们今天关⼼⼀组线，叫做地址总线。

在这里插入图片描述

CPU 访问内存中的某个字节空间，必须知道这个字节空间在内存的什么位置，⽽因为内存中字节很多，

所以需要给内存进⾏编址(就如同宿舍很多，需要给宿舍编号⼀样)。

计算机中的编址，并不是把每个字节的地址记录下来，⽽是通过硬件设计完成的。

钢琴、吉他 上⾯没有写上“剁、来、咪、发、唆、拉、西”这样的信息，但演奏者照样能够准确找到每⼀个琴弦的每⼀个位置，

这是为何？因为制造商已经在乐器硬件层⾯上设计好了，并且所有的演奏者都知道。本质是⼀种约定出来的共识！

硬件编址也是如此。

我们可以简单理解，32 位机器有 32 根地址总线，每根线只有两态，表⽰ 0, 1【电脉冲有⽆】，那么 1 根线，就能表⽰ 2 种含义，

2 根线就能表⽰ 4 种含义，依次类推。32 根地址线，就能表⽰ 2 ^ 32 种含义，每⼀种含义都代表⼀个地址。

地址信息被下达给内存，在内存上，就可以找到该地址对应的数据，将数据在通过数据总线传⼊ CPU 内寄存器。

2. 指针变量和地址

2.1 取地址操作符 &

理解了内存和地址的关系，我们再回到 C语⾔ ，在 C语⾔ 中创建变量其实就是向内存申请空间，⽐如：

#include <stdio.h>
int main()
{
	int a = 10;
	return 0;
}

在这里插入图片描述

比如，上述的代码就是创建了整型变量 a ，内存中申请 4 个字节，用于存放整数 10 ，其中每个字节都有地址，

上图中 4 个字节的地址分别是：

0x006FFD70
0x006FFD71
0x006FFD72
0x006FFD73

那我们如何能得到 a 的地址呢？

这里就得学习⼀个操作符 & 取地址操作符

#include <stdio.h>
int main()
{
	int a = 10;
	&a;//取出a的地址
	printf("%p\n", &a);
	return 0;
}

在这里插入图片描述

按照画图的例子，会打印出：006FFD70 ；&a 取出的是 a 所占 4 个字节中地址较小的字节的地址。

虽然整型变量占用 4 个字节，我们只要知道了第一个字节地址，顺藤摸瓜访问到 4 个字节的数据也是可行的。

2.2 指针变量和解引用操作符 *

2.2.1 指针变量

通过取地址操作符 & 拿到的地址是⼀个数值，比如： 0x006FFD70 ，这个数值有时候也是需要存储起来，方便后期再使用的，

那我们把这样的地址值存放在哪里呢？答案是：指针变量中。

比如：

#include <stdio.h>
int main()
{
	int a = 10;
	int * pa = &a;//取出a的地址并存储到指针变量pa中
	return 0;
}

指针变量也是⼀种变量，这种变量就是用来存放地址的，存放在指针变量中的值都会理解为地址。

2.2.2 如何拆解指针类型

我们看到 pa 的类型是 int* ，我们该如何理解指针的类型呢？

int a = 10;
int * pa = &a;

这里 pa 左边写的是 int* ，* 是在说明 pa 是指针变量，而前面的 int 是在说明 pa 指向的是整型 int 类型的对象。

在这里插入图片描述
那如果有⼀个 char 类型的变量 ch ， ch 的地址，要放在什么类型的指针变量中呢？

char ch = 'w';
char* pc = &ch;//pc 的类型怎么写呢？

与 int 类型是相似的，若是存储字符类型的变量，则变量的类型为 char*

其他内置类型的变量例如 long 、double 、float 等都以此类推。

2.2.3 解引用操作符

我们将地址保存起来，未来是要使用的，那怎么使用呢？

在现实生活中，我们使用地址要找到一个房间，在房间⾥可以拿去或者存放物品。

C语言 中其实也是一样的，我们只要拿到了地址（指针），就可以通过地址（指针）找到地址（指针）指向的对象，

这里必须学习一个操作符叫解引用操作符 * 。

#include <stdio.h>

int main()
{
	int a = 100;
	int* pa = &a;
	*pa = 0;
	return 0;
}

上面代码中第 7 行就使用了解引用操作符， *pa 的意思就是通过 pa 中存放的地址，找到指向的空间，*pa 其实就是a变量了；

所以*pa = 0 ，这个操作符是把 a 改成了 0。

有同学肯定在想，这⾥如果目的就是把 a 改成 0 的话，写成 a = 0; 不就完了，为啥非要使用指针呢？

其实这里是把 a 的修改交给了 pa 来操作，这样对 a 的修改，就多了一种途径，写代码就会更加灵活，

后期慢慢就能理解了。

2.3 指针变量的大小

前面的内容我们了解到，32 位机器假设有 32 根地址总线，每根地址线出来的电信号转换成数字信号后是 1 或者 0 ，

那我们把 32 根地址线产生的 2 进制序列当做⼀个地址，那么一个地址就是 32 个 bit 位，需要 4 个字节才能存储。

如果指针变量是用来存放地址的，那么指针变量的大小就得是 4 个字节的空间才可以。

同理 64 位机器，假设有 64 根地址线，一个地址就是 64 个⼆进制位组成的⼆进制序列，存储起来就需要 8 个字节的空间，

指针变量的大小就是 8 个字节。

#include <stdio.h>
//指针变量的⼤⼩取决于地址的⼤⼩
//32位平台下地址是32个bit位（即4个字节）
//64位平台下地址是64个bit位（即8个字节）
int main()
{
	printf("%zd\n", sizeof(char *));
	printf("%zd\n", sizeof(short *));
	printf("%zd\n", sizeof(int *));
	printf("%zd\n", sizeof(double *));
	return 0;
}

X86 环境下代码的运行结果：

在这里插入图片描述
X64 环境下代码的运行结果：

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

  • 32 位平台下地址是 32 个 bit 位，指针变量大小是 4 个字节

  • 64 位平台下地址是 64 个 bit 位，指针变量大小是 8 个字节

  • 注意指针变量的大小和类型是无关的，只要指针类型的变量，在相同的平台下，大小都是相同的。

3. 指针变量类型的意义

指针变量的大小和类型无关，只要是指针变量，在同一个平台下，大小都是一样的，为什么还要有各种各样的指针类型呢？

其实指针类型是有特殊意义的，我们接下来继续学习。

3.1 指针的解引用

对比，下面 2 段代码，主要在调试时观察内存的变化。

//代码1
#include <stdio.h>
int main()
{
	int n = 0x11223344;
	int *pi = &n;
	*pi = 0;
	return 0;
}

//代码2
#include <stdio.h>
int main()
{
	int n = 0x11223344;
	char *pc = (char *)&n;
	*pc = 0;
	return 0;
}

在这里插入图片描述
在这里插入图片描述

调试我们可以看到，代码 1 会将 n 的 4 个字节全部改为 0，但是代码 2 只是将 n 的第⼀个字节改为 0 。

结论：

指针的类型决定了，对指针解引用的时候有多大的权限（⼀次能操作几个字节）。

比如：char* 的指针解引用就只能访问一个字节，而 int* 的指针的解引用就能访问四个字节。

3.2 指针加减整数

先看⼀段代码，调试观察地址的变化。

#include <stdio.h>
int main()
{
	int n = 10;
	char *pc = (char*)&n;
	int *pi = &n;
	printf("%p\n", &n);
	printf("%p\n", pc);
	printf("%p\n", pc+1);
	printf("%p\n", pi);
	printf("%p\n", pi+1);
	return 0;
}

代码运行的结果如下：

在这里插入图片描述
我们可以看出，char* 类型的指针变量 +1 跳过 1 个字节，int* 类型的指针变量 +1 跳过了 4 个字节。

这就是指针变量的类型差异带来的变化。指针 +1 ，其实跳过 1 个指针指向的元素。指针可以 +1 ，那也可以 -1 。

结论：

指针的类型决定了指针向前或者向往后走一部有多大（距离）。

在指针类型中有⼀种特殊的类型是 void * 类型的，可以理解为无具体类型的指针（或者叫泛型指针），

这种类型的指针可以用来接受任意类型地址。但是也有局限性， void* 类型的指针不能直接进行指针的加减整数和解引用的运算。

举例：

#include <stdio.h>

int main()
{
	int a = 10;
	int* pa = &a;
	char* pc = &a;
	return 0;
}

在上面的代码中，将⼀个 int 类型的变量的地址赋值给⼀个 char* 类型的指针变量。

编译器给出了⼀个警告（如下图），是因为类型不兼容。

在这里插入图片描述

而使用 void* 类型就不会有这样的问题。

使用 void* 类型的指针接收地址：

#include <stdio.h>

int main()
{
	int a = 10;
	void* pa = &a;
	void* pc = &a;
	*pa = 10;
	*pc = 0;
	return 0;
}

VS 编译代码的结果：

在这里插入图片描述
这⾥我们可以看到，void* 类型的指针可以接收不同类型的地址，但是无法直接进行指针运算。

那么 void* 类型的指针到底有什么⽤呢？

⼀般 void* 类型的指针是使⽤在函数参数的部分，用来接收不同类型数据的地址，这样的设计可以实现泛型编程的效果。

使得⼀个函数来处理多种类型的数据，在《深入理解指针(4)》中我们会详细讲解。

4. 指针运算

指针的基本运算有三种，分别是：

  • 指针 加减 整数

  • 指针 减 指针

  • 指针的关系运算

4.1 指针 加减 整数

因为数组在内存中是连续存放的，只要知道第一个元素的地址，顺藤摸瓜就能找到后面的所有元素。

int arr[10] = {1,2,3,4,5,6,7,8,9,10};

在这里插入图片描述

#include <stdio.h>
//指针+- 整数
int main()
{
	int arr[10] = {1,2,3,4,5,6,7,8,9,10};
	int *p = &arr[0];
	int i = 0;
	int sz = sizeof(arr)/sizeof(arr[0]);
	for(i=0; i<sz; i++)
	{
		printf("%d ", *(p+i));//p+i 这⾥就是指针+整数
	}
	
	return 0;
}

在这里插入图片描述
可以观察到，代码成功通过指针加减整数的操作对数组成员进行了调用，只知道了第一个元素的地址，却调用了整个数组的成员。

4.2 指针 减 指针

#include <stdio.h>
int my_strlen(char* s)
{
	char* p = s;
	while (*p != '\0')
		p++;
	return p - s;
}

int main()
{
	char str[] = "abc";
	printf("%d\n", my_strlen(str));
	return 0;
}

在这里插入图片描述
可以观察到，代码成功通过指针 减 指针的操作，计算出了 str 字符数组中有几个字符成员。

4.3 指针的关系运算

//指针的关系运算
#include <stdio.h>

int main()
{
	int arr[10] = {1,2,3,4,5,6,7,8,9,10};
	int *p = &arr[0];
	int sz = sizeof(arr)/sizeof(arr[0]);
	while(p < arr + sz) //指针的⼤⼩⽐较
	{
		printf("%d ", *p);
		p++;
	}
	return 0;
}

在这里插入图片描述
在代码的 while 循环部分的判断条件处，代码通过指针的关系运算，将循环停止在了 arr + sz 处。

且在循环内部，通过调用地址 p 也成功调用了数组的成员。

到此，第十一讲 - 深入理解指针（1）部分的内容到此结束
如对文章有更好的意见与建议，一定要告知作者，读者的反馈对于我十分重要，希望读者们勤勉励学，精益求精，
我们下篇文章再见👋。

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值