Go语言中所有函数参数都是按值传递的。这意味着当一个变量（包括指针）作为参数传递给函数时，其值会被复制一份。对于指针而言，复制的是指针变量本身存储的内存地址，而非指针变量自身的地址。因此，在函数内部对复制的指针变量进行修改（例如将其设为nil）不会影响到函数外部的原始指针变量，但通过复制的指针可以修改其所指向的底层数据。
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 mainimport "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=%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，这只会影响 q 这个局部变量，不会影响 main 函数中的 p q = nil}func main() { i := int(42) // i 是一个 int 变量 fmt.Printf("1. main -- i %T: &i=%p i=%vn", i, &i, i) p := &i // p 是一个指向 int 变量 i 的指针 fmt.Printf("2. main -- p %T: &p=%p p=&i=%p *p=i=%vn", 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=%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=0xc000014088 i=422. main -- p *int: &p=0xc000006028 p=&i=0xc000014088 *p=i=423. byVal -- q *int: &q=0xc000006030 q=&i=0xc000014088 *q=i=424. byVal -- q *int: &q=0xc000006030 q=&i=0xc000014088 *q=i=41435. main -- p *int: &p=0xc000006028 p=&i=0xc000014088 *p=i=41436. 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 mainimport ( "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 的地址420x4930d4 // 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指向的值: %vn”, &s, s, *s)明确变量的含义： 始终清楚地区分变量的“地址”（&variable）、“值”（variable）以及“指针所指向的值”（*pointer）。理解Go的“值传递”： 记住Go总是按值传递。即使是传递一个指针，也是指针的值（即地址）被复制。这允许函数通过复制的指针修改原始数据，但不能改变原始指针变量本身。变量作用域： 函数参数是局部变量，它们有自己的作用域和内存空间。即使与外部变量同名，它们也是独立的。
总结
Go语言的参数传递机制是纯粹的“值传递”。对于指针类型，传递的是指针变量存储的内存地址副本。这意味着函数内部的形参会拥有与实参相同的指针值（指向相同的底层数据），但形参自身是一个独立的变量，有其独立的内存地址。因此，在函数内部对形参指针进行赋值（如q = nil）不会影响到函数外部的原始指针变量，但通过解引用形参指针来修改其指向的底层数据，则会影响到原始数据。正确理解&variable、variable和*pointer之间的区别，以及善用fmt.Printf进行调试，是掌握Go语言指针和内存管理的关键。
以上就是深入理解Go语言中的指针与值传递：内存地址的奥秘的详细内容，更多请关注创想鸟其它相关文章！
版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。
如发现本站有涉嫌抄袭侵权/违法违规的内容， 请发送邮件至 chuangxiangniao@163.com 举报，一经查实，本站将立刻删除。
发布者：程序猿，转转请注明出处：https://www.chuangxiangniao.com/p/1396182.html
微信扫一扫 
支付宝扫一扫 
