*T与*Interface区别全解析

在Golang实战开发的过程中，我们经常会遇到一些这样那样的问题，然后要卡好半天，等问题解决了才发现原来一些细节知识点还是没有掌握好。今天golang学习网就整理分享《Go语言中\*T与\*Interface的区别详解》，聊聊，希望可以帮助到正在努力赚钱的你。

Go语言接口与类型实现

在Go语言中，接口定义了一组方法签名。任何类型，只要实现了接口中定义的所有方法，就被认为实现了该接口。这种实现是隐式的，无需显式声明。

考虑以下接口定义：

// eventloop.go
package eventloop

import "vector" // 假设 vector 是一个已定义的包

type Object interface {
    ActivateSlot(name string, parameters vector.Vector)
}

// Slot 结构体，其中包含一个 Object 接口类型的字段
type Slot struct {
    Name string
    Stuff Object // 注意：这里是 Object 接口类型，不是 *Object
}

以及一个实现了 Object 接口的具体类型 printer：

// main.go
package main

import (
    "fmt"
    "vector" // 假设 vector 是一个已定义的包
    "yourproject/eventloop" // 假设 eventloop 包路径
)

const slotname = "printer"

type printer struct {
    slot eventloop.Slot
}

// printer 类型实现了 eventloop.Object 接口的 ActivateSlot 方法
func (p *printer) ActivateSlot(name string, parameters vector.Vector) {
    fmt.Println("Slot called: ", name)
}

func (p *printer) Init() {
    // 尝试将 *printer 类型的 p 赋值给 eventloop.Slot 中的 Stuff 字段
    // 原始代码中的问题行：p.slot = eventloop.Slot{slotname, p}
    // 当 eventloop.Slot.Stuff 被定义为 *eventloop.Object 时，此处会报错
}

核心问题解析：*T 与 *Interface 的区别

当 eventloop.Slot 结构体的 Stuff 字段被定义为 *eventloop.Object 类型时，即指向接口的指针，尝试将 *printer 类型的 p 直接赋值给它会导致编译错误：cannot use p (type *printer) as type *eventloop.Object in field value。

这个错误的核心在于对Go语言中接口值的理解。

1. 接口值 (Interface Value)：一个接口值由两部分组成：一个类型（type）和一个具体值（value）。当一个具体类型（例如 *printer）被赋值给一个接口类型（例如 eventloop.Object）时，这个接口值会存储 *printer 的类型信息和 p 的内存地址。

   • p 的类型是 *printer。
   • *printer 类型实现了 eventloop.Object 接口（因为 (p *printer) ActivateSlot(...) 方法绑定在 *printer 上）。
   • 因此，p 本身就是一个 eventloop.Object。

2. *指向接口的指针 (`Interface)**：eventloop.Object意味着一个指向eventloop.Object接口值本身的指针。这与指向实现接口的具体类型（如printer`）的指针是完全不同的概念。

   • 你不能直接将一个 *printer 类型的指针隐式转换为一个 *eventloop.Object 类型的指针。它们在内存布局和语义上是不同的。
   • *printer 指向的是一个 printer 结构体的内存地址。
   • *eventloop.Object 指向的是一个接口值（包含类型和具体值）的内存地址。

正确的接口使用方式（常见场景）

在绝大多数情况下，当你希望一个结构体字段能够持有任何实现了特定接口的对象时，你应该将该字段定义为接口类型本身，而不是指向接口的指针。

推荐的 eventloop.Slot 定义：

// eventloop.go
package eventloop

import "vector"

type Object interface {
    ActivateSlot(name string, parameters vector.Vector)
}

// Slot 结构体的 Stuff 字段类型为 Object 接口
type Slot struct {
    Name string
    Stuff Object // 正确：直接使用接口类型
}

相应的 printer.Init() 方法：

// main.go
package main

import (
    "fmt"
    "vector"
    "yourproject/eventloop"
)

const slotname = "printer"

type printer struct {
    slot eventloop.Slot
}

func (p *printer) ActivateSlot(name string, parameters vector.Vector) {
    fmt.Println("Slot called: ", name)
}

func (p *printer) Init() {
    // 这里 p (类型为 *printer) 实现了 eventloop.Object 接口
    // 因此可以直接赋值给 eventloop.Slot.Stuff (类型为 eventloop.Object)
    p.slot = eventloop.Slot{Name: slotname, Stuff: p} // 正确赋值
}

func main() {
    pr := &printer{}
    pr.Init()
    // 验证接口调用
    if pr.slot.Stuff != nil {
        pr.slot.Stuff.ActivateSlot("test-slot", vector.Vector{})
    }
}

在这个例子中，p 是一个 *printer 类型的值。由于 *printer 实现了 Object 接口，p 可以直接赋值给 Slot 结构体中的 Stuff 字段，该字段的类型是 Object 接口。Go语言运行时会自动将 *printer 的类型和值封装到 Object 接口值中。

何时可能需要 *Interface（罕见情况）

虽然不常见，但在某些非常特定的场景下，你可能确实需要一个指向接口值的指针。例如，如果你需要通过指针修改接口变量本身（而不是它内部的具体值），或者需要将接口变量的地址传递给某个函数。

如果 eventloop.Slot.Stuff 必须是 *eventloop.Object 类型（这通常是一个需要重新审视的设计决策），那么你需要先创建一个 eventloop.Object 类型的变量，然后取其地址：

// eventloop.go (假设 Slot.Stuff 确实是 *Object)
package eventloop

import "vector"

type Object interface {
    ActivateSlot(name string, parameters vector.Vector)
}

type Slot struct {
    Name string
    Stuff *Object // 极少见：指向 Object 接口的指针
}

相应的 printer.Init() 方法：

// main.go
package main

import (
    "fmt"
    "vector"
    "yourproject/eventloop"
)

const slotname = "printer"

type printer struct {
    slot eventloop.Slot
}

func (p *printer) ActivateSlot(name string, parameters vector.Vector) {
    fmt.Println("Slot called: ", name)
}

func (p *printer) Init() {
    // 步骤1: 将 *printer 类型的 p 赋值给一个 Object 接口变量 o
    var o eventloop.Object = p
    // 此时 o 是一个接口值，其内部包含了 *printer 的类型和 p 的地址

    // 步骤2: 取接口变量 o 的地址，得到 *eventloop.Object 类型
    p.slot = eventloop.Slot{Name: slotname, Stuff: &o} // 赋值为指向接口的指针
}

func main() {
    pr := &printer{}
    pr.Init()
    // 验证接口调用 (需要解引用 Stuff 字段)
    if pr.slot.Stuff != nil {
        (*pr.slot.Stuff).ActivateSlot("test-slot", vector.Vector{})
    }
}

在这个例子中，var o eventloop.Object = p 这行代码将 *printer 类型的 p 包装成了一个 eventloop.Object 接口值 o。然后，&o 才是指向这个接口值 o 的指针，其类型为 *eventloop.Object，符合 Slot.Stuff 字段的类型要求。

注意事项： 这种 *Interface 的用法非常罕见，因为它意味着你正在操作接口值本身，而不是它所封装的具体值。在大多数面向接口的设计中，我们通常关心的是通过接口方法与底层具体值进行交互，而不是改变接口变量的引用或其内部结构。如果你的设计需要频繁使用 *Interface，这可能是一个信号，表明你的抽象层可能存在问题，或者有更简洁的实现方式。

总结

理解Go语言中接口和指针的交互至关重要：

1. 实现接口的类型可以是值类型或指针类型。 例如，printer 或 *printer 都可以实现 Object 接口。
2. 接口值已经能够封装具体类型（包括指针类型）。 当一个 *T 类型的值 t 实现了接口 I 时，可以直接将 t 赋值给 I 类型的变量或字段。
3. *`Interface是指向接口值的指针，与指向实现接口的具体类型的指针不同。** 尝试将T直接赋值给Interface` 通常是类型不匹配。
4. *优先使用接口类型 Interface 而非 `Interface作为字段或参数类型。** 这符合Go语言接口的惯用模式，使得代码更简洁、意图更清晰。只有在极少数需要直接操作接口变量内存地址的场景下，才考虑使用*Interface`。

通过区分 Interface 和 *Interface 的语义和用途，可以避免常见的类型错误，并编写出更符合Go语言习惯的高效、可维护的代码。

本篇关于《*T与*Interface区别全解析》的介绍就到此结束啦，但是学无止境，想要了解学习更多关于Golang的相关知识，请关注golang学习网公众号！