Go语言中，所有函数参数都是按值传递的。这意味着当传递一个变量（包括指针）给函数时，实际是传递该变量的一个副本。对于指针而言，函数接收的是指针值（即它所指向的内存地址）的一个副本，而不是指针变量本身的内存地址。因此，在函数内部修改该指针变量本身（如将其设为nil）不会影响原始指针，但通过复制的指针访问并修改其指向的数据，则会影响原始数据。理解这一点对于 Go 程序的内存模型和并发编程至关重要。
Go 语言的参数传递机制
go 语言的参数传递机制是“按值传递”（pass by value）。这意味着当您将一个变量传递给函数时，函数会接收到该变量的一个副本。这个规则适用于所有类型，包括基本类型（如 int, string, bool）、复合类型（如 struct, array）、以及引用类型（如 slice, map, channel, pointer）。
对于基本类型，其值被直接复制。例如，传递一个 int 变量，函数内部对该副本的修改不会影响原始变量。
而对于指针类型，传递的“值”是指针所存储的内存地址。函数接收到的是这个地址值的一个副本。这意味着，函数内部的指针变量与外部的原始指针变量是两个不同的变量，它们拥有各自独立的内存地址，但它们都指向同一块底层数据。
深入剖析指针的传值行为
为了更好地理解指针的传值行为，我们通过一个简化示例来观察变量地址、指针变量地址以及指针所指向的地址之间的关系。
考虑以下 Go 代码：
立即学习“go语言免费学习笔记（深入）”；
package mainimport "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=%vn", q, &q, q, *q) // 通过指针 q 修改其指向的数据 *q = 4143 fmt.Printf("4. byVal -- q %T: &q=%p q=&i=%p *q=i=%vn", 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=%vn", 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=%vn", 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=%vn", p, &p, p, *p) // 6. 再次查看 i 的值。 fmt.Printf("6. main -- i %T: &i=%p i=%vn", i, &i, i)}
运行上述代码，您会得到类似如下的输出（内存地址可能不同）：
1. main -- i int: &i=0xf840000040 i=422. main -- p *int: &p=0xf8400000f0 p=&i=0xf840000040 *p=i=423. byVal -- q *int: &q=0xf8400000d8 q=&i=0xf840000040 *q=i=424. byVal -- q *int: &q=0xf8400000d8 q=&i=0xf840000040 *q=i=41435. main -- p *int: &p=0xf8400000f0 p=&i=0xf840000040 *p=i=41436. 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 mainimport "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)}
输出：
0x4930d4 // main 函数中 s 变量自身的地址from gotest:0x4974d8 // gotest 函数中 s 变量自身的地址420x4930d4 // 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 变量自身的地址: %pn", &s)fmt.Printf("s 指向的 Something 结构体的地址: %pn", s)fmt.Printf("s 指向的 Something 结构体内容: %+vn", *s)
理解引用类型： 尽管 slice, map, channel 等是引用类型，但它们作为函数参数时，其头部或描述符仍然是按值传递的。这意味着你可以在函数内部修改 slice 的元素，或者向 map/channel 中添加/发送数据，因为这些操作都是通过其内部指向底层数据的指针完成的。但如果你尝试在函数内部重新分配一个全新的 slice 或 map（例如 s = make([]int, 0)），这只会影响函数内部的副本，而不会影响原始变量。
总结
Go 语言严格遵循按值传递的原则。当一个指针作为函数参数传递时，实际传递的是该指针变量存储的内存地址值的一个副本。这意味着：
函数内部的指针变量与外部的原始指针变量是两个独立的内存实体，它们的内存地址（&ptr）不同。然而，它们都存储着相同的内存地址值（ptr），因此它们都指向同一块底层数据。通过函数内部复制的指针修改底层数据，会影响到原始数据，因为它们共享同一份数据。在函数内部对指针变量本身进行赋值操作（如 ptr = nil 或 ptr = &anotherVar）只会影响函数内部的副本，不会影响外部的原始指针。
清晰地理解这些概念是编写高效、正确 Go 程序的基石，尤其是在处理并发和共享数据时。
以上就是深入理解Go语言函数参数传递：值、指针与内存地址的详细内容，更多请关注创想鸟其它相关文章！
版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。
如发现本站有涉嫌抄袭侵权/违法违规的内容， 请发送邮件至 chuangxiangniao@163.com 举报，一经查实，本站将立刻删除。
发布者：程序猿，转转请注明出处：https://www.chuangxiangniao.com/p/1396184.html
微信扫一扫 
支付宝扫一扫 
