内存,通常被严谨地画成下面这个样子,一个下方是低地址上方是高地址的格子楼。
但我今天换种画法,画成下面这个样子。
每个格子代表内存中的 1 个字节(8 位),格子上的数字就代表内存地址,我也直接用 10 进制来表示了,免得 16 进制又算不明白了。
目前内存是完全空的,格子里没有任何内容。
试想一下,如果你忘掉所有的语法规则和编程规范,你会如何描述对这些内存格子的操作呢?
一、类型系统
很简单,往格子 3 处放个数字 29,往格子 6 处放个数字 38,就这么简单直接地描述即可。
但是这样说话太麻烦了,什么往格子 3 处放个数字 29 的,废话太多,也不方便不讲感情的计算机去理解。
那我们就定个指令,使用 mov $x, (y) 表示把数字 x 放入格子 y,如下:
mov $
29
, (
3
)

mov $
38
, (
6
)

这就表示刚刚说的:
把数字 
29
 放入内存格子 
3
把数字 
38
 放入内存格子 
6
是不是太简单了?别急,好戏马上开始!
如果要把数字 999 放入内存格子 8,该怎么办呢?
由于 1 个格子表示 1 个字节,只有 8 位,因此只能表示 256 个数字,要么是有符号的 -128 ~ 127,要么是无符号的 0 ~255,显然数字 999 无法放在 1 个格子内,只能占用 2 个格子了。
那也好办,就这么说,把数字 999 放入格子 8,连续占用两个格子。
但这样,我们刚刚的 mov 指令就得改改了,不但要表示"存放"这个含义,还得表示占用了多少个格子。
我们用 movb 表示只占 1 个字节,用 movw 表示占用 2 个字节。那么,刚刚的三个数字,就分别可以这样用指令来表示了:
movb $
29
, (
3
)

movb $
38
, (
6
)

movw $
999
, (
8
)

含义就是:
把数字 
29
 放入内存格子 
3
,占 
1
 个字节

把数字 
38
 放入内存格子 
6
,占 
1
 个字节

把数字 
999
 放入内存格子 
8
,占 
2
 个字节

OK,既然有了 1 字节和 2 字节的的指令,不妨再设计下,用 movl 表示 4 字节,movq 表示 8 字节 ...
movb 占用 
1
 字节

movw 占用 
2
 字节

movl 占用 
4
 字节

movq 占用 
8
 字节

不知不觉,类型系统就被你悄悄设计出来了!当然,虽然这只是个半成品。
二、变量
你不断地往不同格子里放数据。
比如我把我的年龄放在 11 号格子(占 1 字节),把我的月薪放在 14 号格子(占 4 字节)。
现在我们的内存已经非常混乱了,你根本记不住原来的 3 号格子放的数据表示什么,11 号格子又表示什么,只能通过看数字知道 14 号格子里放的确实是我的月薪。这该怎么办呢?
增加一层抽象嘛!我们给这些放了我们数据的格子,都贴上个标签,就可以不用再记那些无意义的格子编号了。
这样以来,其实我们也不再关心,这些标签到底在哪个格子里,只要给我找到格子把我的数据放进去就可以了。
movb $
29
, a

movb $
38
, b

movw $
999
, c

movb $
18
, age

movl $
2147483647
, salary

当然,我还需要再通过这个标签,把我刚刚放进去的数据找出来。
这很简单,但存在一个问题,放进去的时候,我们可以通过 movb,movw,movl 等知道占用多少个格子。而取出来的时候,标签上可没有写这个数据占用了多少个格子,这是有问题的。
因此,在定义这个标签时,不能光取个名字,还需要有个信息就是,这个标签对应的数据,占了多少个格子。
我们就效仿刚刚的存放操作,也规定一系列单词,来修饰这些标签,表示占用了多少个格子。
char 表示 1 个字节,short 表示 2 个字节,int 表示 4 个字节,long 表示 8 个字节 ...
于是乎刚刚的 5 个数据,就可以表示为如下指令:
char
 a = 
29
;

char
 b = 
38
;

short c = 
999
;

char
 age = 
18
;

int
 salary = 
2147483647
;

行了,我也别藏着掖着了,相信大家也知道,这里就是 C 语言的写法,而刚刚那堆 mov 是汇编语言的写法。
这些 char a,char b,int salary 等,就是变量!记住,变量不但要有名字,还得有类型!
三、变量定义与赋值
其实,刚刚的写法,是把变量的定义与赋值操作写在一行了。
比如有如下语句:
int
 a = 
1
;

实际上是分成两步的:
// 变量的定义
int
 a;

// 变量的赋值(此处也可以叫变量的初始化)
a = 
1
;

其中变量的定义是为了方便程序员后面去用它,这部分不是给 CPU 看的。
而变量的赋值才是真正在内存中把数据放进去,这部分才真正涉及 CPU 具体指令的执行。
也就是说,如果你仅仅定义了一个变量 int a; 但是没有给它初始化的赋值操作,那么最终在 CPU 执行指令的时候,这个定义根本就没有任何体现。

四、指针
现在,让我们把内存清空,回到一开始的那一片净土上。
我们来搞点花样。我将我的密码(1234)存储在一个 short a 中,假设这个变量 a 被放在了 6 号格子处。
同时,我将这个变量 a 的地址,也就是 6 这个数字,存储在另一个变量 int p 中,假设这个变量 p 被放在了 1 号格子处。
这样,我寻找我密码的方式,就是先通过 p 所在的内存地址找到里面存的值,也就是 a 的内存地址 6,再通过 a 的内存地址找到里面存的值,也就是我要找的密码 1234。
我们可以用下面的代码来表示刚刚的存放逻辑。
short a = 
1234
;

// 假设 a 被放在了 6 号格子处
int
 p = 
6
;

这里的 p 和 a 都是变量,只不过,p 这个变量有点特殊,它里面存放的值是一个内存地址,我们把 p 这个变量形象地成为指针变量,简称指针
不过,这样有几个问题,我一个个来说。
1. 取地址
首先,我们在编码阶段,无法知道也无需知道变量 a 会存放在哪里,不然就失去了标签的含义,又回到了需要关心具体的内存地址(也就是格子编号)的时代了。
所以,我们应该有个方法,来在编码阶段表示变量 a 的地址的含义,姑且就叫做 &a 吧。
那么我们的代码,就可以优化为:
short a = 
1234
;

// 假设 a 的地址是 6
// 那么下面的 p 就等于 6
int
 p = &a;

用图来表示就是:
2. 指针变量本身的大小
视角放到这个变量 p 身上,虽然本质上这个变量 p 里面存放的就是一个数值,假设是 6,但是它却表示了一个内存地址的值。
如果让程序员随便规定这个变量 p 的数据类型(也就是占多少个字节),那显然容易出问题。
比如内存地址是 999,那么我用一个 char 类型的变量 p 来存放它,就会有问题。
我们在编码阶段是无法确定一个变量的内存地址是多少的,所以用什么类型的变量来存放它,也是无法判断的。
所以,最稳妥的办法就是,用一个完全能容纳所有内存地址范围的变量类型来存放指针变量。
我们姑且认为我们是在一个 32 位的系统上,那么用一个 4 字节大小的变量来存放,就可以了。(当然,实际上这取决于你的编译器的位数)
现在,我们的指针变量所占用的内存大小,就是固定的 4 个字节,也就是 4 个格子。
程序员无需也无法修改这个大小,那么我们就可以把 p 前面的数据类型去掉了。
short a = 
1234
;

p = &a;

3. 指针变量的类型
刚刚我们解决了指针变量本身所占用的内存大小,但是还有一个问题没有解决,就是指针变量里存放的内存地址处的变量的大小。
也就是说,上面的指针变量 p 里虽然存放了变量 a 的内存地址 6,但是指针变量 p 却没有任何信息,来说明内存地址 6 处的变量,它的大小是多少。
假如,我们认为内存地址 6 处的变量是个 char 类型,也就是只占用了一个字节,那么显然,会取出一个不符合预期的值。
当然,如果认为 6 处的变量是个 int 类型,占 4 个字节,虽然数值上可能没有问题,但从某种程度上讲也是不太符合预期的(假如 8 号和 9 号格子里有其他内容,那就更不符合预期了)
所以,必须得完全按照变量本身的类型,也就是 short 类型来读取此内存地址处的值,才是正确的。
那我们应该如何表示这个信息呢?即如何表示,变量 p 是一个指针,且这个指针里面存放的内存地址处的变量的类型是 short。
很好办,直接说答案吧。
short a = 
1234
;

short * p = &a;

p 前面的 * 表示变量 p 是一个指针类型,再前面的 short 表示该指针指向的内存地址处的变量,是个 short 类型的变量。
当然,更准确的说法是,指针 p 将会按照 short 类型的变量来读取它指向的内存,至于那里到底是什么,无所谓。
注意哦,这个 short 并不是表示指针变量本身的大小占 2 个字节,指针变量本身我们前面说过了,就是固定的 4 字节大小。
不过总是这样说太绕口了,今后我们就说,变量 p 是个 short * 类型的指针,就可以了。
用上面的图形象地说就是,右边变量 a 蓝色的填充,表示 a 是个 short 类型,而外面的虚线框框,表示指针 p 按照 short 类型的变量来"解读"内存地址 6 处的数值。
两者相匹配了,就是"正确"的编程代码了。
当然,这里的"正确",是说给程序员听的,CPU 才不关心。
4. 指针所指向的值
上面我们已经可以获得某个变量的地址,比如获取 a 的地址就是:
&a

同时我们也可以定义一个指针变量,比如定义一个 short * 类型的指针变量 p:
short * p;

并且,我们通过直接赋值操作,可以给指针变量进行初始化:
p = &a;

当然,上面的代码也可以连起来写,即指针变量 p 的定义与初始化写在同一行:
short * p = &a;

不过,我们还没有一个方法,来表示指针变量 p 所指向的那块内存。
那我们就发明一个,比如想把 p 所指向的那块内存的值改为 999,可以这样写。
*p = 
999
;

这里的 * 就表示"指向"的含义,即 *p 不是说 p 这个变量的内存地址,而是把 p 这个变量里存的内容当做内存地址来看,指向这个内存地址。
用图表示就是:
所以连起来一个完整的程序就是:
short a = 
1234
;

// 指针的定义
short * p;

// 指针的初始化,也即指针变量本身的值
p = &a;

// 指针变量所指向的内存地址的值
*p = 
999
;

执行过后,a 的值会变成 999,或者说 6 号格子与 7 号格子里的值会变成 999。
5. 指针的加减
如果对一个普通变量 +1,比如说:
int
 a = 
1
;

int
 b = a + 
1
;

那显然,b 的值应该是 2,毫无疑问。
但是如果对一个指针变量 +1,会怎么样呢?
int
 a = 
1
;

int
 *p = &a;

int
 *p2 = p + 
1
;

我们假设变量 a 放在了格子 1 处。
变量 a 的值是什么,以及变量 p 被放在了哪里,我们都不关心,就只盯着 p 的值看,显然,一开始的时候是 1。
(为方便演示,下面的图直接表示 p 所指向的内存地址,而不是 p 本身所在的内存地址)
我们先不考虑,p + 1 应该是几,如果让你来设计这个语言,你觉得 p + 1 是几比较好呢?
我认为,只有两种较为合理的设计。
第一种,p + 1 就等于 2,就简简单单当做数值进行加法运算而已。
第二种,p + 1 等于 5,即跨过一个 p 所指向的内存单元的数据类型的大小,也就是 4 字节的 int。
你觉得那种比较合理呢?
那显然是第二种嘛!不然和普通变量有啥区别了,你既然设计出了指针变量这个玩意,就需要让它发挥点方便程序员的作用,这才是你设计它的真正目的。
当然你不服,你就想让这个 int * 类型的指针变量,就真真正正在数值上只 +1,也就是让 p 等于 2,该怎么办呢?
很简单,分成三步就好了:
第一步,把 int * 类型的 p 强转为 char * 类型的 p。
第二步,p + 1。
第三步,再把 char * 类型的 p 强转为 int * 类型。
完事!用代码表示就是:
p = (
int
 *)((
char
 *)p + 
1
);

你会看到,C 语言项目中经常使用这样的玩法。
当然,你这一顿花里胡哨的操作,在 CPU 眼里,就是对一个内存地址处的值简简单单地 +1 而已。
五、指针的本质
我们看上面的一张图:
其实,别看上面又 short * p 又 short a 的,这是给程序员和编译器看的。
在 CPU 眼里,根本没有这些眼花缭乱的标签,以及五花八门的解读,就是 0 ~ 4 号格子里存了个数字 6,然后 6 ~ 7 号格子里存了个数字 1234,仅此而已。
更进一步讲,其实就只是 1 号格子里存储了数字 6(234 号格子是空的),6 号格子里存储了数字 12,7 号格子里存储了数字 34。
(当然实际得转换成二进制,再结合大端序还是小端序来看哈,我这里就是简单直观告诉大家 CPU 才不管那么多,就一个格子一个格子的放数字就完事了)
所以,我们经常听书上讲,让大家一定要记住,指针变量中只能存放地址,不要将一个整数或任何其他非地址类型的数据赋给一个指针变量了。
这种说法就非常别扭,很多书上,即想讲清楚指针的本质,又想讲清楚指针的注意事项,混杂在一起,让读者即没有搞清楚指针的本质,又不知道指针的注意事项。
真纠结!
说实话,就光看书而没有经过大量 C 语言的实践,谁能记得住或者理解透彻那些注意事项。而经过大量 C 语言实践的人,指针早就融入进血液中了,谁还来看你讲指针的本质?所以说,这块我觉得非常之矛盾。
实际上,指针变量的本质和普通变量是一样的:
普通变量,写个 short a,是在告诉编译器,当我 a = 1 时,你给我找到一块 2 字节的内存,把 1 填充进去。
指针变量,写个 short * p,是在告诉编译器两件事情:
当我 p = xxx 时,你给我找到一块 4 字节的内存(我们假设指针本身的大小固定 4 字节),把 xxx 填充进去,这就和普通变量完全一样;
当我 *p = yyy 时,你给我找到 xxx 内存地址,并且按照 short 类型也就是 2 字节大小,把 yyy 填充到这里。
所以,谁说不能把一个整型变量赋给指针了,我这不就把一个整型变量 xxx 赋给指针 p 了么,我赋值的时候就说它是整型变量了,怎么的吧?
但是我用它的时候,我 *p 又把 xxx 看做是一个内存地址了,就去找内存 xxx 的地方,又怎么的吧?
用代码来表示就是:
我强行把一个整型数值 6 赋值给指针变量 p,然后 *p 去访问内存地址 6 并修改那个地方的值:
int
 * p = 
6
;

*p = 
999
;

我还可以把一个地址值,强行赋值给一个普通变量:
int
 a = 
1
;

int
 b = &a;

这时普通变量 b 里面存储着 a 的地址,我 *b 也同样可以访问到 a 并修改它的值:
*b = 
999
;

当然如果你真这么写编译器会报错,但没关系,我们可以先把普通变量 b 强转为指针变量,然后再 * 它:
*(
int
 *)b = 
999
;

你还可以玩些更花哨的,先 & 取地址,再 * 取值,虽然没啥用:
*((
int
 *)*(&p)) = 
999
;

假如 a 的地址是 6 的话,其实你这些花里胡哨的操作,最后到人家 CPU 眼里,就是一条简单的指令:
movl $
999
, (
6
)

就是想把 999 放在 6 号格子嘛!
所以,不要把指针想得多么复杂和神圣,它就是方便了程序员编程,同时告诉编译器应该怎么编译成最终的指令。
你写了个 *p,就是把 p 的值当做内存地址去访问,在汇编语言层面就是加了个括号:
(p)

你写了个 &a,就是取出变量 a 的内存地址,在汇编语言层面就是 lea 指令:
lea a, xxx

你如果写了个 ***p 那就是,相当于加了三次括号:
(((p)))

当然啦,以上都是方便理解的伪指令,具体落实到真正的汇编语言,我会在后续的章节中讲述,直接从汇编语言理解指针,你就会发现指针就是个工具人而已。
六、写在最后
我们从最开始的内存格子出发,逐渐推导出类型系统和变量的作用,进而再引出本质上和普通变量没有任何区别的指针变量,最后再推导出指针变量相关的操作,带你看清了指针的本质。
你不要去记本文的知识点,重在整个推导的过程,要去理解指针想解决的问题是什么,它的合理性在哪,哪一部分信息是给程序员和编译器看的,哪一部分操作最终又是真正落实到 CPU 指令的,这些才是关键。
当然,我还是给你简单总结下知识点相关的部分,其实简单说,就这么几件事。
定义一个指针:
int
 * p;

赋值或初始化一个指针:
p = &a;

修改指针的内容:
*p = 
999
;

指针的加减(其实到后面讲的数组才有价值):
p = p + 
1
;

完事,就这些!
最后,给大家推荐两个网站。
一个是可以将 C 语言代码实时编译成汇编代码,你可以用它来自己玩指针做实验,看它最终到 CPU 指令层面是什么样。
https://godbolt.org
一个是 GNU C 手册,里面对各种语法和作用讲述的非常清楚,不要再用百度搜博客了。
https://www.gnu.org/software/gnu-c-manual/gnu-c-manual.html
比如讲类型系统里的整型类型:
再比如讲指针的定义和初始化:
我相信本文看下来,一定有人想问,short * p 是不是应该写成:
short *p

或者
short* p

自己去上面的文档里找答案即可。
- EOF -
关注「程序员的那些事」加星标,不错过圈内事
点赞和在看就是最大的支持❤️
继续阅读
阅读原文