[pointers] X는 Y를 구현하지 않습니다 (… 메소드에 포인터 수신기가 있습니다).

이 컴파일 타임 오류는 구체적 유형을 인터페이스 유형 에 지정하거나 전달 (또는 변환)하려고 할 때 발생 합니다. 타입 자체는 인터페이스를 구현하지 않고 type에 대한 포인터 만 구현합니다 .

예를 보자.

type Stringer interface {
    String() string
}

type MyType struct {
    value string
}

func (m *MyType) String() string { return m.value }

Stringer인터페이스 유형은 하나의 방법 만이 있습니다 String(). 인터페이스 값에 저장된 모든 값 Stringer에는이 방법이 있어야합니다. 또한을 만들고 포인터 수신기를 사용 MyType하여 메서드 MyType.String()를 만들었습니다 . 이는 메소드가 유형 의 메소드 세트 에 있지만 의 메소드 세트 에는 없음을 의미 합니다.String()*MyTypeMyType

MyTypetype의 변수에 값을 할당하려고 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)

우리는 유형의 값을 할당하려고한다면 모든 것이 괜찮 *MyType로를 Stringer:

s = &m
fmt.Println(s)

그리고 우리는 예상 결과를 얻습니다 ( Go Playground 에서 시도하십시오 ).

something

따라서이 컴파일 타임 오류를 얻는 데 필요한 요구 사항은 다음과 같습니다.

• 포인터 가 아닌 콘크리트 유형 의 값 이 지정되거나 전달되거나 변환됩니다.
• 인터페이스 유형에 지정되거나 전달되거나 변환되는 인터페이스 유형
• 구체적 유형에는 필요한 인터페이스 방법이 있지만 포인터 수신기가 있습니다.

문제를 해결할 수있는 가능성 :

• 값에 대한 포인터를 사용해야하며, 이의 메소드 세트에는 포인터 수신기가있는 메소드가 포함됩니다.
• 또는 리시버 유형을 non-pointer 로 변경해야 하므로 비 포인터 콘크리트 유형의 메소드 세트도 메소드를 포함하므로 인터페이스를 만족시킵니다. 메소드가 값을 수정해야하는 것처럼 비 포인터 리시버는 옵션이 아닌 것처럼 이는 실행 가능하거나 불가능할 수 있습니다.

구조 및 임베딩

구조체와 embedding을 사용할 때 , 종종 인터페이스를 구현하는 것은 “사용자”가 아니라 (메소드 구현을 제공함),에 포함 된 타입 struct입니다. 이 예에서와 같이 :

type MyType2 struct {
    MyType
}

m := MyType{value: "something"}
m2 := MyType2{MyType: m}

var s Stringer
s = m2 // Compile-time error again

다시 한 번, 컴파일 시간 오류는의 메소드 세트에 embed MyType2의 String()메소드를 포함하지 않기 때문에의 메소드 세트 MyType만 포함 *MyType2하므로 다음 작업이 수행됩니다 ( Go Playground 에서 시도 ).

var s Stringer
s = &m2

포인터*MyType 가 아닌 포인터 를 포함 하고 사용하는 경우 MyType2에도 Go Playground 에서 시도해보십시오 .

type MyType2 struct {
    *MyType
}

m := MyType{value: "something"}
m2 := MyType2{MyType: &m}

var s Stringer
s = m2

또한 우리가 포함하거나 ( MyType또는 *MyType) 포인터를 사용 *MyType2하면 항상 작동합니다 ( Go Playground 에서 시도하십시오 ).

type MyType2 struct {
    *MyType
}

m := MyType{value: "something"}
m2 := MyType2{MyType: &m}

var s Stringer
s = &m2

스펙의 관련 섹션 (섹션 유형에서 ) :

구조체 유형 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

assert 타입 대신 변환하려고하면, 우리가 이야기하고있는 컴파일 타임 에러가 발생합니다 :

m := MyType{value: "something"}

fmt.Println(Stringer(m))

답변

package main

import "fmt"

// Loader defines a content loader
type Loader interface {
    Load(src string) string
}

// WebLoader is a web content loader
type WebLoader struct{}

// Load loads the content of a page
func (w *WebLoader) Load(src string) string {
    return fmt.Sprintf("I loaded this page %s", src)
}

func main() {
    webLoader := WebLoader{}
    loadContent(webLoader)
}

func loadContent(loader Loader) {
    loader.Load("google.com")
}

webLoader := &WebLoader{} 

type GetterSetter interface {
   GetVal() int
   SetVal(x int) int
}

type MyTypeA struct {
   a int
}

func (m MyTypeA) GetVal() int {
   return a
}

func (m *MyTypeA) SetVal(newVal int) int {
    int oldVal = m.a
    m.a = newVal
    return oldVal
}

myTypeInstance := MyType{ 7 }
... maybe some code doing other stuff ...
var f interface{} = myTypeInstance
_, ok := f.(GetterSetter)
if !ok {
    t.Fail()
}

var f interface{} = new(&MyTypeA)
 ...

myTypeInstance := MyType{ 7 }
var f interface{} = &myTypeInstance
...

func SomeStuff(g GetterSetter, x int) int {
    if x > 10 {
        return g.GetVal() + 1
    }
    return g.GetVal()
}

func (m MyTypeA) OtherThing(x int) {
    SomeStuff(m, x)
}

func (m *MyTypeA) OtherThing(x int) {
    SomeStuff(m, x)
}

func (m MyTypeA) OtherThing(x int) {
    SomeStuff(&m, x)
}