包装的结构引用

I am little consfused about value type struct wrapped by pointer type struct.

Example:

package main

import (
    "fmt"
)

type A struct {
  id int
  B
}

func (a *A) setId(val int) {
  a.id = val
}

type B struct {
  name string
}

func (b B) setNameViaValue(val string) {
  b.name = val
}

func (b *B) setNameViaPointer(val string) {
  b.name = val
}

func main() {
    a := new(A)
    a.setId(1)
    a.setNameViaValue("valuename")
    fmt.Println(a)
    a.setNameViaPointer("pointername")
    fmt.Println(a)
}

I would expect that referencing through pointer type A struct(which addresses concrete memory) that wraps B value type struct will set inner value no matter what kind of refence to B is used (B/*B). This is also related to type definition. Can anyone also explain what is different when I define it like this? Is there any usecase scenario?

type A struct {
  id int
  *B
}

Why doesn't setNameViaValue end up setting the name

If you declare a method with a value (non-pointer) receiver, then that method cannot "modify" the receiver cause it will actually receive a copy.

That's why the "name" is not set as you expected with the setNameViaValue method.

If you want to be able to set the name of B in that way, only setNameViaPointer is an option.

You can read more about the differences between method and value receivers here:

https://tour.golang.org/methods/8

Why can you actually invoke the inner struct methods on the outer struct

That's because you "embedded" the inner struct in the outer one.

When you include a struct type name without giving it a field name, then all of the "inner" struct methods and fields are "promoted" to the outer one.

That means you can call a.setNameViaValue and it will be equivalent to doing a.B.setNameViaValue.

Is there any difference if I embedded as a pointer

If you define A this way:

type A struct {
  id int
  *B
}

Then:

• The "setNameViaValue" will still not work (that's only related to the method being defined over a value instead of a pointer receiver, it has nothing to do with how A references B).

• You will need to initialize B explicitly when creating an A object, otherwise *B will end up being nil. (if you reference it as a value, it will be initialized as an empty B)

• You can change what *B points to later on (if it was a value, then it will always reference the same "value")