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)
}输出：
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)），这只会影响函数内部的副本，而不会影响原始变量。
总结
Go 语言严格遵循按值传递的原则。当一个指针作为函数参数传递时，实际传递的是该指针变量存储的内存地址值的一个副本。这意味着：
- 函数内部的指针变量与外部的原始指针变量是两个独立的内存实体，它们的内存地址（&ptr）不同。
- 然而，它们都存储着相同的内存地址值（ptr），因此它们都指向同一块底层数据。
- 通过函数内部复制的指针修改底层数据，会影响到原始数据，因为它们共享同一份数据。
- 在函数内部对指针变量本身进行赋值操作（如 ptr = nil 或 ptr = &anotherVar）只会影响函数内部的副本，不会影响外部的原始指针。
清晰地理解这些概念是编写高效、正确 Go 程序的基石，尤其是在处理并发和共享数据时。
