一起来聊聊指针

先说内存，内存通常被严谨地画成下面这个样子，一个下方是低地址上方是高地址的格子楼。

但我今天换种画法，画成下面这个样子。

每个格子代表内存中的 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 个数据，就可以表示为如下指令：

chara=29;
charb=38;
shortc=999;
charage=18;
intsalary=2147483647;

行了，我也别藏着掖着了，相信大家也知道，这里就是 C 语言的写法，而刚刚那堆 mov 是汇编语言的写法。

这些 char a，char b，int salary 等，就是变量！记住，变量不但要有名字，还得有类型！

三、变量定义与赋值

其实，刚刚的写法，是把变量的定义与赋值操作写在一行了。

比如有如下语句：

inta=1;

实际上是分成两步的：

//变量的定义
inta;
//变量的赋值（此处也可以叫变量的初始化）
a=1;

其中变量的定义是为了方便程序员后面去用它，这部分不是给 CPU 看的。

而变量的赋值才是真正在内存中把数据放进去，这部分才真正涉及 CPU 具体指令的执行。

也就是说，如果你仅仅定义了一个变量 int a; 但是没有给它初始化的赋值操作，那么最终在 CPU 执行指令的时候，这个定义根本就没有任何体现。

四、指针

现在，让我们把内存清空，回到一开始的那一片净土上。

我们来搞点花样。我将我的密码（1234）存储在一个 short a 中，假设这个变量 a 被放在了 6 号格子处。

同时，我将这个变量 a 的地址，也就是 6 这个数字，存储在另一个变量 int p 中，假设这个变量 p 被放在了 1 号格子处。

这样，我寻找我密码的方式，就是先通过 p 所在的内存地址找到里面存的值，也就是 a 的内存地址 6，再通过 a 的内存地址找到里面存的值，也就是我要找的密码 1234。

我们可以用下面的代码来表示刚刚的存放逻辑。

shorta=1234;
//假设a被放在了6号格子处
intp=6;

这里的 p 和 a 都是变量，只不过，p 这个变量有点特殊，它里面存放的值是一个内存地址，我们把 p 这个变量形象地称为指针变量，简称指针。

不过，这样有几个问题，我一个个来说。

1. 取地址

首先，我们在编码阶段，无法知道也无需知道变量 a 会存放在哪里，不然就失去了标签的含义，又回到了需要关心具体的内存地址（也就是格子编号）的时代了。

所以，我们应该有个方法，来在编码阶段表示变量 a 的地址的含义，姑且就叫做 &a 吧。

那么我们的代码，就可以优化为：

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

用图来表示就是：

2. 指针变量本身的大小

视角放到这个变量 p 身上，虽然本质上这个变量 p 里面存放的就是一个数值，假设是 6，但是它却表示了一个内存地址的值。

如果让程序员随便规定这个变量 p 的数据类型（也就是占多少个字节），那显然容易出问题。

比如内存地址是 999，那么我用一个 char 类型的变量 p 来存放它，就会有问题。

我们在编码阶段是无法确定一个变量的内存地址是多少的，所以用什么类型的变量来存放它，也是无法判断的。

所以，最稳妥的办法就是，用一个完全能容纳所有内存地址范围的变量类型来存放指针变量。

我们姑且认为我们是在一个 32 位的系统上，那么用一个 4 字节大小的变量来存放，就可以了。（当然，实际上这取决于你的编译器的位数）

现在，我们的指针变量所占用的内存大小，就是固定的 4 个字节，也就是 4 个格子。

程序员无需也无法修改这个大小，那么我们就可以把 p 前面的数据类型去掉了。

shorta=1234;
p=&a;

3. 指针变量的类型

刚刚我们解决了指针变量本身所占用的内存大小，但是还有一个问题没有解决，就是指针变量里存放的内存地址处的变量的大小。

也就是说，上面的指针变量 p 里虽然存放了变量 a 的内存地址 6，但是指针变量 p 却没有任何信息，来说明内存地址 6 处的变量，它的大小是多少。

假如，我们认为内存地址 6 处的变量是个 char 类型，也就是只占用了一个字节，那么显然，会取出一个不符合预期的值。

当然，如果认为 6 处的变量是个 int 类型，占 4 个字节，虽然数值上可能没有问题，但从某种程度上讲也是不太符合预期的（假如 8 号和 9 号格子里有其他内容，那就更不符合预期了）。

所以，必须得完全按照变量本身的类型，也就是 short 类型来读取此内存地址处的值，才是正确的。

那我们应该如何表示这个信息呢？即如何表示，变量 p 是一个指针，且这个指针里面存放的内存地址处的变量的类型是 short。

很好办，直接说答案吧。

shorta=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 这个变量里存的内容当做内存地址来看，指向这个内存地址。

用图表示就是：

所以连起来一个完整的程序就是：

shorta=1234;
//指针的定义
short*p;
//指针的初始化，也即指针变量本身的值
p=&a;
//指针变量所指向的内存地址的值
*p=999;

执行过后，a 的值会变成 999，或者说 6 号格子与 7 号格子里的值会变成 999。

5. 指针的加减

如果对一个普通变量 +1，比如说：

inta=1;
intb=a+1;

那显然，b 的值应该是 2，毫无疑问。

但是如果对一个指针变量 +1，会怎么样呢？

inta=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;

我还可以把一个地址值，强行赋值给一个普通变量：

inta=1;
intb=&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 指令：

leaa,xxx

你如果写了个 ***p 那就是，相当于加了三次括号：

(((p)))

当然啦，以上都是方便理解的伪指令，具体落实到真正的汇编语言，你就会发现指针就是个工具人而已。

六、写在最后

至此，今天的内容就讲完了。

我们从最开始的内存格子出发，逐渐推导出类型系统和变量的作用，进而再引出本质上和普通变量没有任何区别的指针变量，最后再推导出指针变量相关的操作，带你看清了指针的本质。

你不要去记本文的知识点，重在整个推导的过程，要去理解指针想解决的问题是什么，它的合理性在哪，哪一部分信息是给程序员和编译器看的，哪一部分操作最终又是真正落实到 CPU 指令的，这些才是关键。

当然，我还是给你简单总结下知识点相关的部分，其实简单说，就这么几件事。

定义一个指针：

int*p;

赋值或初始化一个指针：

p=&a;

修改指针的内容：

*p=999;

指针的加减（其实到后面讲的数组才有价值）：

p=p+1;

完事，就这些！

审核编辑：刘清