深入理解Go语言函数参数传递：值、指针与内存地址-Golang-PHP中文网

深入理解Go语言函数参数传递：值、指针与内存地址

Go语言中，所有函数参数都是按值传递的。这意味着当传递一个变量（包括指针）给函数时，实际是传递该变量的一个副本。对于指针而言，函数接收的是指针值（即它所指向的内存地址）的一个副本，而不是指针变量本身的内存地址。因此，在函数内部修改该指针变量本身（如将其设为nil）不会影响原始指针，但通过复制的指针访问并修改其指向的数据，则会影响原始数据。理解这一点对于 Go 程序的内存模型和并发编程至关重要。

Go 语言的参数传递机制

go 语言的参数传递机制是“按值传递”（pass by value）。这意味着当您将一个变量传递给函数时，函数会接收到该变量的一个副本。这个规则适用于所有类型，包括基本类型（如 int, string, bool）、复合类型（如 struct, array）、以及引用类型（如 slice, map, channel, pointer）。

对于基本类型，其值被直接复制。例如，传递一个 int 变量，函数内部对该副本的修改不会影响原始变量。

而对于指针类型，传递的“值”是指针所存储的内存地址。函数接收到的是这个地址值的一个副本。这意味着，函数内部的指针变量与外部的原始指针变量是两个不同的变量，它们拥有各自独立的内存地址，但它们都指向同一块底层数据。

深入剖析指针的传值行为

为了更好地理解指针的传值行为，我们通过一个简化示例来观察变量地址、指针变量地址以及指针所指向的地址之间的关系。

考虑以下 Go 代码：

立即学习“go语言免费学习笔记（深入）”；

package main

import "fmt"

func byVal(q *int) {
    // 3. 进入 byVal 函数
    // q 是一个 *int 类型的变量，它是 main 函数中 p 的值（即 &i）的一个副本。
    // &q 是 q 这个变量自身的内存地址。
    // q 是 q 所存储的地址值，即它指向的内存地址。
    // *q 是 q 指向的内存地址上的值。
    fmt.Printf("3. byVal -- q %T: &q=%p q=&i=%p  *q=i=%v\n", q, &q, q, *q)

    // 通过指针 q 修改其指向的数据
    *q = 4143
    fmt.Printf("4. byVal -- q %T: &q=%p q=&i=%p  *q=i=%v\n", q, &q, q, *q)

    // 尝试将 q 设置为 nil。这只会影响 byVal 函数内部的 q 变量，
    // 因为 q 只是原始指针 p 的一个副本。
    q = nil
}

func main() {
    // 1. main 函数开始
    // i 是一个 int 变量，其值为 42。
    // &i 是 i 这个变量的内存地址。
    i := int(42)
    fmt.Printf("1. main  -- i  %T: &i=%p i=%v\n", i, &i, i)

    // 2. p 是一个指向 i 的指针。
    // p 存储的值是 i 的内存地址 (&i)。
    // &p 是 p 这个指针变量自身的内存地址。
    p := &i
    fmt.Printf("2. main  -- p %T: &p=%p p=&i=%p  *p=i=%v\n", p, &p, p, *p)

    // 调用 byVal 函数，将 p 的值（即 &i）传递给它。
    byVal(p)

    // 5. byVal 函数返回后
    // p 变量本身的地址 (&p) 没有改变。
    // p 存储的值（&i）也没有改变。
    // 但通过 byVal 函数内部的 q 指针修改了 *q，因此原始的 i 的值也随之改变。
    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=0xf840000040 i=42
2. main  -- p *int: &p=0xf8400000f0 p=&i=0xf840000040  *p=i=42
3. byVal -- q *int: &q=0xf8400000d8 q=&i=0xf840000040  *q=i=42
4. byVal -- q *int: &q=0xf8400000d8 q=&i=0xf840000040  *q=i=4143
5. main  -- p *int: &p=0xf8400000f0 p=&i=0xf840000040  *p=i=4143
6. main  -- i  int: &i=0xf840000040 i=4143

登录后复制

输出分析：

1. main -- i: 变量 i 的地址是 0xf840000040，值为 42。
2. main -- p: 指针变量 p 自身的地址是 0xf8400000f0。它存储的值是 0xf840000040，这正是 i 的地址，所以 *p 的值是 42。
3. byVal -- q: 当 byVal(p) 被调用时，p 的值（即 0xf840000040）被复制给 byVal 函数的参数 q。此时，q 这个变量自身的地址是 0xf8400000d8，它与 p 的地址 0xf8400000f0 不同。然而，q 所存储的值（即它指向的地址）仍是 0xf840000040，与 p 所存储的值相同。这意味着 p 和 q 虽然是两个不同的指针变量，但它们都指向同一个 int 变量 i。
4. byVal -- q: 在 byVal 函数内部，*q = 4143 操作通过 q 指针修改了它所指向的内存地址 0xf840000040 上的值，使其变为 4143。
5. main -- p: byVal 函数返回后，main 函数中的 p 变量依然存在于其原始地址 0xf8400000f0，并仍然指向 0xf840000040。由于 0xf840000040 上的值已被修改，所以此时 *p 的值是 4143。
6. main -- i: 最终，原始变量 i 的值也变成了 4143，这证实了通过函数内部复制的指针成功修改了外部变量。

值得注意的是，如果在 byVal 函数中执行 q = nil，这只会将 byVal 函数内部的局部变量 q 设置为 nil，而不会影响 main 函数中的 p 变量，因为它们是两个独立的变量。

解决原始疑问：Goroutine 中的指针行为

回到最初的疑问：为什么在 main 函数和 gotest goroutine 中打印同一个结构体指针 s 的地址 (&s) 会得到不同的值，但对 s 所指内容的修改却能生效？

// 原始问题中的简化示例
package main

import "runtime"

type Something struct {
    number int
    queue  chan int
}

func gotest(s *Something, done chan bool) {
    println("from gotest:")
    println(&s) // 打印的是 gotest 函数中 s 变量自身的内存地址
    for num := range s.queue {
        println(num)
        s.number = num // 修改的是 s 指向的 Something 结构体的内容
    }
    done <- true
}

func main() {
    runtime.GOMAXPROCS(4)
    s := new(Something) // s 是一个 *Something 类型的指针变量
    println(&s)         // 打印的是 main 函数中 s 变量自身的内存地址
    s.queue = make(chan int)
    done := make(chan bool)
    go gotest(s, done) // 将 main.s 的值（即 Something 结构体的地址）复制给 gotest.s
    s.queue <- 42
    close(s.queue)
    <-done
    println(&s) // 再次打印 main 函数中 s 变量自身的内存地址
    println(s.number)
}

登录后复制

输出：

怪兽AI数字人

数字人短视频创作，数字人直播，实时驱动数字人

查看详情

0x4930d4  // main 函数中 s 变量自身的地址
from gotest:
0x4974d8  // gotest 函数中 s 变量自身的地址
42
0x4930d4  // main 函数中 s 变量自身的地址 (未变)
42        // s.number 被成功修改

登录后复制

这里的关键在于区分 &s 和 s 的含义：

&s：表示变量 s 自身在内存中的地址。由于 main 函数中的 s 和 gotest 函数中的 s 是两个不同的变量（尽管它们同名且类型相同），它们各自在栈上拥有独立的内存空间，因此它们的地址 (&s) 自然不同。
s：表示变量 s 存储的值，对于指针类型，这个值就是它所指向的底层数据的内存地址。当 main.s 作为参数传递给 gotest 时，gotest.s 接收的是 main.s 所存储的那个地址值的一个副本。因此，main.s 和 gotest.s 指向的是同一块内存区域（即同一个 Something 结构体实例）。

正是因为 main.s 和 gotest.s 指向同一块 Something 结构体，所以在 gotest 中通过 s.number = num 修改 *s 的内容，在 main 函数中通过 s.number 也能看到这些改变。这完美地体现了 Go 语言“按值传递”指针的特性：指针变量本身被复制，但它们都指向同一份底层数据。

最佳实践与注意事项

为了避免混淆，在 Go 语言中处理指针和内存地址时，建议遵循以下实践：

明确区分：
- &variable: 获取 variable 本身的内存地址。
- pointer_variable: 指针变量存储的值，即它所指向的内存地址。
- *pointer_variable: 指针变量所指向的内存地址上的值。
使用 fmt 包进行打印：fmt.Printf 提供了更强大和清晰的格式化输出能力。
- 打印指针变量的值（它指向的地址）：fmt.Printf("%p", ptrVar)
- 打印变量本身的地址：fmt.Printf("%p", &varName)
- 打印结构体或复杂类型的值：fmt.Printf("%v", structVar) 或 fmt.Printf("%+v", structVar) (包含字段名)
例如，对于上述 Something 结构体，你可以这样打印：
```
// 在 main 或 gotest 中
fmt.Printf("s 变量自身的地址: %p\n", &s)
fmt.Printf("s 指向的 Something 结构体的地址: %p\n", s)
fmt.Printf("s 指向的 Something 结构体内容: %+v\n", *s)
```
登录后复制
理解引用类型： 尽管 slice, map, channel 等是引用类型，但它们作为函数参数时，其头部或描述符仍然是按值传递的。这意味着你可以在函数内部修改 slice 的元素，或者向 map/channel 中添加/发送数据，因为这些操作都是通过其内部指向底层数据的指针完成的。但如果你尝试在函数内部重新分配一个全新的 slice 或 map（例如 s = make([]int, 0)），这只会影响函数内部的副本，而不会影响原始变量。