新资讯:你管这破玩意叫指针?

本系列分三篇,用破玩意的方式彻底理解好指针的本质:

你管这破玩意叫指针 -- 基础篇


(资料图片)

你管这破玩意叫指针 -- 进阶篇

你管这破玩意叫指针 -- 变态篇

话不多说,开始!

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

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

每个格子代表内存中的 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,amovb$38,bmovw$999,cmovb$18,agemovl$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就等于6intp=&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;

完事,就这些!

最后,给大家推荐两个网站。

一个是可以将 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

自己去上面的文档里找答案即可。

OK,本文到这里就终于要结束了,在接下来的进阶篇里,我会讲述二级指针、数组、函数指针、字符串、结构体、结构体数组与指针等内容。

虽然说是进阶篇,但我认为,指针的本质反而是进阶,而指针的进阶反而是基础。

因为假如理解了上述的一切,下面的所谓指针进阶玩法,都可以通过指针的本质以及语言设计的合理性,推导出来,再往后无非是需要花时间熟练使用和掌握罢了。

所以,理解好今天的内容,非常重要!

敬请期待:

你管这破玩意叫指针 -- 进阶篇

你管这破玩意叫指针 -- 变态篇

关键词: 指针变量 汇编语言 类型系统

来源:程序员客栈
编辑:GY653

免责声明:本网站内容主要来自原创、合作媒体供稿和第三方自媒体作者投稿,凡在本网站出现的信息,均仅供参考。本网站将尽力确保所提供信息的准确性及可靠性,但不保证有关资料的准确性及可靠性,读者在使用前请进一步核实,并对任何自主决定的行为负责。本网站对有关资料所引致的错误、不确或遗漏,概不负任何法律责任。任何单位或个人认为本网站中的网页或链接内容可能涉嫌侵犯其知识产权或存在不实内容时,应及时向本网站提出书面权利通知或不实情况说明,并提供身份证明、权属证明及详细侵权或不实情况证明。本网站在收到上述法律文件后,将会依法尽快联系相关文章源头核实,沟通删除相关内容或断开相关链接。

  • 相关推荐

相关词