值接收者和指针接收者,方法集差在哪

难度 ★★★☆☆ · 前置:函数返回了 nil,调用方却判不出来 | 一句话结论:方法集只认接收者的种类,T 只装值接收者方法,*T 两种都装,所以指针接收者的方法永远传不到一个值上去,编译器宁可报错也不替你猜。

编译器给我的第一句话是这个:cannot use Robot{…} (value of struct type Robot) as Speaker value in variable declaration: Robot does not implement Speaker (method Speak has pointer receiver)(这条提示我在四个文件里都撞见过),到第二次才决定把它抄下来。起因是给一个用了很久的接口加了个新方法,这个方法要按名字把接收者里的字段改掉,所以我用了指针接收者。加完之后原先能编译的地方开始报错,报错散在好几个文件里,提示都是同一句话,说某个类型没有实现这个接口。我第一反应是怀疑自己漏写了方法,把那几个类型从头翻了一遍,方法都在,名字对,参数对,返回值也对,连拼写都一个字母一个字母对过。(那阵子我一直往接口那边找,压根没顾上看括号里写了什么。)真正的原因跟方法写没写没有关系,跟方法挂在谁身上有关系,同一份实现,挂值上还是挂指针上,决定的是这个类型肯不肯出现在接口的候选名单里,这件事在代码里不留痕迹,只有编译器知道(我是被一句报错按在地上才认下这条的)。

那些报错我一条条点开,行号分散在四个文件里,括号里那句话一字不差。我把它们抄到一张纸上对齐了看,才发现全落在赋值那一行,没有一条落在接口声明那个文件里。这个分布当时没让我起疑,我以为接口那边还有别的写法没试,又在那儿翻了半天。

翻到第二个文件的时候我才停下来,把括号里那句话从头到尾读了一遍。

方法集这个词听起来抽象(说白了就是一张清单),上面记着这个类型能响应哪些方法,编译器检查接口实现的时候只翻这张清单,不管你手写了多少个函数。它跟着类型走。

这条弯路是我自己绕进去的。

两条规则,方法集的全部内容

规则只有两条,短到可以背下来。类型 T 的方法集,只包含所有以值作为接收者的方法。类型 *T 的方法集,既包含以值作为接收者的方法,也包含以指针作为接收者的方法。也就是说,指针那边是全集,值那边是子集,值能做的事情指针都能做,指针能做的事情值不一定能做。这个不对称反过来推比正着背容易,值接收者的方法拿到的是接收者的副本,它改副本改得再狠也伤不到原对象,也不需要知道原对象住在哪,所以任何一份值都能调用它。指针接收者的方法要的是一颗地址,它顺着地址去改原对象,一个值想变成地址得有落脚的地方,编译器得取得到它的地址,才敢把这颗地址交出去。

T 与 *T 的方法集包含关系

把两句话并排放在一起看,能看出这不是两条平级的规则,是一条规则的两种写法。值那边少掉的那些方法,正好就是需要地址的那些方法,需要的地址越多,能从值这边过去的方法就越少。这也解释了为什么同一个类型,换个写法能满足的接口就变了,变的是清单的长度,实现一个字没动。

先看两个形状。方法集既然由接收者决定,值类型为什么就不行?

三种赋值能过,第四种过不去

先看例子,规则落到代码上才清楚。

我写了一个最小的例子来验证这件事,一共两个类型,外加一个接口。Dog 有两个方法,Speak 用值接收者,Bark 用指针接收者,这样它身上就同时有两种接收者,差异才看得见。Robot 只有一个方法 Speak,用的是指针接收者,它代表那种要改内部状态、只能在指针上挂方法的类型。接口 Speaker 只要求一个 Speak 方法,签名跟上面两处实现保持一致,我把接口收得很窄,就是为了让差异只落在接收者上,不落在方法名或者参数上。两个结构体都用一个字段存点状态,Dog 里放名字,Robot 里放编号,这样 Speak 的返回值能直接把是谁打印出来,看输出就知道这一次调用落在哪个类型上,不用再打断点。

三行都过,问题在第四行。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
type Speaker interface {
Speak() string
}

type Dog struct {
Name string
}

func (d Dog) Speak() string {
return "woof " + d.Name
}

func (d *Dog) Bark() {
fmt.Println(d.Name + " barks")
}

type Robot struct {
ID int
}

func (r *Robot) Speak() string {
return "beep " + strconv.Itoa(r.ID)
}

这个例子我改了两版,第二版才把 Bark 挪到指针上。

三种赋值都能编译,我把它们写在同一个文件里,跑出来的结果一行一行排着,看输出就知道每个接口变量里装的到底是哪个对象,也顺带验证了 Speak 读到的字段值没有串。

1
2
3
4
5
6
7
var s1 Speaker = Dog{"a"}
var s2 Speaker = &Dog{"b"}
var s3 Speaker = &Robot{7}

fmt.Println(s1.Speak())
fmt.Println(s2.Speak())
fmt.Println(s3.Speak())
1
2
3
woof a
woof b
beep 7

三行都过,第四行过不去,差别就落在这一张表上。

赋给 Speaker 的东西 方法集里有 Speak 吗 编译
Dog 的值 有,Speak 是值接收者 过
*Dog 的指针 有,指针那边是全集 过
*Robot 的指针 有,Robot 唯一的方法挂在指针上 过
Robot 的值 没有,得先有地址才调得动 当场停下

这里没有发生什么隐式转换,接口变量里存的东西跟赋过去的东西是同一种描述,指针还是指针,值还是值。三行写在同一个文件里,编译器从头到尾没有提出任何意见,输出跟我预期的一模一样,到这一步会觉得方法集规则没什么难处,两种类型都能往接口里塞,差别只在第四行。

报错原文里写着 pointer receiver

第四行我把 Robot 的值直接塞进接口,本意只是想少写一颗星号,编译当场停下,报错原文我原样抄在下面,一个字都没改。

1
var s4 Speaker = Robot{7}
1
2
# msdemo
.\main_bad.go:32:19: cannot use Robot{…} (value of struct type Robot) as Speaker value in variable declaration: Robot does not implement Speaker (method Speak has pointer receiver)

这句报错值得逐字读。最开始我只盯着 does not implement 这几个词看,以为是接口那边的声明写错了,回头把接口重读一遍才发现接口没有问题,答案在括号里,括号已经把原因递到眼前了。它没有说找不到方法,也没有说签名对不上,它说的是 method Speak has pointer receiver,方法 Speak 有一个指针接收者,这就是全部原因。Robot 的值的方法集是空的,因为它唯一的方法挂在指针上,值这份清单里什么都没有。编译器在这里没有替我取地址,也没有给一个隐式转换,它选择直接停下,一旦放行,接口里装的就是一个值的副本,而 Speak 要改的那个对象跟这份副本不是同一个,这个矛盾在运行期没法收拾,它宁可在这里停下来报一句 pointer receiver,也不替你猜一次。

自动取地址只在能取的时候成立

上一节的规则到这里像是要破了。

按上面的说法,值调不了指针方法,那平时写 d.Bark() 为什么又能编译。

原因是直接调用跟接口赋值走的是两条路。

直接调用的时候,编译器看到 d 是一个变量,它可以被取地址,于是自动把 d.Bark() 改写成 (&d).Bark(),再往下走。接口赋值的时候没有这条改写,编译器只查方法集,清单里没有就是没有,它不会因为那个值碰巧可以被取地址就额外帮一次忙。这条改写的门槛是接收者必须可寻址,变量恰好是最稳的一种。

切片元素也算稳,它背后有数组,位置能算出来。

结构体字段要看外层能不能寻址,外层是个变量它就跟着能,外层本身不可寻址它就一起落空。

这一层的边界我记住了。

1
2
3
4
var d Dog
d.Name = "x"
d.Bark()
(&d).Bark()

复合字面量就没有这个待遇,我原以为它也行,试完才发现不是。取地址那一层确实留了一个口子,&Dog{…} 这种写法是允许的,可那个口子只放开取地址,不放开方法调用里的改写,想绕过去只能自己把星号写出来,写成 (&Dog{…}).Bark(),那样能跑,我试出来打印的是 a barks。

不写星号,编译器照样拒绝,而且换了一句更短的提示。

1
2
.\main.go:15:11: cannot call pointer method Bark on Dog
.\main.go:18:21: cannot call pointer method Ptr on In

第一行是我拿 Dog 的复合字面量去调 Bark 时印出来的,第二行是 map 的元素,两句措辞一模一样,只换了类型名,句式都是 cannot call pointer method X on Y。这一对照说明问题不在指针方法身上,在接收者那一侧站没站住,变量站得住,复合字面量和 map 元素站不住。

(这里本来想顺手把逃逸分析写两句,跟我这个问题没有关系,写了一半删了。)

这两句提示我在编辑器里并排看了很久。

帮忙是有条件的,条件就是这个值拿得到稳定的地址。map 的元素是另一种反例,写 m 的 a 号元素去调 Ptr 编译不过,因为 map 的元素永远不可寻址,它在扩容和搬迁的时候会被挪走,编译器给不出一颗可靠的地址。可换成值接收者方法,同一行立刻能过,那次我打印出来是 7,值本身被复制了一份照样能算,可见卡住的只是指针接收者那一侧。

1
2
5 5
7

这两行来自同一个对照组里的另一个结构体,o 是一个变量,两支方法都能调,说明可寻址的时候两种接收者没有差别,差别只在不可寻址的位置上才露出来。

装进接口的那一份是复制品

接口变量里装的是什么,这一节说清。

接口这边还有一层,值得单独说。把一个值赋给接口变量,装进去的是这个值的一份副本,不是它本身。这一点跟方法集是两件事,可它们经常一起被问到,因为都跟值和指针有关。我实测过,先把 Dog 变量的名字改成 c,然后把它赋给接口变量,再把原来那个变量里的名字改成 d,调用接口上的 Speak,打印出来是 woof c,不是 woof d。副本在赋值那一刻就已经切开了,后面怎么改原件都影响不到它。这件事跟方法集规则没有直接关系,可它解释了另一半疑问,很多人把接口变量当成一个引用,以为塞进去之后两边还是同一个对象,改那边这边就跟着变,实际不是,接口变量装的是自己的那一份,跟原始变量从赋值那一行起就没有关系了。

副本这件事我栽过跟头。

1
2
3
4
d.Name = "c"
var s5 Speaker = d
d.Name = "d"
fmt.Println(s5.Speak())
1
woof c

这一份我复制出来单独跑过。为什么值接收者能读到改之前的名字?因为接口里装进去的就是那一刻的副本。

这也是为什么指针接收者的方法要的是一颗地址。值接收者拿到的是副本,改副本没有意义,想让方法真的改到原对象,唯一的办法是通过一颗指向它的指针,这也解释了值类型为什么天生做不了这件事。

嵌入把方法集一起搬过去

嵌入是另一条容易绕进去的路。嵌入一个类型,它的方法会被提升到外层,方法集的规则也跟着一起搬过去。嵌入 T,外层类型的方法集跟着 T 走,T 上挂着的那几个值接收者方法就成了外层的方法,T 的指针接收者方法不在里面。嵌入 *T,外层拿到的是完整的全集。两种写法在代码上只差一个星号,在接口能不能满足这件事上差别很大,而且外层的指针接收者和值接收者又会各自再分一次,层层叠上去之后,光看代码很难一眼说清哪一层漏了什么。

所以我看别人的嵌入结构时,会把两层的清单分开写下来对一遍,而不是只对外层那张扫一眼。

跨包那一层我没敢写成结论。

提升这个词容易让人以为方法被复制了一份,其实没有,只是查找路径多了一跳,调用的时候仍然会回到原来那个类型的实现上。跨包嵌入别包的类型,这一层我没验证完。同包里嵌 T 和嵌 *T 我都跑过,输出跟上面写的一致,再往外多套一层的时候,我只是在纸上推,没写代码跑,所以那一层我不敢写成结论。

一个方法改了接收者,整条链都要跟着改

统一接收者这件事我吃过亏。

Go 里有个流传很广的写法习惯,同一个类型的方法,要么全用值接收者,要么全用指针接收者,不要混着来。我一开始以为这是风格问题,后来发现是被方法集逼出来的。混着写的类型,值能满足的接口是残缺的,指针能满足的才是完整的那一份,别人拿到这个类型的时候,得先看你给它的是值还是指针,才知道它能塞进哪些接口。这种不确定性会在接口边界上放大(尤其是跨包传递的时候),一个值传过去能不能用,全看那边怎么声明,我在接手别人代码的时候最怕碰上这种要翻两层才能确认的接口。

所以我现在的做法是,只要这个类型有一个方法需要改内部状态,其余的也统一用指针接收者,省得以后在接口上再补一遍。我后来把手上那个类型的方法挨个过了一遍,挂指针的那几个和挂值的混在一起,改完统一到指针上,编译和测试都过,只是 diff 比我预想的大。

我现在的检查顺序

现在再遇到接口装不进去,我按固定的顺序往下看,中间一步都不跳:

  1. 先看报错括号里那句话,是不是 pointer receiver,是的话基本就定了,不用再往下找。
  2. 再看接口要的那几个方法,接收者分别写在值上还是指针上,把两份清单在心里对一遍,缺的那几个点通常在指针那一侧。

真正花时间的是定下来改哪一层,改接收者要动所有方法,改调用方要动所有传值的地方,两边都有代价,只能看哪边的调用点更少。

我上次是改调用方,因为那个接口不止一个实现,动接收者会牵连另外两个类型,而传值的地方只有三处。先看那两份清单。

方法集这两条规则我抄在便签上贴过一阵,抄的时候觉得太简单,用的时候才知道简单的规则最容易记一半。