Ponteiros para uma Interface

Você quase nunca precisa de ponteiros para tipos de interface. Você deve passar interfaces por valor e, ao fazer isso, os dados subjacentes ainda podem ser um ponteiro.

As interfaces são essencialmente representadas com dois campos no nível subjacente:

  1. Um ponteiro para alguma informação específica do tipo. Você pode pensar nisso como o "tipo".
  2. Um ponteiro para os dados. Se os dados armazenados forem um ponteiro, eles são armazenados diretamente. Se os dados armazenados forem um valor, é armazenado um ponteiro para esse valor.

Se você deseja que os métodos da interface modifiquem os dados subjacentes, você deve usar receptores de ponteiro (atribuir o ponteiro do objeto à variável de interface).

type F interface {
  f()
}

type S1 struct{}

func (s S1) f() {}

type S2 struct{}

func (s *S2) f() {}

// f1.f() não pode modificar os dados subjacentes
// f2.f() pode modificar os dados subjacentes, o ponteiro do objeto é atribuído à variável de interface f2
var f1 F = S1{}
var f2 F = &S2{}

Nunca use ponteiros para uma interface, isso é sem sentido. Na linguagem Go, a própria interface é um tipo de referência. Em outras palavras, o próprio tipo de interface é um ponteiro. Para minhas necessidades, o parâmetro para teste só precisa ser myinterface, e só preciso passar um tipo *mystruct (e só posso passar um tipo *mystruct) ao passar o valor.

type myinterface interface{
	print()
}

func test(value *myinterface){
	//algo para fazer ...
}

type mystruct struct {
	i int
}

// Implementar a interface
func (this *mystruct) print(){
	fmt.Println(this.i)
	this.i=1
}

func main(){
	m := &mystruct{0}
test(m) // Incorreto
test(*m) // Incorreto
}