Go中接口类型的间接

Question

I'm trying to create a function that will create a new instance of an interface, and assign that instance to a variable that has the type of the interface. Here is a simple example program (which does not compile):

package main

import (
    "fmt"
)

type Foo interface {
    Foo(int) int
}

type Foo_impl struct {}

func (f *Foo_impl) Foo(x int) int {
    return x * 2
}

func main() {
    var x *Foo_impl
    constructFoo(x)

    fmt.Println("Hello, playground")
}

func constructFoo(x Foo) {
    *x = Foo_impl{} // Blows up here - invalid indirect of x (type Foo)
}

Is it possible via reflection to indirect an interface variable, and assign to the underlying value? If I were not using interfaces, I would do something like this,

func main() {
    var x int
    foo(&x)
    fmt.Printf("%d
", x)
}

func foo(x *int) {
    *x = 4
}

And as expected, this will print out 4. The issue is that interface variables cannot be indirected in the normal way. Is there a way around this?

Answer 1

I was able to write a function that did what I want

package main

import (
    "fmt"
    "reflect"
)

type Y interface {
    SetX(int)
}

type X struct {
    test int
}

func (x *X) SetX(param int) {
    x.test = param
}

func main() {
    var x *X
    y := foo(&x)
    y.SetX(12)
    fmt.Printf("%+v", x)
}

func foo(x interface{}) Y {
    t := reflect.TypeOf(x)
    pointerType := t.Elem()
    realType := pointerType.Elem()

    pointer := reflect.New(realType)
    reflect.Indirect(reflect.ValueOf(x)).Set(pointer)

    return pointer.Interface().(Y)
}

The foo function can initialize any double pointer to a type that implements Y, and it returns the new instance as a Y.