Passing an interface pointer in a function parameter

Question

I am trying to understand Golang (1.12) interfaces. I found out that interface pointers must be explicitly dereferenced, unlike structs:

import "fmt"

// A simple interface with one function
type myinter interface {
    hello()
}

// Implement myinter
type mystruct struct {}

func (mystruct) hello() {
    fmt.Println("I am T!")
}

// Some function that calls the hello function as defined by myinter
func callHello(i *myinter) {   
    i.hello()  // <- cannot resolve reference 'hello'
}

func main() {
    newMystruct := &mystruct{}
    callHello(newMystruct)
}

Here, my callHello function cannot resolve the reference to my hello function as defined in the interface. Of course, dereferencing the interface works:

func callHello(i *myinter) {   
    (*i).hello()  // <- works!
}

But in structs, we can call the function directly, none of this cumbersome dereference notation is necessary:

func callHello(s *mystruct) {   
    s.hello()  // <- also works!
}

Why is this the case? Is there a reason why we must explicitly dereference interface pointers? Is Go trying to discourage me from passing interface pointers into functions?

It's rare to use a pointer to an interface in Go. Nothing in the question indicates that there's a reason to use a pointer to an interface. Fix by changing *myinter to myinter. This fixes the error at callHello(newMystruct) and at i.hello(). — user5728991
– user5728991, Commented Oct 9, 2019 at 17:41

Burak Serdar · Accepted Answer · 2019-10-10 15:57:53Z

1

It is related to the way the type system works. An interface type I defines a method set. The method set is defined for type I, and not for type *I. Because of this, the use of *I is limited. It can be used when a function is to set the interface value, but it is rare:

func f(x *error) {
  *x = fmt.Errorf("Some error")
}

Note that the interface itself can have an underlying pointer value:

func f(x someInterface) {
   *x.(*someType) = value
}

func main() {
   x := someType{}
   f(&x)
}

This is different for non-interface types. When you define a method for a non-interface type T, the method is defined for both T and *T. If you define a method for *T, it is only defined for *T, and not for T.

edited Oct 10, 2019 at 15:57

user142162

answered Oct 9, 2019 at 17:58

Burak Serdar

52.5k4 gold badges54 silver badges74 bronze badges

Sign up to request clarification or add additional context in comments.

2 Comments

Kenny Over a year ago

But if I want to take an interface as a parameter in a function, wouldn't it be inefficient to pass a concrete type in by value? Interfaces represent abstract types, wouldn't passing a pointer be better than passing by value especially when we don't know the size of the concrete type?

Burak Serdar Over a year ago

If you pass an interface to a function, what's passed is the pointer to the underlying value, and a pointer to the type. If the underlying value of the interface is a struct (not pointer), interface points to a copy of the struct. If you pass a concrete struct to the function, the struct will be copied. If you pass a pointer to the struct, only a pointer will be passed. So passing in a struct takes a copy, regardless if you pass it via an interface or not.

Buttle Butkus · Accepted Answer · 2023-01-19 21:53:00Z

1

Is Go trying to discourage me from passing interface pointers into functions?

Yes.

Pointer-to-interface is wrong in (almost*) all cases.

(* There are very rare and delicate cases where pointer-to-interface makes sense but chances are high you won't see them more than once every 5 years.)

(Nitpick: The language is called "Go". "golang.org" is the website. Basics like this are covered by the compatibility promise and do not depend on the version: Go 1.0, 1.12 and 1.16 behave exactly the same in this regard.)

edited Jan 19, 2023 at 21:53

Buttle Butkus

9,54713 gold badges86 silver badges126 bronze badges

answered Oct 10, 2019 at 6:56

Volker

42.6k8 gold badges86 silver badges97 bronze badges

2 Comments

Kenny Over a year ago

Can you elaborate why this is wrong? Coming from a heavy Java development past, it seems that interface pointers would be more common (passing pointers to abstract types).

Volker Over a year ago

@KennyWorden Pointer-to-something is needed if you want to mutate the something. An interface value itself is seldomly modified. What is modified is the actual value contained in the interface value: It is common to store pointers inside an interface, but that is completely different from a pointer to an interface value itself.

Stephen Dunne · Accepted Answer · 2022-07-15 14:50:58Z

0

Simply remove the pointer and use the interface.

func callHello(i myinter) {   
    i.hello()  
}

This func will now accept either an instance of a struct that implements the interface, or a pointer to an instance of a struct that implements the interface.

func main() {
    instance := mystruct{}
    pointer := &mystruct{}
    callHello(instance)
    callHello(pointer)
}

outputs the following:

I am T!
I am T!
 
Program exited.

answered Jul 15, 2022 at 14:50

Stephen Dunne

4691 gold badge9 silver badges17 bronze badges

Collectives™ on Stack Overflow

Passing an interface pointer in a function parameter

3 Answers 3

2 Comments

2 Comments

Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

3 Answers 3

2 Comments

2 Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related