1

尝试做 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 魔术吗？

4

1 回答 1

3

从这里：http ://research.swtch.com/interfaces

在此处输入图像描述

究竟interface(struct)返回什么？

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

如何interface(struct).func找到原始结构？

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

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

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

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

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

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的是一个具体类型实例，就像你的 struct 实例_j和_j1.

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

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

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

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

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

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

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

于 2013-10-16T06:52:09.413 回答