无法使用 *T 类型的变量作为参数中的类型

对于一个Golang开发者来说，牢固扎实的基础是十分重要的，golang学习网就来带大家一点点的掌握基础知识点。今天本篇文章带大家了解《无法使用 *T 类型的变量作为参数中的类型》，主要介绍了，希望对大家的知识积累有所帮助，快点收藏起来吧，否则需要时就找不到了！

我正在学习 go 1.18 泛型，我试图理解为什么我在这里遇到麻烦。长话短说，我正在尝试 unmarshal protobuf，我希望 blah 中的参数类型“正常工作”。我已尽我所能简化了问题，并且此特定代码正在重现我所看到的相同错误消息：

./prog.go:31:5: cannot use t (variable of type *t) as type stringer in argument to do:
    *t does not implement stringer (type *t is pointer to type parameter, not type parameter)

package main

import "fmt"

type stringer interface {
    a() string
}

type foo struct{}

func (f *foo) a() string {
    return "foo"
}

type bar struct{}

func (b *bar) a() string {
    return "bar"
}

type FooBar interface {
    foo | bar
}

func do(s stringer) {
    fmt.Println(s.a())
}

func blah[T FooBar]() {
    t := &T{}
    do(t)
}

func main() {
    blah[foo]()
}

我意识到我可以通过不使用泛型来完全简化这个示例（即，将实例传递给 blah(s stringer) {do(s)}。但是，我确实想了解为什么会发生错误。

我需要对此代码进行哪些更改，以便我可以创建 t 的实例并将该指针传递给需要特定方法签名的函数？

正确答案

在您的代码中，约束 foobar 和 stringer 之间没有关系。此外，这些方法是在指针接收器上实现的。

对你设计的程序的一个快速而肮脏的修复就是简单地断言 *t 确实是一个 stringer：

func blah[t foobar]() {
    t := new(t)
    do(any(t).(stringer))
}

演示：https://go.dev/play/p/zmVX56T9LZx

但这放弃了类型安全，并且可能在运行时出现恐慌。为了保持编译时类型安全，另一种在一定程度上保留程序语义的解决方案是：

type foobar[t foo | bar] interface {
    *t
    stringer
}

func blah[t foo | bar, u foobar[t]]() {
    var t t
    do(u(&t))
}

那么这是怎么回事？

首先，类型参数与其约束之间的关系不是恒等的：t 不是 foobar。您不能像使用 foobar 一样使用 t，因此 *t 绝对不等于 *foo 或 *bar。

因此，当您调用 do(t) 时，您正在尝试将类型 *t 传递到需要 stringer 的对象中，但是 t（无论是否为指针）本质上并不具有其类型集中的 a() string 方法。

第1步：将方法a() string添加到foobar接口中（通过嵌入stringer）：

type foobar interface {
    foo | bar
    stringer
}

但这还不够，因为现在您的类型都没有真正实现它。两者都在指针接收器上声明了方法。

第2步：将联合中的类型更改为指针：

type foobar interface {
    *foo | *bar
    stringer
}

此限制现在有效，但您还有另一个问题。当约束没有核心类型时，您无法声明复合文字。所以 t := t{} 也是无效的。我们将其更改为：

func blah[t foobar]() {
    var t t // already pointer type
    do(t)
}

现在可以编译了，但 t 实际上是指针类型的零值，所以它是 nil。您的程序不会崩溃，因为这些方法只返回一些字符串文字。

如果您还需要初始化指针引用的内存，则在 blah 内部您需要了解基本类型。

第 3 步：添加 t foo | bar 作为一种类型参数，并将签名更改为：

func blah[t foo | bar, u foobar]() {
    var t t
    do(u(&t))
}

完成了吗？还没有。转换 u(&t) 仍然无效，因为 u 和 t 的类型集不匹配。您现在需要在 t 中参数化 foobar。

第 4 步：基本上，您将 foobar 的联合提取到类型参数中，以便在编译时其类型集将仅包含以下两种类型之一：

type foobar[t foo | bar] interface {
    *t
    stringer
}

现在可以使用 t foo | 实例化约束。 bar，保留类型安全、指针语义并将 t 初始化为非零。

func (f *foo) a() string {
    fmt.println("foo nil:", f == nil)
    return "foo"
}

func main() {
    blah[foo]()
}

打印：

foo nil: false
foo

演示：https://go.dev/play/p/src2sDSwe5H

如果您可以使用指针类型实例化 blah，或者更好地向其传递参数，则可以删除所有中间技巧：

type foobar interface {
    *foo | *bar
    stringer
}

func blah[t foobar](t t) {
    do(t)
}

func main() {
    blah(&foo{})
}

除了上面的答案之外，还有两种方法可以解决这个问题。在这两种情况下，foobar 类型都必须是：

type foobar interface {
    *foo | *bar
    stringer
}

第一个：

创建这个通用的新函数。它的作用与内置 new func 相同，但可以轻松地作为函数参数传递。

func new[t any]() *t {
    return new(t)
}

修改 blah 函数以接受并使用 _new 函数。 该函数负责创建一个 foobar 实例。

func blah[t foobar](_new func() t) {
    t := _new()
    do(t)
}

修改主函数：

func main() {
    blah(new[foo])
}

基本上，我们将内置的新函数注入到通用函数中。

Full solution on a go playground

第二个：

我们可以使用反射来实例化隐藏在接口后面的指针类型的变量：

func gnew[t any]() t {
    var t t
    var _t = reflect.typeof(t)
    if _t.kind() == reflect.pointer {
        return reflect.new(_t.elem()).interface().(t)
    }
    return t
}

废话和主要功能将是：

func blah[T FooBar]() {
    var t = gnew[T]()
    do(t)
}

func main() {
    blah[*foo]()
}

Full solution on a go playground

终于介绍完啦！小伙伴们，这篇关于《无法使用 *T 类型的变量作为参数中的类型》的介绍应该让你收获多多了吧！欢迎大家收藏或分享给更多需要学习的朋友吧~golang学习网公众号也会发布Golang相关知识，快来关注吧！