结构的方法签名之间的区别

Question

As a programmer coming from other languages like C++, I find it rather strange that go allows to specify methods for structs that allow either a pointer or an instance as a parameter. According to go by example once could use either of them if we didn't want to modify the origin:

Go automatically handles conversion between values and pointers for method calls. You may want to use a pointer receiver type to avoid copying on method calls or to allow the method to mutate the receiving struct.

Consider the following code:

package main

import (
    "fmt"
)

type Foo struct {}

type Bar struct {}

func (this Foo) String() string {
  return "Foo"
}

func (this *Bar) String() string {
  return "Bar"
}

func main() {
  fmt.Println(Foo{}) // "Foo"
  fmt.Println(Bar{}) // "{}"
}

Why can't I use both signature versions to modify the stringify (I don't know how it is actually called in go) behavior of the structs?

Just to be clear: I don't really care about the stringify, but want to understand how the language behaves.

Answer 1

Just add & to the Bar{} and make it pointer receiver, like this:

fmt.Println(&Bar{}) // "Bar"

Here a little adjustment to your code that outputs:

Foo
Bar

see:

package main

import "fmt"

type Foo struct{}

func (Foo) String() string {
    return "Foo"
}

type Bar struct{}

func (*Bar) String() string {
    return "Bar"
}

func main() {
    fmt.Println(Foo{}) // "Foo"
    pb := &Bar{}
    fmt.Println(pb) // "Bar"
}

---

Notes:

Receiver name should be a reflection of its identity; don't use generic names such as "this" or "self"

And you don't need names here for your example.

And nice to read Golang methods receivers:

Value receivers operate on a copy of the original type value. This means that there is a cost involved, especially if the struct is very large, and pointer received are more efficient.