反映，分配一个指针结构值

Question

I m trying to assign a pointer to a struct to the value of an already initialized struct pointer of the same type.

To do a simple service locator

Code is like this

package main

import (
  "fmt"
  "reflect"
)

type Concrete struct {}
func (c *Concrete) Do(){}

type Doer interface {
    Do()
}

func main() {
    l := ServiceLocator{}
    l.Register(&Concrete{})

    var x Doer
    if l.Get(&x); x!= nil {
        fmt.Println("by interface pointer ok")
    }

    // This is not possible in my understanding
    //var z Doer
    //if l.Get(z); z!= nil {
    //  fmt.Println("by interface ok")
    //}

    var y *Concrete
    if l.Get(y); y!= nil {
        fmt.Println("by struct pointer ok")
    }
}

type ServiceLocator struct {
  services []interface{}
  types []reflect.Type
  values []reflect.Value
}

func (s *ServiceLocator) Register(some interface{}) {
  s.services = append(s.services, some)
  s.types = append(s.types, reflect.TypeOf(some))
  s.values = append(s.values, reflect.ValueOf(some))
}

func (s *ServiceLocator) Get(some interface{}) interface{} {
  k := reflect.TypeOf(some).Elem()
  kind := reflect.TypeOf(some).Elem().Kind()
  for i, t := range s.types {
    if kind==reflect.Interface && t.Implements(k) {
      reflect.Indirect(
        reflect.ValueOf(some),
      ).Set(s.values[i])
    } else if kind==reflect.Struct && k.AssignableTo(t.Elem()) {
      fmt.Println(reflect.ValueOf(some).Elem().CanAddr())
      fmt.Println(reflect.ValueOf(some).Elem().CanSet())
      fmt.Println(reflect.Indirect(reflect.ValueOf(some)))
      reflect.ValueOf(some).Set(s.values[i])
    }
  }
  return nil
}

Despite my attempts i keep getting runtime errors such

panic: reflect: reflect.Value.Set using unaddressable value

try the play here

need help, thanks a lot!

---

With JimB helps and information here is the fixed play https://play.golang.org/p/_g2AbX0yHV

Answer 1

You can't assign the value of a pointer directly to y, because you're passing the value of y into Get, not its address. You could pass in the address of y (type **Concrete), so that you could assign a pointer (*Concrete) to y. If it's safe to assign the value directly, you assign the indirection of the registered pointer to y, but y must be initialized with a valid value so that there's an address to write to.

n := 42
p := &n

x := new(int)
// set the value to *x, but x must be initialized
reflect.ValueOf(x).Elem().Set(reflect.ValueOf(p).Elem())
fmt.Println("*x:", *x)

var y *int
// to set the value of y directly, requires y be addressable
reflect.ValueOf(&y).Elem().Set(reflect.ValueOf(p))
fmt.Println("*y:", *y)

https://play.golang.org/p/6tFitP4_jt