Go语言的参数传递机制
go语言在参数传递方面遵循严格的“值传递”原则。这意味着无论你传递的是基本类型（如int、string）还是复杂类型（如结构体struct、切片slice、映射map、通道channel），函数接收到的都是参数值的一个副本。
对于指针类型，其“值”就是它所指向的内存地址。因此，当你将一个指针变量传递给函数时，实际上是复制了该指针变量所存储的内存地址。函数内部的形参会拥有这个地址的副本，但形参本身是一个独立的变量，位于不同的内存地址。
指针、地址与变量：&s, s, *s 的辨析
理解Go语言中指针的关键在于区分以下三个概念：
- &s (地址的地址)： 表示变量s本身的内存地址。如果s是一个指针变量，那么&s就是存储这个指针变量的内存位置。
- s (指针的值)： 如果s是一个指针变量，s的值就是它所指向的那个数据的内存地址。
- *`s(指针指向的值)：** 表示指针s`所指向的内存地址中存储的实际数据。
在函数调用中，当我们将一个指针变量p传递给函数时，函数形参q会得到p的值（即p所指向的内存地址）的一个副本。这意味着p和q虽然指向同一个底层数据，但它们自身是两个独立的变量，位于不同的内存地址。因此：
- &p 和 &q 会是不同的地址（因为它们是两个不同的变量）。
- p 和 q 的值会是相同的（因为它们都存储了同一个底层数据的地址）。
- *p 和 *q 会是相同的（因为它们都指向并访问同一个底层数据）。
示例解析：理解指针传递的本质
为了更清晰地说明这一点，我们来看一个简化的示例代码：
立即学习“go语言免费学习笔记（深入）”；
package main
import "fmt"
func byVal(q *int) {
// 3. 在 byVal 函数内部
// q 是形参，其地址 (&q) 与 main 函数中的 p 的地址 (&p) 不同
// q 的值 (q) 与 main 函数中的 p 的值 (p) 相同，都指向 i 的地址
// *q 的值 (*q) 与 main 函数中的 *p 的值 (*p) 相同，都是 i 的值
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，这只会影响 q 这个局部变量，不会影响 main 函数中的 p
q = nil
}
func main() {
i := int(42) // i 是一个 int 变量
fmt.Printf("1. main -- i %T: &i=%p i=%v\n", i, &i, i)
p := &i // p 是一个指向 int 变量 i 的指针
fmt.Printf("2. main -- p %T: &p=%p p=&i=%p *p=i=%v\n", p, &p, p, *p)
byVal(p) // 将指针 p 的值（即 i 的地址）传递给 byVal 函数
// 5. 从 byVal 函数返回后
// p 的地址 (&p) 不变
// p 的值 (p) 不变，仍然指向 i 的地址
// *p 的值 (*p) 已被 byVal 函数修改
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=0xc000014088 i=42 2. main -- p *int: &p=0xc000006028 p=&i=0xc000014088 *p=i=42 3. byVal -- q *int: &q=0xc000006030 q=&i=0xc000014088 *q=i=42 4. byVal -- q *int: &q=0xc000006030 q=&i=0xc000014088 *q=i=4143 5. main -- p *int: &p=0xc000006028 p=&i=0xc000014088 *p=i=4143 6. main -- i int: &i=0xc000014088 i=4143
输出解读：
- 步骤1和2： main函数中，i是一个int变量，p是一个指向i的指针。注意&i和&p是不同的内存地址，因为它们是两个独立的变量。p的值就是&i。
- 步骤3和4： 当调用byVal(p)时，p的值（即0xc000014088）被复制给形参q。因此，q的值也是0xc000014088，这意味着q和p都指向i。然而，q自身作为一个局部变量，其内存地址&q (0xc000006030) 与&p (0xc000006028) 是不同的。在byVal函数中，通过*q = 4143成功修改了i的值。
- 步骤5和6： byVal函数返回后，main函数中的p变量并未受byVal函数中q = nil操作的影响，p的地址和值保持不变。但由于*q修改了i，所以*p和i的值都变成了4143。
这清晰地表明，byVal函数操作的是q（p的副本），但通过q指向的地址，成功修改了main函数中p所指向的原始数据i。
原始问题中的println(&s)困惑
回到原始问题中的代码，main函数和gotest协程中都存在一个名为s的变量。
package main
import ( "runtime" )
type Something struct {
number int
queue chan int
}
func gotest( s *Something, done chan bool ) { // 这里的 s 是 gotest 的形参
println( "from gotest:")
println( &s ) // 打印的是 gotest 局部变量 s 的地址
for num := range s.queue {
println( num )
s.number = num // 修改的是 main 函数中 s 所指向的 Something 对象的 number 字段
}
done <- true
}
func main() {
runtime.GOMAXPROCS(4)
s := new(Something) // 这里的 s 是 main 函数的局部变量
println(&s) // 打印的是 main 局部变量 s 的地址
s.queue = make(chan int)
done := make(chan bool)
go gotest(s, done) // 将 main 函数中 s 的值（即 Something 对象的地址）传递给 gotest
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
这里的关键在于：
- main函数中的s是一个*Something类型的局部变量，其地址是0x4930d4。
- gotest函数中的s是另一个*Something类型的局部形参，其地址是0x4974d8。
- 当main调用go gotest(s, done)时，main函数中s的值（即new(Something)创建的Something对象的内存地址）被复制并传递给gotest的形参s。
- 所以，虽然main的s和gotest的s是两个不同内存地址的变量（0x4930d4 vs 0x4974d8），但它们的值是相同的，都指向同一个Something对象。
- 因此，gotest函数内部通过s.number = num修改的是同一个Something对象的number字段，所以在main函数中也能看到s.number被修改了。
println(&s)打印的是指针变量s本身的内存地址，而不是它所指向的对象的地址。由于main和gotest中的s是不同的变量（即使同名），它们有不同的内存地址，所以打印出来的值不同是完全符合预期的。
最佳实践与注意事项
-
避免使用println打印地址： println在打印指针时可能会有不一致的行为或输出格式不明确。推荐使用fmt包进行格式化输出，尤其是fmt.Printf结合%p动词，它专门用于打印指针的值（即它所指向的地址）。
- 例如：fmt.Printf("变量s的地址: %p, s指向的地址: %p, s指向的值: %v\n", &s, s, *s)
- 明确变量的含义： 始终清楚地区分变量的“地址”（&variable）、“值”（variable）以及“指针所指向的值”（*pointer）。
- 理解Go的“值传递”： 记住Go总是按值传递。即使是传递一个指针，也是指针的值（即地址）被复制。这允许函数通过复制的指针修改原始数据，但不能改变原始指针变量本身。
- 变量作用域： 函数参数是局部变量，它们有自己的作用域和内存空间。即使与外部变量同名，它们也是独立的。
总结
Go语言的参数传递机制是纯粹的“值传递”。对于指针类型，传递的是指针变量存储的内存地址副本。这意味着函数内部的形参会拥有与实参相同的指针值（指向相同的底层数据），但形参自身是一个独立的变量，有其独立的内存地址。因此，在函数内部对形参指针进行赋值（如q = nil）不会影响到函数外部的原始指针变量，但通过解引用形参指针来修改其指向的底层数据，则会影响到原始数据。正确理解&variable、variable和*pointer之间的区别，以及善用fmt.Printf进行调试，是掌握Go语言指针和内存管理的关键。
