Golang中的指针是安全的内存引用机制，用于共享数据、提升性能、构建复杂数据结构及表示“无值”状态；通过&取地址、*解引用操作，结合new函数或取现有变量地址进行初始化，需避免nil解引用等陷阱；在函数参数中传递指针可修改原值，在方法接收器中使用指针可改变对象状态，提升效率并确保一致性。
Golang中的指针，在我看来，它更像是一种“直接与内存对话”的工具。它不是C/C++那种需要小心翼翼把玩的危险品，而是在Go语言设计哲学下，被驯化得更加安全、也更具目的性的机制。简单来说，指针就是存储另一个变量内存地址的变量。通过它，我们能够直接访问并修改那个被指向的变量，这在很多场景下，比如函数间共享数据、优化大对象传递性能，以及构建链表这类数据结构时，都显得不可或缺。
解决方案
理解Golang指针的核心，无非是掌握两个关键操作：获取内存地址（
&
操作符）和通过地址取值（
*
操作符）。
我们都知道，Go语言在函数参数传递上，默认是“值传递”。这意味着当你把一个变量传给函数时，函数拿到的是这个变量的一个副本。如果想让函数修改原变量，而不是副本，指针就派上用场了。你可以把变量的地址传进去，函数通过这个地址找到原变量，然后直接操作它。
具体来说，定义一个指针变量，你需要指定它将指向什么类型的数据。比如
var p *int
就声明了一个指向整数的指针。但此时
p
的值是
nil
，它还没有指向任何有效的内存地址。要让它指向一个变量，我们用
&
操作符。例如，
x := 10; p = &x
，现在
p
就存储了变量
x
的内存地址。
立即学习“go语言免费学习笔记（深入）”；
而当我们需要访问或修改
p
所指向的
x
的值时，就用到
*
操作符，也就是“解引用”。
fmt.Println(*p)
会打印出
10
。如果你执行
*p = 20
，那么变量
x
的值也会随之变为
20
。这个过程，其实就是通过指针变量里存的地址，找到那块内存，然后读写那块内存里的数据。
还有一种创建指针的方式是使用内置的
new
函数，比如
p := new(int)
。
new
函数会为指定类型分配内存，并将其初始化为零值（对于
int
是
0
），然后返回这个内存地址的指针。这和
var x int; p := &x
的效果在某种程度上是相似的，只是
new
直接分配了内存，而
&
是取现有变量的地址。
Golang中指针存在的意义是什么？它解决了哪些实际编程痛点？
说实话，初学Go时，我一度觉得指针这东西是不是有点多余，毕竟Go已经对内存管理做了很多抽象。但随着项目深入，我发现指针在Go的设计哲学中扮演着一个微妙但至关重要的角色，它并非为了提供C/C++那种底层控制力，更多是为了解决Go语言自身的一些设计限制和效率考量。
首先，最直接的痛点就是“函数间共享和修改数据”。Go是纯粹的值传递，这意味着如果你想让一个函数修改传入的某个变量（而不是它的副本），你就必须传递这个变量的地址。比如，我们经常会写一个函数来处理一个结构体，如果这个函数需要更新结构体内部的状态，那么接收一个结构体指针作为参数就成了标准做法。否则，函数操作的只是结构体的拷贝，改了也白改。
其次，处理大型数据结构时的性能优化。想象一下你有一个包含大量字段的结构体，如果每次函数调用都复制这个结构体，那么内存开销和复制时间都会显著增加。传递一个指向这个结构体的指针，就只需要复制一个内存地址（通常是8字节），效率高得多。这对于像数据库连接池、缓存对象等需要频繁传递和操作的大型资源尤其重要。
再者，实现某些特定的数据结构。链表、树、图这些经典的数据结构，它们的核心就是通过节点之间的“引用”来连接。在Go中，这个“引用”就是通过指针来实现的。每个节点存储下一个（或多个）节点的内存地址，这样才能构建起复杂的相互关联的数据模型。
最后，区分“有值”和“无值”。在Go中，基本类型（如
int
,
string
）的零值是确定的，但有时我们需要表达“这个字段可能存在，也可能不存在”的概念，而不是一个默认的零值。比如一个JSON字段，如果它缺失，我们不希望它被序列化为
0
或
""
。这时，使用指向基本类型的指针就很有用，
nil
指针可以明确表示“无值”，而指向有效内存的指针则表示“有值”。
如何安全地声明、初始化并操作Golang指针？有哪些常见的陷阱需要避免？
在Go中使用指针，虽然比C/C++安全得多，但依然有一些最佳实践和需要警惕的陷阱。
声明与初始化：声明指针很简单，
var p *int
。关键在于初始化。
指向现有变量： 这是最常见的，
x := 10; p := &x
。此时
p
指向
x
的内存地址。使用
new()
函数：
p := new(int)
。
new
会分配一块内存，将值初始化为类型的零值（
int
为
0
），并返回这块内存的地址。这块内存是匿名的，你只能通过
p
来访问它。结构体字面量： 对于结构体，你可以直接创建并取地址：
s := &MyStruct{Field: "value"}
。这实际上是先创建了一个
MyStruct
的实例，然后取其地址。
安全操作：最重要的安全规则就是“解引用前务必检查
nil
”。如果一个指针是
nil
，意味着它没有指向任何有效的内存地址，此时尝试解引用（
*p
）会导致运行时
panic
。所以，
if p != nil { *p = 20 }
这样的检查是必不可少的。
Go中没有指针算术，这是Go设计者为了避免C/C++中常见的越界访问和内存腐败问题而做出的重要决策。你不能像C语言那样对指针进行加减操作来访问相邻内存。这极大地提升了内存操作的安全性，但也意味着你不能用指针来遍历数组等。
变量的生命周期：Go的垃圾回收机制（GC）会自动管理内存，你不需要手动释放指针指向的内存。只要有活跃的指针引用着一块内存，GC就不会回收它。当没有任何指针再引用那块内存时，GC会在合适的时机将其回收。这大大降低了内存泄漏和悬垂指针的风险。
常见陷阱：
nil
指针解引用： 这是最常见的错误，前面已经强调过。函数返回局部变量的地址： 这在C/C++中是灾难性的，因为局部变量在函数返回后就可能被销毁。但在Go中，由于GC的存在，编译器会进行“逃逸分析”（escape analysis），如果发现局部变量的地址被返回或赋值给外部变量，它会自动将这个局部变量分配到堆上，而不是栈上，从而保证其生命周期。所以，
func createInt() *int { x := 10; return &x }
这样的代码在Go中是安全的，但理解其背后的机制很重要。误解值传递与指针传递： 再次强调，Go是值传递。如果你传递一个指针，你传递的是指针的副本。你可以通过这个副本指针修改它指向的内存，但你不能修改这个副本指针本身，让它指向别的内存（除非你把它作为返回值）。
指针在函数参数传递和方法接收器中的应用有何不同？
指针在函数参数和方法接收器中的应用，虽然核心思想都是为了实现对原数据的修改，但在语义和使用场景上，确实存在一些细微但重要的区别。
函数参数传递中的指针：当我们将一个变量的指针作为函数参数传递时，函数内部得到的是这个指针的一个副本。这意味着函数可以通过这个副本指针去访问并修改原始变量的值。
func modifyValue(val int) { val = 20 // 只能修改val的副本}func modifyPointer(ptr *int) { *ptr = 20 // 通过指针修改原始变量的值}func main() { a := 10 modifyValue(a) fmt.Println(a) // 输出 10 b := 10 modifyPointer(&b) fmt.Println(b) // 输出 20}
这里很清晰，
modifyValue
函数无法改变
main
函数中的
a
，因为它操作的是
a
的一个独立拷贝。而
modifyPointer
通过接收
b
的地址，成功地修改了
b
的值。这种方式主要用于实现函数对外部变量的“副作用”，或者为了避免大对象的复制开销。
方法接收器中的指针：在Go中，方法是绑定到特定类型上的函数。方法的接收器（receiver）可以是值类型，也可以是指针类型。这两种选择对方法的行为有着根本性的影响。
值接收器 (
func (s MyStruct) MyMethod()
)：当使用值接收器时，方法操作的是接收器的一个副本。这意味着在方法内部对接收器状态的任何修改，都不会反映到调用者那里。
type Counter struct { count int}func (c Counter) IncrementValue() { c.count++ // 修改的是c的副本 fmt.Printf("IncrementValue: 内部count = %dn", c.count)}func main() { myCounter := Counter{count: 0} myCounter.IncrementValue() fmt.Printf("main: 外部count = %dn", myCounter.count) // 输出 0}
这里，
IncrementValue
方法对
c.count
的修改只发生在
myCounter
的一个临时副本上，原
myCounter
保持不变。
*指针接收器 (`func (s MyStruct) MyMethod()`)：当使用指针接收器时，方法操作的是接收器原始值**的指针。因此，在方法内部对接收器状态的任何修改，都会直接影响到原始的调用者。
type Counter struct { count int}func (c *Counter) IncrementPointer() { c.count++ // 修改的是原始Counter的count fmt.Printf("IncrementPointer: 内部count = %dn", c.count)}func main() { myCounter := Counter{count: 0} myCounter.IncrementPointer() fmt.Printf("main: 外部count = %dn", myCounter.count) // 输出 1}
在这里，
IncrementPointer
方法通过指针
c
访问并修改了
myCounter
的
count
字段，实现了对原始对象的持久化修改。
何时选择？
需要修改接收器状态时，必须使用指针接收器。 这是最核心的判断依据。对于大型结构体，为了性能考虑，即使不修改状态，也倾向于使用指针接收器，以避免不必要的内存复制。如果方法不修改接收器，且接收器是小尺寸类型（如基本类型、小结构体），可以使用值接收器。这有时可以简化代码，避免一层额外的解引用。保持一致性： 对于一个类型，通常建议所有方法都使用相同的接收器类型（要么都是值，要么都是指针），这样可以避免混淆，也更容易理解类型的行为。
在我看来，方法接收器的选择，是Go语言面向对象编程中一个非常精妙的设计点。它强制你思考你的方法是否会改变对象的状态，从而在设计API时就明确了行为意图。
以上就是Golang指针使用基础 内存地址与取值操作的详细内容，更多请关注创想鸟其它相关文章！
版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。
如发现本站有涉嫌抄袭侵权/违法违规的内容， 请发送邮件至 chuangxiangniao@163.com 举报，一经查实，本站将立刻删除。
发布者：程序猿，转转请注明出处：https://www.chuangxiangniao.com/p/1404319.html
微信扫一扫 
支付宝扫一扫 
