Golang指针变量赋值与内存地址变化解析-Golang-PHP中文网

Golang中指针变量赋值时，若修改其指向的值（*p = val），则地址不变；若给指针重新赋地址（p = &b），则其存储的地址改变。核心在于区分指针自身地址与所指地址。

golang指针变量赋值与内存地址变化解析

Golang中指针变量的赋值，其内存地址的变化取决于你操作的对象：如果你是修改指针所指向的值，那么指针变量本身存储的地址不变；如果你是给指针变量赋一个新的地址，那么指针变量存储的地址就变了。这听起来有点绕，但核心在于区分“指针变量自身存储的地址”和“该地址指向的数据”。

在Go语言中，指针是一个非常基础但又容易让人混淆的概念。说实话，刚开始接触Go的指针时，我也绕了点弯子，总觉得它和C/C++的指针有点像，但又有些微妙的不同。理解指针变量的赋值与内存地址的变化，是掌握Go内存模型和编写高效代码的关键。

Go语言中的指针，本质上就是一个存储另一个变量内存地址的变量。我们用

&amp;

登录后复制

操作符来获取变量的地址，用

登录后复制

操作符来解引用（dereference），也就是访问或修改该地址处的值。

让我们来看一个例子：

立即学习“go语言免费学习笔记（深入）”；

package main

import "fmt"

func main() {
    var a int = 10
    var p *int = &amp;a // p现在存储了变量a的内存地址

    fmt.Printf("初始状态：\n")
    fmt.Printf("a 的值：%d，a 的地址：%p\n", a, &amp;a)
    fmt.Printf("p 的值（即a的地址）：%p，p 自身的地址：%p\n", p, &amp;p)

    // 场景一：通过指针修改所指向的值
    fmt.Printf("\n场景一：通过指针修改所指向的值 (*p = 20)\n")
    *p = 20 // 修改p所指向的内存地址中的值

    fmt.Printf("修改后：\n")
    fmt.Printf("a 的值：%d，a 的地址：%p\n", a, &amp;a) // a的值变了
    fmt.Printf("p 的值（即a的地址）：%p，p 自身的地址：%p\n", p, &amp;p) // p存储的地址没变

    // 场景二：给指针变量赋一个新的地址
    fmt.Printf("\n场景二：给指针变量赋一个新的地址 (p = &amp;b)\n")
    var b int = 30
    p = &amp;b // p现在存储了变量b的内存地址

    fmt.Printf("重新赋值后：\n")
    fmt.Printf("a 的值：%d，a 的地址：%p\n", a, &amp;a) // a的值和地址都没变
    fmt.Printf("b 的值：%d，b 的地址：%p\n", b, &amp;b)
    fmt.Printf("p 的值（即b的地址）：%p，p 自身的地址：%p\n", p, &amp;p) // p存储的地址变了
}

登录后复制

从上面的输出你可以清楚地看到：

当我们执行
```
*p = 20
```
登录后复制
时，我们是在操作
```
p
```
登录后复制
所指向的那个内存位置上的数据。因此，
```
a
```
登录后复制
的值从10变成了20，但
```
a
```
登录后复制
的内存地址以及
```
p
```
登录后复制
变量自身存储的地址（也就是
```
a
```
登录后复制
的地址）都没有改变。
当我们执行
```
p = &amp;b
```
登录后复制
时，我们是直接修改了
```
p
```
登录后复制
这个变量本身存储的内容。
```
p
```
登录后复制
原本存储着
```
a
```
登录后复制
的地址，现在它存储了
```
b
```
登录后复制
的地址。这时，
```
p
```
登录后复制
变量自身存储的地址（
```
&amp;p
```
登录后复制
）依然不变，但
```
p
```
登录后复制
的值（它所指向的地址）却从
```
&amp;a
```
登录后复制
变成了
```
&amp;b
```
登录后复制
。

理解这个区分是至关重要的。指针变量本身也是一个变量，它有自己的内存地址，并存储着另一个变量的内存地址。对其解引用操作是去修改它指向的数据，而直接对指针变量进行赋值，则是改变它指向哪里。

Golang中，指针变量的赋值究竟改变了什么？是值还是地址？

这确实是初学者最容易混淆的地方。简单来说，指针变量的赋值操作可以分为两种，它们改变的东西是不同的：

改变指针所指向的“值”： 当你使用解引用操作符
```
*
```
登录后复制
，例如
```
*ptr = newValue
```
登录后复制
时，你实际上是在访问
```
ptr
```
登录后复制
所存储的内存地址，并将
```
newValue
```
登录后复制
写入到那个内存地址中。
- 改变了什么？ 改变了
```
ptr
```
  登录后复制
  所指向的那个变量的值。
- 什么没变？
```
ptr
```
  登录后复制
  这个指针变量本身存储的地址（即它指向哪里）没有改变，
```
ptr
```
  登录后复制
  自身的内存地址（
```
&amp;ptr
```
  登录后复制
  ）也没有改变。它就像你拿着一把钥匙去打开某个抽屉，然后往抽屉里放东西，钥匙本身还是那把钥匙，抽屉的位置也没变。
```
package main

import "fmt"

func main() {
    x := 10
    ptr := &amp;x // ptr指向x

    fmt.Printf("修改前：x=%d, ptr指向%p, ptr自身地址%p\n", x, ptr, &amp;ptr)
    *ptr = 20 // 通过ptr修改x的值
    fmt.Printf("修改后：x=%d, ptr指向%p, ptr自身地址%p\n", x, ptr, &amp;ptr)
}
```
登录后复制
输出会显示
```
x
```
登录后复制
的值从10变为20，但
```
ptr
```
登录后复制
所指向的地址以及
```
ptr
```
登录后复制
自身的地址都保持不变。
改变指针变量本身存储的“地址”： 当你直接给指针变量赋值，例如
```
ptr = &amp;anotherVar
```
登录后复制
时，你是在改变
```
ptr
```
登录后复制
这个变量自身存储的内容。
```
ptr
```
登录后复制
现在不再指向之前的变量，而是指向了
```
anotherVar
```
登录后复制
。
- 改变了什么？ 改变了
```
ptr
```
  登录后复制
  这个指针变量存储的地址（即它现在指向哪里）。
- 什么没变？
```
ptr
```
  登录后复制
  这个指针变量自身的内存地址（
```
&amp;ptr
```
  登录后复制
  ）没有改变。它就像你把钥匙串上的钥匙换成了另一把，钥匙串（
```
&amp;ptr
```
  登录后复制
  ）还在你手上，但你现在拿着的钥匙（
```
ptr
```
  登录后复制
  的值）已经不同了，它能打开另一个抽屉。
```
package main

import "fmt"

func main() {
    x := 10
    y := 30
    ptr := &amp;x // ptr最初指向x

    fmt.Printf("修改前：x=%d, y=%d, ptr指向%p, ptr自身地址%p\n", x, y, ptr, &amp;ptr)
    ptr = &amp;y // 让ptr指向y
    fmt.Printf("修改后：x=%d, y=%d, ptr指向%p, ptr自身地址%p\n", x, y, ptr, &amp;ptr)
}
```
登录后复制
输出会显示
```
ptr
```
登录后复制
所指向的地址从
```
&amp;x
```
登录后复制
变为
```
&amp;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, &amp;val)
}

func main() {
    num := 100
    fmt.Printf("调用前 (main): num=%d, num的地址=%p\n", num, &amp;num)
    modifyValue(num)
    fmt.Printf("调用后 (main): num=%d, num的地址=%p\n", num, &amp;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, &amp;ptr)
    *ptr = 200 // 通过副本指针修改它所指向的内存地址中的值
}

func reassignPointer(ptr *int) {
    // 这里的ptr也是原始指针的一个副本
    var temp int = 500
    ptr = &amp;temp // 重新赋值这个副本指针，让它指向一个新的地址
    fmt.Printf("在函数内部 (reassignPointer): ptr指向%p, ptr自身地址%p\n", ptr, &amp;ptr)
}

func main() {
    num := 100
    p := &amp;num // p指向num

    fmt.Printf("调用前 (main): num=%d, p指向%p, p自身地址%p\n", num, p, &amp;p)

    // 场景一：函数通过指针副本修改原始数据
    modifyPointerValue(p)
    fmt.Printf("调用 modifyPointerValue 后 (main): num=%d, p指向%p, p自身地址%p\n", num, p, &amp;p)
    // 此时，num的值变了，但p所指向的地址没变，p自身的地址也没变

    // 场景二：函数尝试重新赋值原始指针（但只能改变副本）
    reassignPointer(p)
    fmt.Printf("调用 reassignPointer 后 (main): num=%d, p指向%p, p自身地址%p\n", num, p, &amp;p)
    // 此时，num的值和p所指向的地址都保持不变，因为reassignPointer只改变了它内部的指针副本
}

登录后复制

输出会清晰地显示：

```
modifyPointerValue
```
登录后复制
函数能够成功修改
```
main
```
登录后复制
函数中
```
num
```
登录后复制
的值，因为虽然它拿到的是
```
p
```
登录后复制
的副本，但这个副本指向的内存地址和
```
p
```
登录后复制
指向的内存地址是一样的。
```
reassignPointer
```
登录后复制
函数内部虽然将
```
ptr
```
登录后复制
重新指向了
```
temp
```
登录后复制
，但这个改变只发生在函数内部，
```
main
```
登录后复制
函数中的
```
p
```
登录后复制
变量依然指向
```
num
```
登录后复制
。因为
```
reassignPointer
```
登录后复制
操作的也是
```
p
```
登录后复制
的一个副本。

总结来说，当你需要函数修改外部变量的值时，就应该传递该变量的指针。但如果你想让函数改变外部指针变量的指向（例如，让

main

登录后复制

函数中的

登录后复制

从指向

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", &amp;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(&amp;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
```
登录后复制
。这在某种程度上减轻了开发者手动管理内存的负担，但也意味着你可能在不知不觉中创建了堆分配，而堆分配通常比栈分配慢。