Go语言指针传递与内存地址解析

Go语言的参数传递机制：值传递

Go语言中的所有参数传递都是值传递。这意味着当一个变量作为函数参数被传入时，函数会接收到该变量的一个副本。对于基本类型（如int, string, bool等），传递的是它们的实际值；对于复合类型（如struct, array），传递的是它们的整个副本。

当传递指针时，情况略有不同但本质依然是值传递。传递的是指针变量本身的值，即它所指向的内存地址。函数会获得这个内存地址的一个副本，而不是指向该地址的指针变量本身的一个副本。

指针作为参数时的行为解析

为了更好地理解这一点，我们来看一个简化后的示例：

package main

import "fmt"

func byVal(q *int) {
    // 3. 打印函数参数q的地址（即q变量在内存中的位置）和q的值（即它指向的地址）
    fmt.Printf("3. byVal -- q %T: &q=%p q=&i=%p  *q=i=%v\n", q, &q, q, *q)
    *q = 4143 // 通过指针q修改它所指向的底层int值
    // 4. 再次打印q的地址和值，以及修改后的底层int值
    fmt.Printf("4. byVal -- q %T: &q=%p q=&i=%p  *q=i=%v\n", q, &q, q, *q)
    q = nil // 将函数内部的q设置为nil，这不会影响外部的p
}

func main() {
    i := int(42) // 声明一个int变量i
    // 1. 打印i的类型、内存地址和值
    fmt.Printf("1. main  -- i  %T: &i=%p i=%v\n", i, &i, i)

    p := &i // 声明一个int指针p，指向i的地址
    // 2. 打印p的类型、内存地址（p变量在内存中的位置）、p的值（即它指向的地址）和p所指向的值
    fmt.Printf("2. main  -- p %T: &p=%p p=&i=%p  *p=i=%v\n", p, &p, p, *p)

    byVal(p) // 调用byVal函数，将指针p的值（i的地址）作为参数传递

    // 5. 函数返回后，再次打印p的地址、值和p所指向的值
    fmt.Printf("5. main  -- p %T: &p=%p p=&i=%p  *p=i=%v\n", p, &p, p, *p)
    // 6. 再次打印i的地址和值
    fmt.Printf("6. main  -- i  %T: &i=%p i=%v\n", i, &i, i)
}

运行上述代码，输出类似（内存地址可能不同）：

1. main  -- i  int: &i=0xc000018080 i=42
2. main  -- p *int: &p=0xc000006028 p=&i=0xc000018080  *p=i=42
3. byVal -- q *int: &q=0xc000006030 q=&i=0xc000018080  *q=i=42
4. byVal -- q *int: &q=0xc000006030 q=&i=0xc000018080  *q=i=4143
5. main  -- p *int: &p=0xc000006028 p=&i=0xc000018080  *p=i=4143
6. main  -- i  int: &i=0xc000018080 i=4143

解析：

1. main函数中的变量 i 和 p:

   • i 是一个 int 变量，存储在地址 0xc000018080，值为 42。
   • p 是一个 *int 指针变量，它本身存储在地址 0xc000006028。p 的值是 i 的地址 0xc000018080，即 p 指向 i。*p 则表示 p 所指向的值，即 42。

2. byVal函数中的参数 q:

   • 当调用 byVal(p) 时，p 的值（即 0xc000018080）被复制并赋值给 byVal 函数的参数 q。
   • 因此，q 也是一个 *int 指针变量，它本身存储在地址 0xc000006030。注意，&q (0xc000006030) 与 &p (0xc000006028) 不同，这说明 p 和 q 是两个独立的指针变量，它们在内存中有各自的位置。
   • 然而，q 的值与 p 的值相同，都是 0xc000018080。这意味着 q 也指向 i 变量。

3. 修改底层数据:

   • 在 byVal 函数内部，*q = 4143 操作通过 q 指针修改了它所指向的内存地址 0xc000018080 处的值。由于 p 和 q 都指向 i 的地址，所以这个修改会影响到 main 函数中的 i 变量。
   • 从输出 4. byVal -- ... *q=i=4143 和 6. main -- ... i=4143 可以看出，i 的值确实被改变了。

4. 修改指针变量本身:

   • 在 byVal 函数的最后，q = nil 操作将函数内部的 q 指针变量的值设置为 nil。这仅仅改变了 q 变量本身所存储的地址，使其不再指向 i。
   • 但这个操作对 main 函数中的 p 变量没有任何影响，因为 q 是 p 的一个独立副本。从输出 5. main -- ... p=&i=0xc000018080 可以看出，p 仍然指向 i 的地址。

原始代码中的困惑解析

回到原始问题中的代码片段：

// main函数中
s := new(Something)
println(&s) // 打印的是main函数中s变量的地址

// gotest函数中
func gotest( s *Something, done chan bool ) {
    println( "from gotest:")
    println( &s ) // 打印的是gotest函数中s参数的地址
    // ...
}

原始问题中观察到 println(&s) 在 main 函数和 gotest 函数中打印出不同的地址，但 s.number 却被成功修改。这正是上述“指针作为参数时的值传递”机制的体现：

• main 函数中的 s 是一个 *Something 类型的变量，它存储在 0x4930d4 这个内存地址。它的值是一个指向 Something 结构体实例的地址。
• 当 go gotest(s, done) 被调用时，main 函数中 s 的值（即 Something 结构体实例的地址）被复制并传递给 gotest 函数的参数 s。
• gotest 函数内部的 s 参数是一个新的变量，它存储在 0x4974d8 这个内存地址。因此，&s 在两个函数中显示不同的地址是完全正常的，因为它们是两个不同的变量。
• 然而，这两个不同的 s 变量却持有相同的值——它们都指向 main 函数中创建的那个 Something 结构体实例的内存地址。所以，通过 gotest 函数内部的 s 来修改 s.number，实际上是修改了同一个 Something 结构体实例的成员，这在 main 函数中也能反映出来。

简而言之：main.&s != gotest.&s (因为它们是不同的变量)，但 main.s == gotest.s (因为它们指向同一个底层对象)。

正确观察指针值

为了避免混淆，强烈建议使用 fmt 包来格式化输出，特别是 %p 动词，它专门用于打印指针的值（即它所指向的内存地址）。

• fmt.Printf("%p", ptrVar)：打印 ptrVar 所指向的内存地址。
• fmt.Printf("%p", &ptrVar)：打印 ptrVar 这个变量本身在内存中的地址。

例如，在原始代码中，如果你想确认 main 和 gotest 中的 s 是否指向同一个 Something 对象，应该这样打印：

package main

import (
    "fmt"
    "runtime"
)

type Something struct {
    number int
    queue  chan int
}

func gotest(s *Something, done chan bool) {
    fmt.Println("from gotest:")
    fmt.Printf("  Address of s variable in gotest: %p\n", &s) // s变量本身的地址
    fmt.Printf("  Value of s pointer in gotest: %p\n", s)    // s指向的Something对象的地址

    for num := range s.queue {
        fmt.Println("  Received num:", num)
        s.number = num // 修改s指向的Something对象
    }
    done <- true
}

func main() {
    runtime.GOMAXPROCS(4)
    s := new(Something)
    fmt.Printf("Main: Address of s variable: %p\n", &s) // s变量本身的地址
    fmt.Printf("Main: Value of s pointer: %p\n", s)    // s指向的Something对象的地址

    s.queue = make(chan int)
    done := make(chan bool)

    go gotest(s, done)

    s.queue <- 42
    close(s.queue)
    <-done

    fmt.Printf("Main: After goroutine, address of s variable: %p\n", &s)
    fmt.Printf("Main: After goroutine, value of s pointer: %p\n", s)
    fmt.Printf("Main: s.number: %d\n", s.number)
}

通过这种方式，你会发现 Main: Value of s pointer 和 from gotest: Value of s pointer 打印出的地址是相同的，这正是它们操作同一个 Something 对象的证据。

总结与注意事项

1. Go语言是纯粹的值传递：无论是基本类型、结构体还是指针，传递的都是其值的副本。
2. 指针变量的地址与指针变量的值：
   • &ptrVar 得到的是 ptrVar 这个指针变量本身在内存中的存储地址。
   • ptrVar（不带 &）得到的是 ptrVar 所存储的内存地址，即它所指向的对象的地址。
3. 函数参数中的指针：当一个指针作为参数传入函数时，函数会得到这个指针值的一个副本。这意味着函数内部的指针变量与外部的指针变量是两个独立的内存实体，但它们指向的底层数据是同一个。
4. 修改指针指向的数据：通过函数内部的指针副本修改其指向的底层数据，会影响到外部的原始数据。
5. 修改指针变量本身：在函数内部对指针副本进行重新赋值（如 q = nil 或 q = anotherAddress），不会影响到外部的原始指针变量。
6. fmt.Printf 的 %p 动词：始终使用 fmt.Printf("%p", ptrVar) 来打印指针所指向的地址，而不是 println(&ptrVar)，以避免混淆。
7. GC与对象ID：Go的垃圾回收器可能会移动内存中的对象，但指针的值（它所指向的地址）会相应更新，以确保它始终指向正确的对象。因此，指针的值本身可以被视为对象的“持久ID”，因为它始终能够正确引用到该对象。

理解这些概念对于编写健壮、可预测的Go程序至关重要，尤其是在涉及并发和共享数据时。