Golang中指针变量赋值时，若修改其指向的值（*p = val），则地址不变；若给指针重新赋地址（p = &b），则其存储的地址改变。核心在于区分指针自身地址与所指地址。
Golang中指针变量的赋值，其内存地址的变化取决于你操作的对象：如果你是修改指针所指向的值，那么指针变量本身存储的地址不变；如果你是给指针变量赋一个新的地址，那么指针变量存储的地址就变了。这听起来有点绕，但核心在于区分“指针变量自身存储的地址”和“该地址指向的数据”。
在Go语言中，指针是一个非常基础但又容易让人混淆的概念。说实话，刚开始接触Go的指针时，我也绕了点弯子，总觉得它和C/C++的指针有点像，但又有些微妙的不同。理解指针变量的赋值与内存地址的变化，是掌握Go内存模型和编写高效代码的关键。
Go语言中的指针，本质上就是一个存储另一个变量内存地址的变量。我们用
&操作符来获取变量的地址，用
*操作符来解引用（dereference），也就是访问或修改该地址处的值。
让我们来看一个例子：
立即学习“go语言免费学习笔记（深入）”；
package main
import "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 main import "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 main import "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 main
import "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 main
import "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 main import ( "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指针解引用等潜在问题。
