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

接收方 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”与原始的 obj 不同。 那么幕后和内存中究竟发生了什么？ 根据输出，这种行为对我来说是完全出乎意料的。 我期望由于指针的存在，我们在两种情况下都使用原始对象（“a”和“u”）。第二次（在 func 'update..' 之后）打印 fmt.println(a) 将为我们提供 {peremohy kyiv}，因为第二次 fmt.println(u) 为我们提供 {valeriy zalyzhnyi {peremohy kyiv}}

正确答案

要了解幕后发生的情况，可视化代码的作用可能会很有用：

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

细分为：

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

因此，您已为 1 个 user{} 实例和 2 个 address{} 实例分配了内存。第二个地址实例的值是第一个地址实例的精确副本（在创建副本时）。

现在，当您调用 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 时被复制，因此它的内存地址未知，或者传递给 updatestreet 函数，因此保持不变。