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

Question

尝试做 go koan，我陷入了对接口（结构）语法的理解，究竟是什么 有吗？ 我想出了以下有趣的程序，这进一步让我对接口转换的工作方式感到困惑：

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

interface(struct) 究竟返回了什么？

它创建一个新的接口值（就像你在图中看到的那样），包装一个具体的结构值。

interface(struct).func如何找到原来的结构体？

查看图形中的数据字段。大多数情况下，这将是一个指向现有值的指针。不过，有时它会包含值本身（如果合适的话）。

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

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

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

---

编辑以回答 cmets 中的问题：

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 个块：

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

• 顶部中心的那个是一个接口值，这个包裹（读作：指向）一个具体的值。

• 右下侧的块是Binary底层证券的接口定义。这是跳转表/呼叫转接表所在的位置 (itable)。

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

现在您决定将_j 和_j1 包装在foo 类型的接口值中；现在您在内存中的某个位置有 2 个顶部中心块，指向 _j 和 _j1。

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

在该块中，您有一个跳转表，用于将接口值上的方法调用转发到具体的底层类型的实现。这就是为什么两者是一样的。

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