Assign struct pointer to interface pointer

Question

I'm trying to refactor some golang source code, and I would like to use interfaces but I find huge difficulties (bear with me, I'm a hard-core C/C++ orphan)

I extracted a small sample exhibiting the error I get

package main

import "fmt"

type LogProcessor interface {
    Init() int
}

type MyProcessor struct {
    a int
}

func (m MyProcessor) Init() int {
    return m.a
}

func main() {
    t := &(MyProcessor{2})
    var p *LogProcessor = &(MyProcessor{4}) //!!!fails!!!
    fmt.Println((*t).Init(), (*p).Init())
}

Why is the second assignment failing?

---

Adding the code modified to demonstrate what I was trying to do. I thought interfaces where more similar to C++ classes. My fault. Still learning

package main

import "fmt"

type LogProcessor interface {
    Init() int
}

type MyProcessor struct {
    a int
}

func (m *MyProcessor) Init() int {
    m.a++
    return m.a
}

func main() {
    t := &(MyProcessor{2})
    m := MyProcessor{4}
    var p LogProcessor = &m
    fmt.Println(t.Init(), p.Init())
    fmt.Println(t.a, m.a)
}

Answer 1

The expression MyProcessor{2} is a composite literal . It is valid to take the address of a composite literal, and it will be of type *MyProcessor .

So here:

t := &(MyProcessor{2})

Type of t will be *MyProcessor .

Your failing line:

var p *LogProcessor = &(MyProcessor{4}) //!!!fails!!!

The type of the expression on the right hand side is again *MyProcessor . It's a pointer to a concrete type. The type of p is *LogProcessor , it's a pointer to another type. Assignability rules don't apply here, so the value is simply not assignable to the variable p .

Note that there is an assignability rule:

A value x is assignable to a variable of type T (" x is assignable to T ") if one of the following conditions applies:

• ...
• T is an interface type and x implements T .

In your example p 's type is not an interface type, but a pointer to interface. You rarely (if ever) need this in go.

Instead if you use "just" the interface type:

var p LogProcessor = &(MyProcessor{4}) // This works!

This works because the concrete type *MyProcessor implements the interface type LogProcessor . You also don't need the parenthesis, you may simply use &MyProcessor{4} .

Then of course you can't dereference p (as it's not a pointer), so you have to use p.Init() .

Answer 2

it is failing because you are using a pointer to an interface, if you remove the pointer to LogProcessor for var p it works

package main

import "fmt"

type LogProcessor interface {
    Init() int
}

type MyProcessor struct {
    a int
}

func (m MyProcessor) Init() int {
    return 2
}

func main() {
    t := &(MyProcessor{2})
    var p LogProcessor = MyProcessor{4} // works without a pointer to  the interface type
    fmt.Println((*t).Init(), (p).Init())
}