这些结构背后发生了什么？结构会被复制吗？

Question

我不明白这段代码到底发生了什么。

receiver func 在原始结构 User 上工作（因为指针），所以在 func 内部我们改变了原始 obj。但是结构地址也是原始地址还是原始“a”的副本？

func main() {
    a := Address{"Freedom", "Kyiv"}
    u := User{"Valeriy", "Zalyzhnyi", a}
    fmt.Println(a)
    fmt.Println(u)
    u.updateStreet("Peremohy")

    fmt.Println(a)
    fmt.Println(u)
}

func (u *User) updateStreet(street string) {
    u.address.street = street
}

type User struct {
    firstName string
    lastName  string
    address   Address
}

type Address struct {
    street string
    city   string
}

这是我的输出

{Freedom Kyiv}
{Valeriy Zalyzhnyi {Freedom Kyiv}}
{Freedom Kyiv}
{Valeriy Zalyzhnyi {Peremohy Kyiv}}

由此我了解到 u.address 已更改，我还看到 'u' 内部的这个 'a' 与原始对象不同。 那么在引擎盖下和内存中到底发生了什么？ 根据输出，这种行为对我来说是完全出乎意料的。 我期待的是，由于指针，我们在两种情况下（'a' 和 'u'）都使用原始对象。第二次（在 func 'update..' 之后）打印 fmt.Println(a) 会给我们 {Peremohy Kyiv} 因为第二个 fmt.Println(u) 给了我们 {Valeriy Zalyzhnyi {Peremohy Kyiv}}

Answer 1

要了解引擎盖下发生了什么，可视化代码的作用会很有用：

a = address{}
u := user{address: a}

分解为：

| variable value        | memory address |
| a = address{}         | 0x000001       |
| u = user{}            | 0x000002       |
| u.address = copy of a | 0x000003       |

所以你已经为

user{}

的1个实例和

address{}

的2个实例分配了内存。第二个地址实例的值是第一个地址实例的精确副本，在创建副本时。

现在，当您调用

updateStreet

时，它是通过指针在

u

上调用的，它不会创建

user

实例的副本，而是对内存地址

0x000002

进行操作，因此它有效地对相同的

a

变量。因此表达式：

u.address.street = "foo"

翻译成这样：在内存地址 0x000002 中保存的值，访问名为

address

的字段，在该字段中，访问字段

street

并为其分配新值。让我们将其映射到我们在上面创建的表中：

  0x000002 -> address (which is stored in 0x000003)
              |
              --> set street to "foo"

一旦函数返回，我们仍然拥有与之前相同的对象，位于内存中的相同位置，但是因为我们已经通过内存中的地址访问了

a

的值，所以

updateStreet

函数所做的更改具有被设为

u

的值（因为我们使用了相同的内存地址）。

变量

a

在赋值给 u.address 时被

copied

，所以它的内存地址不知道，或者传递给

updateStreet

函数，因此保持不变。