Golang指针使用基础 内存地址与取值操作

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

0

""

nil

存了个图

视频图片解析/字幕/剪辑，视频高清保存/图片源图提取

17

查看详情

如何安全地声明、初始化并操作Golang指针？有哪些常见的陷阱需要避免？

在Go中使用指针，虽然比C/C++安全得多，但依然有一些最佳实践和需要警惕的陷阱。

声明与初始化： 声明指针很简单，

var p *int

1. 指向现有变量： 这是最常见的，

   x := 10; p := &x

   登录后复制
   。此时

   p

   登录后复制
   指向

   x

   登录后复制
   的内存地址。
2. 使用

   new()

   登录后复制
   函数：

   p := new(int)

   登录后复制
   。

   new

   登录后复制
   会分配一块内存，将值初始化为类型的零值（

   int

   登录后复制
   为

   0

   登录后复制
   ），并返回这块内存的地址。这块内存是匿名的，你只能通过

   p

   登录后复制
   来访问它。
3. 结构体字面量： 对于结构体，你可以直接创建并取地址：

   s := &MyStruct{Field: "value"}

   登录后复制
   。这实际上是先创建了一个

   MyStruct

   登录后复制
   的实例，然后取其地址。

安全操作： 最重要的安全规则就是“解引用前务必检查

nil

nil

*p

panic

if p != nil { *p = 20 }

Go中没有指针算术，这是Go设计者为了避免C/C++中常见的越界访问和内存腐败问题而做出的重要决策。你不能像C语言那样对指针进行加减操作来访问相邻内存。这极大地提升了内存操作的安全性，但也意味着你不能用指针来遍历数组等。

变量的生命周期：Go的垃圾回收机制（GC）会自动管理内存，你不需要手动释放指针指向的内存。只要有活跃的指针引用着一块内存，GC就不会回收它。当没有任何指针再引用那块内存时，GC会在合适的时机将其回收。这大大降低了内存泄漏和悬垂指针的风险。

常见陷阱：

1. nil

   登录后复制
   指针解引用： 这是最常见的错误，前面已经强调过。
2. 函数返回局部变量的地址： 这在C/C++中是灾难性的，因为局部变量在函数返回后就可能被销毁。但在Go中，由于GC的存在，编译器会进行“逃逸分析”（escape analysis），如果发现局部变量的地址被返回或赋值给外部变量，它会自动将这个局部变量分配到堆上，而不是栈上，从而保证其生命周期。所以，

   func createInt() *int { x := 10; return &x }

   登录后复制
   这样的代码在Go中是安全的，但理解其背后的机制很重要。
3. 误解值传递与指针传递： 再次强调，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）可以是值类型，也可以是指针类型。这两种选择对方法的行为有着根本性的影响。

1. 值接收器 (

   func (s MyStruct) MyMethod()

   登录后复制
   )： 当使用值接收器时，方法操作的是接收器的一个副本。这意味着在方法内部对接收器状态的任何修改，都不会反映到调用者那里。

   type Counter struct {
       count int
   }
   
   func (c Counter) IncrementValue() {
       c.count++ // 修改的是c的副本
       fmt.Printf("IncrementValue: 内部count = %d\n", c.count)
   }
   
   func main() {
       myCounter := Counter{count: 0}
       myCounter.IncrementValue()
       fmt.Printf("main: 外部count = %d\n", myCounter.count) // 输出 0
   }

   登录后复制

   这里，

   IncrementValue

   登录后复制
   方法对

   c.count

   登录后复制
   的修改只发生在

   myCounter

   登录后复制
   的一个临时副本上，原

   myCounter

   登录后复制
   保持不变。

2. *指针接收器 (`func (s MyStruct) MyMethod()`)： 当使用指针接收器时，方法操作的是接收器原始值**的指针。因此，在方法内部对接收器状态的任何修改，都会直接影响到原始的调用者。

   type Counter struct {
       count int
   }
   
   func (c *Counter) IncrementPointer() {
       c.count++ // 修改的是原始Counter的count
       fmt.Printf("IncrementPointer: 内部count = %d\n", c.count)
   }
   
   func main() {
       myCounter := Counter{count: 0}
       myCounter.IncrementPointer()
       fmt.Printf("main: 外部count = %d\n", myCounter.count) // 输出 1
   }

   登录后复制

   在这里，

   IncrementPointer

   登录后复制
   方法通过指针

   c

   登录后复制
   访问并修改了

   myCounter

   登录后复制
   的

   count

   登录后复制
   字段，实现了对原始对象的持久化修改。

何时选择？

• 需要修改接收器状态时，必须使用指针接收器。 这是最核心的判断依据。
• 对于大型结构体，为了性能考虑，即使不修改状态，也倾向于使用指针接收器，以避免不必要的内存复制。
• 如果方法不修改接收器，且接收器是小尺寸类型（如基本类型、小结构体），可以使用值接收器。这有时可以简化代码，避免一层额外的解引用。
• 保持一致性： 对于一个类型，通常建议所有方法都使用相同的接收器类型（要么都是值，要么都是指针），这样可以避免混淆，也更容易理解类型的行为。

在我看来，方法接收器的选择，是Go语言面向对象编程中一个非常精妙的设计点。它强制你思考你的方法是否会改变对象的状态，从而在设计API时就明确了行为意图。

以上就是Golang指针使用基础 内存地址与取值操作的详细内容，更多请关注php中文网其它相关文章！