X implementiert Y nicht (...Methode hat einen Zeigerempfänger)

php-Editor Xiaoxin wird in diesem Artikel ein Problem besprechen, bei dem X Y nicht implementiert. Bei diesem Problem haben wir einen Pointer-Receiver-Ansatz verwendet. Durch diese Methode können wir besser verstehen, warum X Y nicht erreichen kann, und Wege finden, dieses Problem zu lösen. Im folgenden Inhalt werden wir dieses Problem im Detail besprechen und einige Lösungen anbieten.

Frageninhalt

Zu der Frage „ auf meine spezifische Situation.

Anstatt die Frage also sehr spezifisch zu formulieren, werde ich sie weit gefasst und abstrakt formulieren – es scheint, als gäbe es ein paar verschiedene Situationen, die zu diesem Fehler führen könnten. Kann das jemand zusammenfassen?

Wie kann man dieses Problem vermeiden und welche Möglichkeiten gibt es, wenn es auftritt? Danke.

Problemumgehung

Dieser Fehler bei der Kompilierung tritt auf, wenn Sie versuchen, einem Schnittstellentyp einen „konkreten“ Typ zuzuweisen oder zu übergeben (oder umzuwandeln), und der Typ selbst implementiert nicht die Schnittstelle, sondern nur einen „Zeiger“ auf den Typzeiger

. Kurze Zusammenfassung:

Eine

Zuweisung an eine Variable^{Der Schnittstellentyp ist gültig, wenn der zugewiesene Wert die Schnittstelle implementiert, der er zugewiesen ist. Wenn sein Methodensatz eine Obermenge der Schnittstelle ist, wird er diese implementieren. Der Methodensatz der Zeigertypen umfasst Methoden mit Zeiger- und Nicht-Zeiger-Empfängern. Der Methodensatz für Nicht-Zeiger-Typen umfasst nur Methoden mit Nicht-Zeiger-Empfängern. Sehen wir uns ein Beispiel an:}

type stringer interface {
    string() string
}

type mytype struct {
    value string
}

func (m *mytype) string() string { return m.value }

stringer-Schnittstellentyp hat nur eine Methode: string(). Jeder im Schnittstellenwert stringer gespeicherte Wert muss über diese Methode verfügen. Wir haben auch einen mytype und eine Methode mytype.string() mit einem

pointer

receiver erstellt. Das bedeutet, dass sich die Methode string() im

Methodensatz

des Typs *mytype befindet, aber nicht in mytype. stringer 接口类型只有一个方法：string()。存储在接口值 stringer 中的任何值都必须具有此方法。我们还创建了一个 mytype，并创建了一个带有指针接收器的方法 mytype.string()。这意味着 string() 方法位于 *mytype 类型的 方法集 中，但是不在 mytype

Wenn wir versuchen, eine Variable vom Typ

zu konvertieren, erhalten wir die folgende Fehlermeldung: mytype 的值分配给 stringer

m := mytype{value: "something"}

var s stringer
s = m // cannot use m (type mytype) as type stringer in assignment:
      //   mytype does not implement stringer (string method has pointer receiver)

Aber wenn wir versuchen,

hinzuzufügen, funktioniert alles gut: *mytype 类型的值分配给 stringer

s = &m
fmt.println(s)

Wir haben das erwartete Ergebnis erhalten (versuchen Sie es auf

Go Playground):

something

Daher die Voraussetzung, um diesen Fehler bei der Kompilierung zu erhalten:

Ein
• Nicht-Zeiger-Wert eines konkreten Typs, der zugewiesen (oder übergeben oder konvertiert) wird Der Schnittstellentyp, der zugewiesen (oder übergeben oder konvertiert) wird
Ein konkreter Typ verfügt über die für die Schnittstelle erforderlichen Methoden, verfügt jedoch über einen
• Zeigerempfänger
Möglichkeit zur Lösung des Problems:

Es muss ein Zeiger auf einen Wert verwendet werden und sein Methodensatz umfasst Methoden mit Zeigerempfängern

Oder der Empfängertyp muss in
• Nicht-Zeiger
geändert werden, damit der Methodensatz des konkreten Nicht-Zeiger-Typs auch diese Methode enthält (wodurch die Schnittstelle erfüllt wird). Dies kann möglich sein oder auch nicht, denn wenn die Methode den Wert ändern muss, ist ein Nicht-Zeiger-Empfänger keine Option.
• Struktur und Einbettung

Bei der Verwendung von

Strukturen und dem Einbetten

ist es normalerweise nicht „Sie“, der die Schnittstelle implementiert (die Methodenimplementierungen bereitstellt), sondern der in

eingebettete Typ. Wie dieses Beispiel:

type mytype2 struct {
    mytype
}

m := mytype{value: "something"}
m2 := mytype2{mytype: m}

var s stringer
s = m2 // compile-time error again

Beim erneuten Kompilieren ist aufgrund des Methodensatzes von struct ein Fehler aufgetreten, sodass die folgende Methode funktioniert (in

Zum Spielplatz gehen

): mytype2的方法集不包含内嵌mytype的string()方法，只有*mytype2

var s stringer
s = &m2

Wir können es auch zum Laufen bringen, wenn wir *mytype einbetten und einfach Nichtzeiger

mytype2 verwenden (in

Go to Playground*mytype 并仅使用非指针 mytype2):

type mytype2 struct {
    *mytype
}

m := mytype{value: "something"}
m2 := mytype2{mytype: &m}

var s stringer
s = m2

Egal was wir einbetten (

, es funktioniert immer (in

Zum Spielplatz gehenmytype 或 *mytype），如果我们使用指针 *mytype2):

type mytype2 struct {
    *mytype
}

m := mytype{value: "something"}
m2 := mytype2{mytype: &m}

var s stringer
s = &m2

Relevanter Abschnitt aus der Spezifikation (aus dem Abschnitt

Strukturtypen

):

给定一个结构体类型 s 和一个名为 t 的类型，提升的方法包含在该结构体的方法集中，如下所示：

• 如果 s 包含匿名字段 t，则 s 和 *s 的方法集均包含接收者为 t 的提升方法。 *s 的方法集还包括接收者 *t 的提升方法。
• 如果 s 包含匿名字段 *t，则 s 和 *s 的方法集都包含接收者为 t 或 *t 的提升方法。

换句话说：如果我们嵌入一个非指针类型，非指针嵌入器的方法集只能获取具有非指针接收器的方法（来自嵌入类型）。

如果我们嵌入一个指针类型，非指针嵌入器的方法集将获取具有指针和非指针接收器的方法（来自嵌入类型）。

如果我们使用指向嵌入器的指针值，则无论嵌入类型是否是指针，指向嵌入器的指针的方法集始终都会获取具有指针和非指针接收器的方法（从嵌入类型）。

注意：

有一个非常相似的情况，即当您有一个包含 mytype 值的接口值时，并且您尝试 类型断言 另一个接口值，stringer。在这种情况下，由于上述原因，断言将不成立，但我们会得到一个略有不同的运行时错误：

m := mytype{value: "something"}

var i interface{} = m
fmt.println(i.(stringer))

运行时恐慌（在 go playground 上尝试一下）：

panic: interface conversion: main.mytype is not main.stringer:
    missing method string

尝试转换而不是类型断言，我们得到了我们正在讨论的编译时错误：

m := MyType{value: "something"}

fmt.Println(Stringer(m))

Das obige ist der detaillierte Inhalt vonX implementiert Y nicht (...Methode hat einen Zeigerempfänger). Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!