本文篇幅较长，故分为上下两篇，此篇为下篇。本文基本上涵盖了 interface 的方方面面，有例子，有源码分析，有汇编分析，前前后后写了 20 多天。不足之处欢迎留言批评指正，同时有些东西没有涉及到（关于「反射」，作者后期将单独分享文章。）
6. 接口的构造过程是怎样的
我们已经看过了 iface 和 eface 的源码，知道 iface 最重要的是 itab 和 _type。
为了研究清楚接口是如何构造的，接下来我会拿起汇编的武器，还原背后的真相。
来看一个示例代码：
package main
import "fmt"
type Person interface { growUp()}
type Student struct { age int}
func (p Student) growUp() { p.age += 1 return}
func main() { var qcrao = Person(Student{age: 18})
fmt.Println(qcrao)}
复制代码
执行命令：
go tool compile -S ./src/main.go
复制代码
得到 main 函数的汇编代码如下：
0x0000 00000 (./src/main.go:30) TEXT "".main(SB), $80-00x0000 00000 (./src/main.go:30) MOVQ (TLS), CX0x0009 00009 (./src/main.go:30) CMPQ SP, 16(CX)0x000d 00013 (./src/main.go:30) JLS 1570x0013 00019 (./src/main.go:30) SUBQ $80, SP0x0017 00023 (./src/main.go:30) MOVQ BP, 72(SP)0x001c 00028 (./src/main.go:30) LEAQ 72(SP), BP0x0021 00033 (./src/main.go:30) FUNCDATA$0, gclocals·69c1753bd5f81501d95132d08af04464(SB)0x0021 00033 (./src/main.go:30) FUNCDATA$1, gclocals·e226d4ae4a7cad8835311c6a4683c14f(SB)0x0021 00033 (./src/main.go:31) MOVQ $18, ""..autotmp_1+48(SP)0x002a 00042 (./src/main.go:31) LEAQ go.itab."".Student,"".Person(SB), AX0x0031 00049 (./src/main.go:31) MOVQ AX, (SP)0x0035 00053 (./src/main.go:31) LEAQ ""..autotmp_1+48(SP), AX0x003a 00058 (./src/main.go:31) MOVQ AX, 8(SP)0x003f 00063 (./src/main.go:31) PCDATA $0, $00x003f 00063 (./src/main.go:31) CALL runtime.convT2I64(SB)0x0044 00068 (./src/main.go:31) MOVQ 24(SP), AX0x0049 00073 (./src/main.go:31) MOVQ 16(SP), CX0x004e 00078 (./src/main.go:33) TESTQ CX, CX0x0051 00081 (./src/main.go:33) JEQ 870x0053 00083 (./src/main.go:33) MOVQ 8(CX), CX0x0057 00087 (./src/main.go:33) MOVQ $0, ""..autotmp_2+56(SP)0x0060 00096 (./src/main.go:33) MOVQ $0, ""..autotmp_2+64(SP)0x0069 00105 (./src/main.go:33) MOVQ CX, ""..autotmp_2+56(SP)0x006e 00110 (./src/main.go:33) MOVQ AX, ""..autotmp_2+64(SP)0x0073 00115 (./src/main.go:33) LEAQ ""..autotmp_2+56(SP), AX0x0078 00120 (./src/main.go:33) MOVQ AX, (SP)0x007c 00124 (./src/main.go:33) MOVQ $1, 8(SP)0x0085 00133 (./src/main.go:33) MOVQ $1, 16(SP)0x008e 00142 (./src/main.go:33) PCDATA $0, $10x008e 00142 (./src/main.go:33) CALL fmt.Println(SB)0x0093 00147 (./src/main.go:34) MOVQ 72(SP), BP0x0098 00152 (./src/main.go:34) ADDQ $80, SP0x009c 00156 (./src/main.go:34) RET0x009d 00157 (./src/main.go:34) NOP0x009d 00157 (./src/main.go:30) PCDATA $0, $-10x009d 00157 (./src/main.go:30) CALL runtime.morestack_noctxt(SB)0x00a2 00162 (./src/main.go:30) JMP 0
复制代码
我们从第 10 行开始看，如果不理解前面几行汇编代码的话，可以回去看看公众号前面两篇文章，这里我就省略了。
| 汇编行数 | 操作 |
|---|
| 10-14 | 构造调用 runtime.convT2I64(SB) 的参数 |
我们来看下这个函数的参数形式：
func convT2I64(tab *itab, elem unsafe.Pointer) (i iface) { // ……}
复制代码
convT2I64 会构造出一个 inteface，也就是我们的 Person 接口。
第一个参数的位置是 (SP)，这里被赋上了 go.itab."".Student,"".Person(SB) 的地址。
我们从生成的汇编找到：
go.itab."".Student,"".Person SNOPTRDATA dupok size=40 0x0000 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 0x0010 00 00 00 00 00 00 00 00 da 9f 20 d4 rel 0+8 t=1 type."".Person+0 rel 8+8 t=1 type."".Student+0
复制代码
size=40 大小为 40 字节，回顾一下：
type itab struct { inter *interfacetype // 8字节 _type *_type // 8字节 link *itab // 8字节 hash uint32 // 4字节 bad bool // 1字节 inhash bool // 1字节 unused [2]byte // 2字节 fun [1]uintptr // variable sized // 8字节}
复制代码
把每个字段的大小相加，itab 结构体的大小就是 40 字节。上面那一串数字实际上是 itab 序列化后的内容，注意到大部分数字是 0，从 24 字节开始的 4 个字节 da 9f 20 d4 实际上是 itab 的 hash 值，这在判断两个类型是否相同的时候会用到。
下面两行是链接指令，简单说就是将所有源文件综合起来，给每个符号赋予一个全局的位置值。这里的意思也比较明确：前 8 个字节最终存储的是 type."".Person 的地址，对应 itab 里的 inter 字段，表示接口类型；8-16 字节最终存储的是 type."".Student 的地址，对应 itab 里 _type 字段，表示具体类型。
第二个参数就比较简单了，它就是数字 18 的地址，这也是初始化 Student 结构体的时候会用到。
| 汇编行数 | 操作 |
|---|
| 15 | 调用 runtime.convT2I64(SB) |
具体看下代码：
func convT2I64(tab *itab, elem unsafe.Pointer) (i iface) { t := tab._type
//...
var x unsafe.Pointer if *(*uint64)(elem) == 0 { x = unsafe.Pointer(&zeroVal[0]) } else { x = mallocgc(8, t, false) *(*uint64)(x) = *(*uint64)(elem) } i.tab = tab i.data = x return}
复制代码
这块代码比较简单，把 tab 赋给了 iface 的 tab 字段；data 部分则是在堆上申请了一块内存，然后将 elem 指向的 18 拷贝过去。这样 iface 就组装好了。
| 汇编行数 | 操作 |
|---|
| 17 | 把 i.tab 赋给 CX |
| 18 | 把 i.data 赋给 AX |
| 19-21 | 检测 i.tab 是否是 nil，如果不是的话，把 CX 移动 8 个字节，也就是把 itab 的 _type 字段赋给了 CX，这也是接口的实体类型，最终要作为 fmt.Println 函数的参数 |
后面，就是调用 fmt.Println 函数及之前的参数准备工作了，不再赘述。
这样，我们就把一个 interface 的构造过程说完了。
【引申 1】 如何打印出接口类型的 Hash 值？
这里参考曹大神翻译的一篇文章，参考资料里会写上。具体做法如下：
type iface struct { tab *itab data unsafe.Pointer}type itab struct { inter uintptr _type uintptr link uintptr hash uint32 _ [4]byte fun [1]uintptr}
func main() { var qcrao = Person(Student{age: 18})
iface := (*iface)(unsafe.Pointer(&qcrao)) fmt.Printf("iface.tab.hash = %#x\n", iface.tab.hash)}
复制代码
一个山寨版的 iface 和 itab，说它山寨是因为 itab 里的一些关键数据结构都不具体展开了，比如 _type，对比一下正宗的定义就可以发现，但是山寨版依然能工作，因为 _type 就是一个指针而已嘛。
在 main 函数里，先构造出一个接口对象 qcrao，然后强制类型转换，最后读取出 hash 值，非常妙！你也可以自己动手试一下。
运行结果：
iface.tab.hash = 0xd4209fda
复制代码
值得一提的是，构造接口 qcrao 的时候，即使我把 age 写成其他值，得到的 hash 值依然不变的，这应该是可以预料的，hash 值只和他的字段、方法相关。
6. 类型转换和断言的区别
我们知道，Go 语言中不允许隐式类型转换，也就是说 = 两边，不允许出现类型不相同的变量。
类型转换、类型断言本质都是把一个类型转换成另外一个类型。不同之处在于，类型断言是对接口变量进行的操作。
类型转换
对于类型转换而言，转换前后的两个类型要相互兼容才行。类型转换的语法为：
package main
import "fmt"
func main() { var i int = 9
var f float64 f = float64(i) fmt.Printf("%T, %v\n", f, f)
f = 10.8 a := int(f) fmt.Printf("%T, %v\n", a, a)
// s := []int(i)
复制代码
上面的代码里，我定义了一个 int 型和 float64 型的变量，尝试在它们之前相互转换，结果是成功的：int 型和 float64 是相互兼容的。
如果我把最后一行代码的注释去掉，编译器会报告类型不兼容的错误：
cannot convert i (type int) to type []int
复制代码
断言
前面说过，因为空接口 interface{} 没有定义任何函数，因此 Go 中所有类型都实现了空接口。当一个函数的形参是 interface{}，那么在函数中，需要对形参进行断言，从而得到它的真实类型。
断言的语法为：
// 安全类型断言
<目标类型的值>，<布尔参数> := <表达式>.( 目标类型 )
//非安全类型断言
<目标类型的值> := <表达式>.( 目标类型 )
复制代码
类型转换和类型断言有些相似，不同之处，在于类型断言是对接口进行的操作。
还是来看一个简短的例子：
package main
import "fmt"
type Student struct { Name string Age int}
func main() { var i interface{} = new(Student) s := i.(Student)
fmt.Println(s)}
复制代码
运行一下：
panic: interface conversion: interface {} is *main.Student, not main.Student
复制代码
直接 panic 了，这是因为 i 是 *Student 类型，并非 Student 类型，断言失败。这里直接发生了 panic，线上代码可能并不适合这样做，可以采用“安全断言”的语法：
func main() { var i interface{} = new(Student) s, ok := i.(Student) if ok { fmt.Println(s) }}
复制代码
这样，即使断言失败也不会 panic。
断言其实还有另一种形式，就是用在利用 switch 语句判断接口的类型。每一个 case 会被顺序地考虑。当命中一个 case 时，就会执行 case 中的语句，因此 case 语句的顺序是很重要的，因为很有可能会有多个 case 匹配的情况。
代码示例如下：
func main() { //var i interface{} = new(Student) //var i interface{} = (*Student)(nil) var i interface{}
fmt.Printf("%p %v\n", &i, i)
judge(i)}
func judge(v interface{}) { fmt.Printf("%p %v\n", &v, v)
switch v := v.(type) { case nil: fmt.Printf("%p %v\n", &v, v) fmt.Printf("nil type[%T] %v\n", v, v)
case Student: fmt.Printf("%p %v\n", &v, v) fmt.Printf("Student type[%T] %v\n", v, v)
case *Student: fmt.Printf("%p %v\n", &v, v) fmt.Printf("*Student type[%T] %v\n", v, v)
default: fmt.Printf("%p %v\n", &v, v) fmt.Printf("unknow\n") }}
type Student struct { Name string Age int}
复制代码
main 函数里有三行不同的声明，每次运行一行，注释另外两行，得到三组运行结果：
// --- var i interface{} = new(Student)0xc4200701b0 [Name: ], [Age: 0]0xc4200701d0 [Name: ], [Age: 0]0xc420080020 [Name: ], [Age: 0]*Student type[*main.Student] [Name: ], [Age: 0]
// --- var i interface{} = (*Student)(nil)0xc42000e1d0 <nil>0xc42000e1f0 <nil>0xc42000c030 <nil>*Student type[*main.Student] <nil>
// --- var i interface{}0xc42000e1d0 <nil>0xc42000e1e0 <nil>0xc42000e1f0 <nil>nil type[<nil>] <nil>
复制代码
对于第一行语句：
var i interface{} = new(Student)
复制代码
i 是一个 *Student 类型，匹配上第三个 case，从打印的三个地址来看，这三处的变量实际上都是不一样的。在 main 函数里有一个局部变量 i；调用函数时，实际上是复制了一份参数，因此函数里又有一个变量 v，它是 i 的拷贝；断言之后，又生成了一份新的拷贝。所以最终打印的三个变量的地址都不一样。
对于第二行语句：
var i interface{} = (*Student)(nil)
复制代码
这里想说明的其实是 i 在这里动态类型是 (*Student), 数据为 nil，它的类型并不是 nil，它与 nil 作比较的时候，得到的结果也是 false。
最后一行语句：
这回 i 才是 nil 类型。
【引申 1】 fmt.Println 函数的参数是 interface。
对于内置类型，函数内部会用穷举法，得出它的真实类型，然后转换为字符串打印。而对于自定义类型，首先确定该类型是否实现了 String() 方法，如果实现了，则直接打印输出 String() 方法的结果；否则，会通过反射来遍历对象的成员进行打印。
再来看一个简短的例子，比较简单，不要紧张：
package main
import "fmt"
type Student struct { Name string Age int}
func main() { var s = Student{ Name: "qcrao", Age: 18, }
fmt.Println(s)}
复制代码
因为 Student 结构体没有实现 String() 方法，所以 fmt.Println 会利用反射挨个打印成员变量：
增加一个 String() 方法的实现：
func (s Student) String() string { return fmt.Sprintf("[Name: %s], [Age: %d]", s.Name, s.Age)}
复制代码
打印结果：
按照我们自定义的方法来打印了。
【引申 2】 针对上面的例子，如果改一下：
func (s *Student) String() string { return fmt.Sprintf("[Name: %s], [Age: %d]", s.Name, s.Age)}
复制代码
注意看两个函数的接受者类型不同，现在 Student 结构体只有一个接受者类型为 指针类型 的 String() 函数，打印结果：
为什么？
类型 T 只有接受者是 T 的方法；而类型 *T 拥有接受者是 T 和 *T 的方法。语法上 T 能直接调 *T 的方法仅仅是 Go 的语法糖。
所以， Student 结构体定义了接受者类型是值类型的 String() 方法时，通过
fmt.Println(s)fmt.Println(&s)
复制代码
均可以按照自定义的格式来打印。
如果 Student 结构体定义了接受者类型是指针类型的 String() 方法时，只有通过
才能按照自定义的格式打印。
8. 接口转换的原理
通过前面提到的 iface 的源码可以看到，实际上它包含接口的类型 interfacetype 和实体类型的类型 _type，这两者都是 iface 的字段 itab 的成员。也就是说生成一个 itab 同时需要接口的类型和实体的类型。
<interface 类型， 实体类型> ->itable
复制代码
当判定一种类型是否满足某个接口时，Go 使用类型的方法集和接口所需要的方法集进行匹配，如果类型的方法集完全包含接口的方法集，则可认为该类型实现了该接口。
例如某类型有 m 个方法，某接口有 n 个方法，则很容易知道这种判定的时间复杂度为 O(mn)，Go 会对方法集的函数按照函数名的字典序进行排序，所以实际的时间复杂度为 O(m+n)。
这里我们来探索将一个接口转换给另外一个接口背后的原理，当然，能转换的原因必然是类型兼容。
直接来看一个例子：
package main
import "fmt"
type coder interface { code() run()}
type runner interface { run()}
type Gopher struct { language string}
func (g Gopher) code() { return}
func (g Gopher) run() { return}
func main() { var c coder = Gopher{}
var r runner r = c fmt.Println(c, r)}
复制代码
简单解释下上述代码：定义了两个 interface: coder 和 runner。定义了一个实体类型 Gopher，类型 Gopher 实现了两个方法，分别是 run() 和 code()。main 函数里定义了一个接口变量 c，绑定了一个 Gopher 对象，之后将 c 赋值给另外一个接口变量 r 。赋值成功的原因是 c 中包含 run() 方法。这样，两个接口变量完成了转换。
执行命令：
go tool compile -S ./src/main.go
复制代码
得到 main 函数的汇编命令，可以看到：r = c 这一行语句实际上是调用了 runtime.convI2I(SB)，也就是 convI2I 函数，从函数名来看，就是将一个 interface 转换成另外一个 interface，看下它的源代码：
func convI2I(inter *interfacetype, i iface) (r iface) { tab := i.tab if tab == nil { return } if tab.inter == inter { r.tab = tab r.data = i.data return } r.tab = getitab(inter, tab._type, false) r.data = i.data return}
复制代码
代码比较简单，函数参数 inter 表示接口类型，i 表示绑定了实体类型的接口，r 则表示接口转换了之后的新的 iface。通过前面的分析，我们又知道， iface 是由 tab 和 data 两个字段组成。所以，实际上 convI2I 函数真正要做的事，找到新 interface 的 tab 和 data，就大功告成了。
我们还知道，tab 是由接口类型 interfacetype 和 实体类型 _type。所以最关键的语句是 r.tab = getitab(inter, tab._type, false)。
因此，重点来看下 getitab 函数的源码，只看关键的地方：
func getitab(inter *interfacetype, typ *_type, canfail bool) *itab { // ……
// 根据 inter, typ 计算出 hash 值 h := itabhash(inter, typ)
// look twice - once without lock, once with. // common case will be no lock contention. var m *itab var locked int for locked = 0; locked < 2; locked++ { if locked != 0 { lock(&ifaceLock) }
// 遍历哈希表的一个 slot for m = (*itab)(atomic.Loadp(unsafe.Pointer(&hash[h]))); m != nil; m = m.link {
// 如果在 hash 表中已经找到了 itab（inter 和 typ 指针都相同） if m.inter == inter && m._type == typ { // ……
if locked != 0 { unlock(&ifaceLock) } return m } } }
// 在 hash 表中没有找到 itab，那么新生成一个 itab m = (*itab)(persistentalloc(unsafe.Sizeof(itab{})+uintptr(len(inter.mhdr)-1)*sys.PtrSize, 0, &memstats.other_sys)) m.inter = inter m._type = typ
// 添加到全局的 hash 表中 additab(m, true, canfail) unlock(&ifaceLock) if m.bad { return nil } return m}
复制代码
简单总结一下：getitab 函数会根据 interfacetype 和 _type 去全局的 itab 哈希表中查找，如果能找到，则直接返回；否则，会根据给定的 interfacetype 和 _type 新生成一个 itab，并插入到 itab 哈希表，这样下一次就可以直接拿到 itab。
这里查找了两次，并且第二次上锁了，这是因为如果第一次没找到，在第二次仍然没有找到相应的 itab 的情况下，需要新生成一个，并且写入哈希表，因此需要加锁。这样，其他协程在查找相同的 itab 并且也没有找到时，第二次查找时，会被挂住，之后，就会查到第一个协程写入哈希表的 itab。
再来看一下 additab 函数的代码：
// 检查 _type 是否符合 interface_type 并且创建对应的 itab 结构体 将其放到 hash 表中func additab(m *itab, locked, canfail bool) { inter := m.inter typ := m._type x := typ.uncommon()
// both inter and typ have method sorted by name, // and interface names are unique, // so can iterate over both in lock step; // the loop is O(ni+nt) not O(ni*nt). // // inter 和 typ 的方法都按方法名称进行了排序 // 并且方法名都是唯一的。所以循环的次数是固定的 // 只用循环 O(ni+nt)，而非 O(ni*nt) ni := len(inter.mhdr) nt := int(x.mcount) xmhdr := (*[1 << 16]method)(add(unsafe.Pointer(x), uintptr(x.moff)))[:nt:nt] j := 0 for k := 0; k < ni; k++ { i := &inter.mhdr[k] itype := inter.typ.typeOff(i.ityp) name := inter.typ.nameOff(i.name) iname := name.name() ipkg := name.pkgPath() if ipkg == "" { ipkg = inter.pkgpath.name() } for ; j < nt; j++ { t := &xmhdr[j] tname := typ.nameOff(t.name) // 检查方法名字是否一致 if typ.typeOff(t.mtyp) == itype && tname.name() == iname { pkgPath := tname.pkgPath() if pkgPath == "" { pkgPath = typ.nameOff(x.pkgpath).name() } if tname.isExported() || pkgPath == ipkg { if m != nil { // 获取函数地址，并加入到itab.fun数组中 ifn := typ.textOff(t.ifn) *(*unsafe.Pointer)(add(unsafe.Pointer(&m.fun[0]), uintptr(k)*sys.PtrSize)) = ifn } goto nextimethod } } } // ……
m.bad = true break nextimethod: } if !locked { throw("invalid itab locking") }
// 计算 hash 值 h := itabhash(inter, typ) // 加到Hash Slot链表中 m.link = hash[h] m.inhash = true atomicstorep(unsafe.Pointer(&hash[h]), unsafe.Pointer(m))}
复制代码
additab 会检查 itab 持有的 interfacetype 和 _type 是否符合，就是看 _type 是否完全实现了 interfacetype 的方法，也就是看两者的方法列表重叠的部分就是 interfacetype 所持有的方法列表。注意到其中有一个双层循环，乍一看，循环次数是 ni * nt，但由于两者的函数列表都按照函数名称进行了排序，因此最终只执行了 ni + nt 次，代码里通过一个小技巧来实现：第二层循环并没有从 0 开始计数，而是从上一次遍历到的位置开始。
求 hash 值的函数比较简单：
func itabhash(inter *interfacetype, typ *_type) uint32 { h := inter.typ.hash h += 17 * typ.hash return h % hashSize}
复制代码
hashSize 的值是 1009。
更一般的，当把实体类型赋值给接口的时候，会调用 conv 系列函数，例如空接口调用 convT2E 系列、非空接口调用 convT2I 系列。这些函数比较相似：
1.具体类型转空接口时，_type 字段直接复制源类型的 _type；调用 mallocgc 获得一块新内存，把值复制进去，data 再指向这块新内存。
2.具体类型转非空接口时，入参 tab 是编译器在编译阶段预先生成好的，新接口 tab 字段直接指向入参 tab 指向的 itab；调用 mallocgc 获得一块新内存，把值复制进去，data 再指向这块新内存。
3.而对于接口转接口，itab 调用 getitab 函数获取。只用生成一次，之后直接从 hash 表中获取。
9. 如何用 interface 实现多态
Go 语言并没有设计诸如虚函数、纯虚函数、继承、多重继承等概念，但它通过接口却非常优雅地支持了面向对象的特性。
多态是一种运行期的行为，它有以下几个特点：
1.一种类型具有多种类型的能力
2.允许不同的对象对同一消息做出灵活的反应
3.以一种通用的方式对待个使用的对象
4.非动态语言必须通过继承和接口的方式来实现
看一个实现了多态的代码例子：
package main
import "fmt"
func main() { qcrao := Student{age: 18} whatJob(&qcrao)
growUp(&qcrao) fmt.Println(qcrao)
stefno := Programmer{age: 100} whatJob(stefno)
growUp(stefno) fmt.Println(stefno)}
func whatJob(p Person) { p.job()}
func growUp(p Person) { p.growUp()}
type Person interface { job() growUp()}
type Student struct { age int}
func (p Student) job() { fmt.Println("I am a student.") return}
func (p *Student) growUp() { p.age += 1 return}
type Programmer struct { age int}
func (p Programmer) job() { fmt.Println("I am a programmer.") return}
func (p Programmer) growUp() { // 程序员老得太快 ^_^ p.age += 10 return}
复制代码
代码里先定义了 1 个 Person 接口，包含两个函数：
然后，又定义了 2 个结构体，Student 和 Programmer，同时，类型 *Student、Programmer 实现了 Person 接口定义的两个函数。注意，*Student 类型实现了接口， Student 类型却没有。
之后，我又定义了函数参数是 Person 接口的两个函数：
func whatJob(p Person)func growUp(p Person)
复制代码
main 函数里先生成 Student 和 Programmer 的对象，再将它们分别传入到函数 whatJob 和 growUp。函数中，直接调用接口函数，实际执行的时候是看最终传入的实体类型是什么，调用的是实体类型实现的函数。于是，不同对象针对同一消息就有多种表现，多态就实现了。
更深入一点来说的话，在函数 whatJob() 或者 growUp() 内部，接口 person 绑定了实体类型 *Student 或者 Programmer。根据前面分析的 iface 源码，这里会直接调用 fun 里保存的函数，类似于：s.tab->fun[0]，而因为 fun 数组里保存的是实体类型实现的函数，所以当函数传入不同的实体类型时，调用的实际上是不同的函数实现，从而实现多态。
运行一下代码：
I am a student.{19}I am a programmer.{100}
复制代码
10. Go 接口与 C++ 接口有何异同
接口定义了一种规范，描述了类的行为和功能，而不做具体实现。
C++ 的接口是使用抽象类来实现的，如果类中至少有一个函数被声明为纯虚函数，则这个类就是抽象类。纯虚函数是通过在声明中使用 “= 0” 来指定的。例如：
class Shape{ public: // 纯虚函数 virtual double getArea() = 0; private: string name; // 名称};
复制代码
设计抽象类的目的，是为了给其他类提供一个可以继承的适当的基类。抽象类不能被用于实例化对象，它只能作为接口使用。
派生类需要明确地声明它继承自基类，并且需要实现基类中所有的纯虚函数。
C++ 定义接口的方式称为“侵入式”，而 Go 采用的是 “非侵入式”，不需要显式声明，只需要实现接口定义的函数，编译器自动会识别。
C++ 和 Go 在定义接口方式上的不同，也导致了底层实现上的不同。C++ 通过虚函数表来实现基类调用派生类的函数；而 Go 通过 itab 中的 fun 字段来实现接口变量调用实体类型的函数。C++ 中的虚函数表是在编译期生成的；而 Go 的 itab 中的 fun 字段是在运行期间动态生成的。原因在于，Go 中实体类型可能会无意中实现 N 多接口，很多接口并不是本来需要的，所以不能为类型实现的所有接口都生成一个 itab， 这也是“非侵入式”带来的影响；这在 C++ 中是不存在的，因为派生需要显示声明它继承自哪个基类。
本文转载自公众号滴滴技术（ID：didi_tech）。
原文链接：
https://mp.weixin.qq.com/s/LVPiE_NJchIhobuDfzFDjA
评论