Golang中指针变量赋值时，若修改其指向的值（*p = val），则地址不变；若给指针重新赋地址（p = &b），则其存储的地址改变。核心在于区分指针自身地址与所指地址。
Golang中指针变量的赋值，其内存地址的变化取决于你操作的对象：如果你是修改指针所指向的值，那么指针变量本身存储的地址不变；如果你是给指针变量赋一个新的地址，那么指针变量存储的地址就变了。这听起来有点绕，但核心在于区分“指针变量自身存储的地址”和“该地址指向的数据”。
在Go语言中，指针是一个非常基础但又容易让人混淆的概念。说实话，刚开始接触Go的指针时，我也绕了点弯子，总觉得它和C/C++的指针有点像，但又有些微妙的不同。理解指针变量的赋值与内存地址的变化，是掌握Go内存模型和编写高效代码的关键。
Go语言中的指针，本质上就是一个存储另一个变量内存地址的变量。我们用
&
操作符来获取变量的地址，用
*
操作符来解引用（dereference），也就是访问或修改该地址处的值。
让我们来看一个例子：
立即学习“go语言免费学习笔记（深入）”；
package mainimport "fmt"func main() { var a int = 10 var p *int = &a // p现在存储了变量a的内存地址 fmt.Printf("初始状态：\n") fmt.Printf("a 的值：%d，a 的地址：%p\n", a, &a) fmt.Printf("p 的值（即a的地址）：%p，p 自身的地址：%p\n", p, &p) // 场景一：通过指针修改所指向的值 fmt.Printf("\n场景一：通过指针修改所指向的值 (*p = 20)\n") *p = 20 // 修改p所指向的内存地址中的值 fmt.Printf("修改后：\n") fmt.Printf("a 的值：%d，a 的地址：%p\n", a, &a) // a的值变了 fmt.Printf("p 的值（即a的地址）：%p，p 自身的地址：%p\n", p, &p) // p存储的地址没变 // 场景二：给指针变量赋一个新的地址 fmt.Printf("\n场景二：给指针变量赋一个新的地址 (p = &b)\n") var b int = 30 p = &b // p现在存储了变量b的内存地址 fmt.Printf("重新赋值后：\n") fmt.Printf("a 的值：%d，a 的地址：%p\n", a, &a) // a的值和地址都没变 fmt.Printf("b 的值：%d，b 的地址：%p\n", b, &b) fmt.Printf("p 的值（即b的地址）：%p，p 自身的地址：%p\n", p, &p) // p存储的地址变了}
从上面的输出你可以清楚地看到：
当我们执行
*p = 20
时，我们是在操作
p
所指向的那个内存位置上的数据。因此，
a
的值从10变成了20，但
a
的内存地址以及
p
变量自身存储的地址（也就是
a
的地址）都没有改变。当我们执行
p = &b
时，我们是直接修改了
p
这个变量本身存储的内容。
p
原本存储着
a
的地址，现在它存储了
b
的地址。这时，
p
变量自身存储的地址（
&p
）依然不变，但
p
的值（它所指向的地址）却从
&a
变成了
&b
。
理解这个区分是至关重要的。指针变量本身也是一个变量，它有自己的内存地址，并存储着另一个变量的内存地址。对其解引用操作是去修改它指向的数据，而直接对指针变量进行赋值，则是改变它指向哪里。
Golang中，指针变量的赋值究竟改变了什么？是值还是地址？
这确实是初学者最容易混淆的地方。简单来说，指针变量的赋值操作可以分为两种，它们改变的东西是不同的：
改变指针所指向的“值”： 当你使用解引用操作符
*
，例如
*ptr = newValue
时，你实际上是在访问
ptr
所存储的内存地址，并将
newValue
写入到那个内存地址中。
改变了什么？ 改变了
ptr
所指向的那个变量的值。什么没变？
ptr
这个指针变量本身存储的地址（即它指向哪里）没有改变，
ptr
自身的内存地址（
&ptr
）也没有改变。它就像你拿着一把钥匙去打开某个抽屉，然后往抽屉里放东西，钥匙本身还是那把钥匙，抽屉的位置也没变。
package mainimport "fmt"func main() { x := 10 ptr := &x // ptr指向x fmt.Printf("修改前：x=%d, ptr指向%p, ptr自身地址%p\n", x, ptr, &ptr) *ptr = 20 // 通过ptr修改x的值 fmt.Printf("修改后：x=%d, ptr指向%p, ptr自身地址%p\n", x, ptr, &ptr)}
输出会显示
x
的值从10变为20，但
ptr
所指向的地址以及
ptr
自身的地址都保持不变。
改变指针变量本身存储的“地址”： 当你直接给指针变量赋值，例如
ptr = &anotherVar
时，你是在改变
ptr
这个变量自身存储的内容。
ptr
现在不再指向之前的变量，而是指向了
anotherVar
。
改变了什么？ 改变了
ptr
这个指针变量存储的地址（即它现在指向哪里）。什么没变？
ptr
这个指针变量自身的内存地址（
&ptr
）没有改变。它就像你把钥匙串上的钥匙换成了另一把，钥匙串（
&ptr
）还在你手上，但你现在拿着的钥匙（
ptr
的值）已经不同了，它能打开另一个抽屉。
package mainimport "fmt"func main() { x := 10 y := 30 ptr := &x // ptr最初指向x fmt.Printf("修改前：x=%d, y=%d, ptr指向%p, ptr自身地址%p\n", x, y, ptr, &ptr) ptr = &y // 让ptr指向y fmt.Printf("修改后：x=%d, y=%d, ptr指向%p, ptr自身地址%p\n", x, y, ptr, &ptr)}
输出会显示
ptr
所指向的地址从
&x
变为
&y
，但
ptr
自身的地址仍然不变。
所以，核心在于理解指针变量和它所指向的数据是两个独立的概念。
理解Go语言中的“传值”与“传指针”：对函数参数的影响
Go语言的函数参数传递机制，一直是“传值”的。这一点非常重要，即使你传递的是一个指针，传递的也仅仅是这个指针变量的一个“副本”（值）。
当我们将一个变量传递给函数时，Go会创建一个该变量的副本，并在函数内部使用这个副本。这意味着，在函数内部对副本的修改，不会影响到原始变量。
package mainimport "fmt"func modifyValue(val int) { val = 200 // 这里的val是原始变量的副本 fmt.Printf("在函数内部 (modifyValue): val=%d, val的地址=%p\n", val, &val)}func main() { num := 100 fmt.Printf("调用前 (main): num=%d, num的地址=%p\n", num, &num) modifyValue(num) fmt.Printf("调用后 (main): num=%d, num的地址=%p\n", num, &num)}
你会发现
main
函数中的
num
值没有改变，因为
modifyValue
操作的是
num
的一个副本。
那么，当我们传递一个指针时会发生什么呢？Go仍然是“传值”的，只不过这次传递的“值”是那个指针变量本身存储的内存地址。函数会得到这个地址的一个副本。
package mainimport "fmt"func modifyPointerValue(ptr *int) { // ptr是main函数中p的一个副本，它存储了相同的地址 fmt.Printf("在函数内部 (modifyPointerValue): ptr指向%p, ptr自身地址%p\n", ptr, &ptr) *ptr = 200 // 通过副本指针修改它所指向的内存地址中的值}func reassignPointer(ptr *int) { // 这里的ptr也是原始指针的一个副本 var temp int = 500 ptr = &temp // 重新赋值这个副本指针，让它指向一个新的地址 fmt.Printf("在函数内部 (reassignPointer): ptr指向%p, ptr自身地址%p\n", ptr, &ptr)}func main() { num := 100 p := &num // p指向num fmt.Printf("调用前 (main): num=%d, p指向%p, p自身地址%p\n", num, p, &p) // 场景一：函数通过指针副本修改原始数据 modifyPointerValue(p) fmt.Printf("调用 modifyPointerValue 后 (main): num=%d, p指向%p, p自身地址%p\n", num, p, &p) // 此时，num的值变了，但p所指向的地址没变，p自身的地址也没变 // 场景二：函数尝试重新赋值原始指针（但只能改变副本） reassignPointer(p) fmt.Printf("调用 reassignPointer 后 (main): num=%d, p指向%p, p自身地址%p\n", num, p, &p) // 此时，num的值和p所指向的地址都保持不变，因为reassignPointer只改变了它内部的指针副本}
输出会清晰地显示：
modifyPointerValue
函数能够成功修改
main
函数中
num
的值，因为虽然它拿到的是
p
的副本，但这个副本指向的内存地址和
p
指向的内存地址是一样的。
reassignPointer
函数内部虽然将
ptr
重新指向了
temp
，但这个改变只发生在函数内部，
main
函数中的
p
变量依然指向
num
。因为
reassignPointer
操作的也是
p
的一个副本。
总结来说，当你需要函数修改外部变量的值时，就应该传递该变量的指针。但如果你想让函数改变外部指针变量的指向（例如，让
main
函数中的
p
从指向
num
变为指向
anotherNum
），那么你需要返回一个新的指针，或者传递一个指向指针的指针（
**int
），但后者在Go中并不常见，通常通过返回值来处理这种需求。
Golang指针在性能优化和内存管理中的实际应用考量
在Go语言中，指针的使用不仅仅是为了修改外部变量，它在性能优化和内存管理方面也有其独特的考量，但又不像C/C++那样需要处处小心翼翼。
避免大对象拷贝： 当你有一个非常大的结构体（struct）实例作为函数参数时，如果直接按值传递，Go会复制整个结构体。这可能导致性能开销和额外的内存分配。在这种情况下，传递结构体的指针可以避免这种拷贝，只传递一个指针大小的地址（通常是8字节），从而提高效率。
package mainimport ( "fmt" "time")type BigStruct struct { Data [1024 * 1024]byte // 1MB大小的数据 ID int}// 按值传递func processByValue(s BigStruct) { s.ID = 1 // 修改副本 // fmt.Printf("ByValue: %p\n", &s)}// 按指针传递func processByPointer(s *BigStruct) { s.ID = 2 // 修改原始数据 // fmt.Printf("ByPointer: %p\n", s)}func main() { bigObj := BigStruct{ID: 0} start := time.Now() processByValue(bigObj) fmt.Printf("ByValue cost: %v, ID: %d\n", time.Since(start), bigObj.ID) // ID未变，因为修改的是副本 start = time.Now() processByPointer(&bigObj) fmt.Printf("ByPointer cost: %v, ID: %d\n", time.Since(start), bigObj.ID) // ID变了，因为修改的是原始数据}
对于非常大的结构体，按指针传递通常会更快，因为避免了内存复制。不过，Go的编译器（通过逃逸分析）在某些情况下会优化小结构体的按值传递，使其效率很高，所以并非所有结构体都需要传递指针。
实现链式数据结构： 链表、树、图等需要节点之间相互引用的数据结构，天然就需要使用指针来实现。每个节点都包含指向下一个（或多个）节点的指针。
type Node struct { Value int Next *Node // 指向下一个Node的指针}
与C代码交互（cgo）： 当Go程序需要调用C语言库时，经常需要使用
unsafe.Pointer
来在Go和C之间传递内存地址，这涉及到更底层的指针操作。不过这属于特殊场景，日常开发中并不常用。
内存管理与垃圾回收（GC）： Go的垃圾回收器会自动管理内存，你不需要像C/C++那样手动
malloc
和
free
。然而，指针的存在意味着GC需要追踪所有可达的内存对象。一个被指针引用的对象，即使在逻辑上不再需要，只要还有指针指向它，GC就不会回收它。这可能导致内存泄漏（虽然不是传统意义上的内存泄漏，更像是“逻辑上的内存泄漏”），所以在使用指针时，要确保不再需要的引用及时被清除（例如，将指针设为
nil
）。
另一方面，Go的逃逸分析（Escape Analysis）是一个非常智能的机制。它会分析变量的生命周期，如果一个局部变量的地址被传递到函数外部，或者被一个全局变量引用，那么这个局部变量就会“逃逸”到堆上分配内存，即使你没有显式地使用
new
或
make
。这在某种程度上减轻了开发者手动管理内存的负担，但也意味着你可能在不知不觉中创建了堆分配，而堆分配通常比栈分配慢。
总的来说，在Go中，指针是一个强大的工具，但我们应该有意识地去使用它。大多数时候，Go的“传值”语义已经足够好，并且通过编译器优化，性能也很好。只有当你确实需要修改原始数据、避免大对象拷贝或构建复杂数据结构时，才应该考虑使用指针。过度使用指针，反而可能增加代码的复杂性，并引入
nil
指针解引用等潜在问题。
以上就是Golang指针变量赋值与内存地址变化解析的详细内容，更多请关注创想鸟其它相关文章！
版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。
如发现本站有涉嫌抄袭侵权/违法违规的内容， 请发送邮件至 chuangxiangniao@163.com 举报，一经查实，本站将立刻删除。
发布者：程序猿，转转请注明出处：https://www.chuangxiangniao.com/p/1404021.html
微信扫一扫 
支付宝扫一扫 
