go - interface(struct) 和 interface(struct).function 到底是什么

Question

尝试做 go koan，我陷入了理解接口(interface)(结构)语法的困境，究竟是什么 是吗？ 我想出了以下有趣的程序，这让我对界面转换的工作方式更加困惑:

package main

import "fmt"

type foo interface{  fn() }

type t struct { }
type q struct { }

func (_i t ) fn() { fmt.Print("t","\n") }
func (_i q ) fn() { fmt.Print("q","\n")}

func main() {
    _j :=  t{}
    _q :=  q{}

    // This is alright ..
    fmt.Print( _j.fn,"\n")           //0x4015e0     
    fmt.Print( _q.fn,"\n")       //0x401610     
    _j.fn()              //t           
    _q.fn()              //q           
    // both pointers same .. why ?
    fmt.Print( foo(_j).fn,"\n")  //0x401640     
    fmt.Print( foo(_q).fn,"\n")  //0x401640     
    // but correct fns called .. how ?
    foo(_j).fn()             //t           
    foo(_q).fn()             //q           

    // same thing again ...
    _fj := foo(_j).fn         
    _fq := foo(_q).fn         
    // both pointers same .. as above
    fmt.Print( _fj,"\n")         //0x401640    
    fmt.Print( _fq,"\n")         //0x401640    
    // correct fns called .. HOW !
    _fj()                //t                          
    _fq()                //q           
}

指针是我的机器，YMMV。 我的问题是.. interface(struct) 究竟返回什么？ 以及 interface(struct).func 是如何找到原始结构的…… 这里有一些 thunk/stub 魔法吗？

Answer 1

来自这里:http://research.swtch.com/interfaces

what exactly does interface(struct) return?

它创建一个新的接口(interface)值(就像您在图中顶部看到的那样)，包装一个具体的结构值。

how does interface(struct).func find the original struct?

请参阅图中的数据 字段。大多数情况下，这将是指向现有值的指针。不过，有时它会包含值本身(如果合适的话)。

在 itable 中，您会看到一个函数表(fun[0] 所在的位置)。

我假设在你的机器上 0x401640 是指向 fn 的相应指针的地址，它在 foo 的表中。虽然这最好由从事 GC 编译器套件的人员验证。

请注意，您发现的行为并未严格定义为如此。编译器构建者可以根据需要采用其他方法来实现 Go 接口(interface)，只要 the language semantics被保留下来。

---

编辑以回答评论中的问题:

package main

import "fmt"

type foo interface {
    fn()
}

type t struct{}
type q struct{}

func (_i t) fn() { fmt.Print("t", "\n") }
func (_i q) fn() { fmt.Print("q", "\n") }

func main() {
    _j := t{}
    _j1 := t{}

    fmt.Println(foo(_j) == foo(_j))  // true
    fmt.Println(foo(_j) == foo(_j1)) // true
}

在图表上您看到 3 个 block :

• 左侧标记为 Binary 的是具体类型实例，例如您的结构实例 _j 和 _j1。

• 顶部中间的是一个接口(interface)值，这个包裹(读作:指向)一个具体的值。

• 右下方的 block 是Binary底层的接口(interface)定义。这就是跳转表/调用转发表所在的位置 (itable)。

_j 和 _j1 是具体类型 t 的两个实例。所以在内存中的某处有两个左下角的 block 。

现在您决定将 _j 和 _j1 都包装在 foo 类型的接口(interface)值中；现在你在内存中的某处有 2 个顶部中心 block ，指向 _j 和 _j1。

为了让接口(interface)值记住它的底层类型是什么以及这些类型的方法在哪里，它在内存中保留右下角 block 的单个实例，两个接口(interface)值都指向该实例_j和_j1分别指向

在该 block 中，您有一个跳转表，用于将对接口(interface)值进行的方法调用转发到具体的底层类型的实现。这就是两者相同的原因。

值得一提的是，与 Java 和 C++(Python 不确定)不同，所有 Go 方法都是静态的，点调用符号只是语法糖。所以 _j 和 _j1 没有不同的 fn 方法，它是用另一个隐式第一个参数调用的完全相同的方法，该参数是接收者方法被调用。