If I have:
type foo struct{
}
func bar(baz interface{}) {
}
The above are set in stone - I can't change foo or bar. Additionally, baz must converted back to a foo struct pointer inside bar. How do I cast &foo{} to interface{} so I can use it as a parameter when calling bar?
To turn *foo into an interface{} is trivial:
f := &foo{}
bar(f) // every type implements interface{}. Nothing special required
In order to get back to a *foo, you can either do a type assertion:
func bar(baz interface{}) {
f, ok := baz.(*foo)
if !ok {
// baz was not of type *foo. The assertion failed
}
// f is of type *foo
}
Or a type switch (similar, but useful if baz can be multiple types):
func bar(baz interface{}) {
switch f := baz.(type) {
case *foo: // f is of type *foo
default: // f is some other type
}
}
baz in your example
baz might be, then you will have to work with reflection (import "reflect"). This is how packages like encoding/json can encode basically any type without knowing before hand.
fmt.Printf will always receive its arguments as interfaces. What it does is telling you the type inside the interface. That means that fmt.Printf("%T", f) and fmt.Printf("%T", interface{}(f)) is the same. The only difference is that in the latter, I did a redundant explicit conversion.Converting a struct to interface can be achieved like this. Where i is an assign data structure.
var j interface{} = &i
Not fully-related, but I googled the question "convert interface struct to pointer" and get here.
So, just make a note: to convert an interface of T to interface of *T:
//
// Return a pointer to the supplied struct via interface{}
//
func to_struct_ptr(obj interface{}) interface{} {
vp := reflect.New(reflect.TypeOf(obj))
vp.Elem().Set(reflect.ValueOf(obj))
return vp.Interface()
}
