怎样理解Golang的指针操作对比普通变量与指针变量的内存访问

P粉602998670

发布时间：2025-08-13 10:36:02

987人浏览过

来源于php中文网

原创

普通变量与指针变量在内存访问上的本质区别在于：普通变量采用值语义，直接存储并操作自身的数据副本；而指针变量采用引用语义，存储的是另一变量的内存地址，需通过解引用操作间接访问和修改目标值。这种机制使得指针在函数间高效传递大型数据、修改外部变量、构建链式结构时具有优势，但也带来别名风险和复杂性。在go中，应优先使用值传递，仅在需修改参数、避免大对象复制、实现数据结构或表示可选值时使用指针；同时，go指针相比c++/c++更安全，禁止指针算术、无void指针、默认初始化为nil，并依赖垃圾回收机制自动管理内存，通过追踪指针可达性来回收无引用对象，避免内存泄漏与悬空指针问题，从而在保证性能的同时提升程序安全性。

怎样理解Golang的指针操作对比普通变量与指针变量的内存访问

理解Golang的指针操作，核心在于它提供了一种直接访问内存地址的能力，而非像普通变量那样直接存储值。这就像你拿到的是一个房间的门牌号，而不是房间里的具体物品。这种机制在处理数据传递、修改外部状态以及构建复杂数据结构时显得尤为重要，它让程序在某些场景下更为高效和灵活。

解决方案

Go语言中的指针，本质上是一个变量，它存储着另一个变量在内存中的地址。当我们声明一个普通变量时，比如

var x int = 10

，内存中会开辟一块空间存放

这个值，并用

这个名字来指代这块空间。而声明一个指针变量，比如

var p *int

，

本身会占据一块内存，但这块内存里存储的不是一个普通值，而是一个指向

int

类型数据的内存地址。

要获取一个变量的地址，我们使用

运算符（取地址符）。例如，

p = &x

意味着

现在存储了变量

的内存地址。要访问指针所指向的值，我们使用

运算符（解引用符）。例如，

fmt.Println(*p)

会打印出

所指向的内存地址中存储的值，也就是

的值。

这种操作方式带来了几个显著的优势：

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

高效的数据传递： 当你需要在函数间传递大型数据结构（如很大的结构体或数组）时，如果按值传递，Go会复制整个数据。而传递一个指向该数据的指针，则只需复制一个地址（通常是8字节），大大减少了内存开销和复制时间。
修改外部变量： 函数通常接收参数的副本。如果你想让一个函数能够修改其调用者传入的变量的原始值，就必须通过传递指针来实现。
构建复杂数据结构： 链表、树、图等数据结构，其节点之间通常需要通过指针相互引用，才能形成复杂的拓扑关系。

package main

import "fmt"

func modifyValue(val int) {
    val = 20 // 仅修改副本
}

func modifyPointerValue(ptr *int) {
    *ptr = 20 // 修改指针指向的原始值
}

func main() {
    // 普通变量
    a := 10
    fmt.Printf("变量a的地址：%p，值为：%d\n", &a, a)

    // 指针变量
    var p *int // 声明一个指向int类型的指针
    p = &a      // 将a的地址赋值给p
    fmt.Printf("指针p存储的地址：%p，指针p指向的值：%d\n", p, *p)

    // 通过指针修改原始变量的值
    *p = 15
    fmt.Printf("通过指针修改后，变量a的值：%d\n", a)

    fmt.Println("\n--- 函数参数传递示例 ---")
    x := 100
    fmt.Printf("调用前，x的值：%d\n", x)
    modifyValue(x) // 传递副本
    fmt.Printf("modifyValue调用后，x的值：%d (未改变)\n", x)

    y := 100
    fmt.Printf("调用前，y的值：%d\n", y)
    modifyPointerValue(&y) // 传递指针
    fmt.Printf("modifyPointerValue调用后，y的值：%d (已改变)\n", y)
}

普通变量与指针变量在内存访问上的本质区别是什么？

在我看来，普通变量和指针变量在内存访问上的区别，就像是直接拥有物品和拥有指向物品的地图。普通变量直接“拥有”它的值，这个值就存放在它自己那块内存区域里。当你操作这个变量时，比如

x = 5

，你就是在直接修改

所占用的内存单元里的内容。如果把

赋值给另一个普通变量

(

y = x

)，那么

的值会被复制一份，存储到

自己的内存空间里，它们从此互不影响。

而指针变量则不同，它自己存储的不是数据本身，而是一个“地址”。这个地址是一个数字，指明了内存中另一个位置。当你声明

var p *int

并让它指向

(

p = &a

) 时，

自己的内存空间里存的是

的地址。要访问

的值，你必须通过

进行“解引用”操作（

*p

），这相当于告诉程序：“去

存储的那个地址，把那里的东西拿出来。” 这种间接访问的特性，使得多个指针可以指向同一块内存区域，从而实现共享数据和修改原始值的能力。

所以，核心区别在于：普通变量是“值语义”，操作的是它自己的那份数据；指针变量是“引用语义”，它操作的是它所指向的那份数据。理解这一点，对于掌握Go语言中数据传递和副作用的机制至关重要。

在Go语言中，何时应该使用指针，何时又应避免？

什么时候用指针，什么时候不用，这其实是个权衡问题，Go的设计哲学在这里体现得淋漓尽致：在需要时提供强大能力，在不需要时保持简洁。

TTSMaker

TTSMaker是一个免费的文本转语音工具，提供语音生成服务，支持多种语言。

下载

我认为，以下情况应该考虑使用指针：

修改函数参数的原始值： 这是最常见的场景。如果你写了一个函数，希望它能修改传入的某个变量，而不是仅仅操作它的副本，那就必须传递指针。例如，一个
```
UpdateUser
```
函数，接收
```
*User
```
参数，就能直接修改数据库中的用户记录。
避免大型数据结构的复制： 当你有一个非常大的结构体（比如包含几十个字段或者内嵌了大型数组），将其作为函数参数传递时，如果按值传递，每次调用都会复制整个结构体，这会消耗大量内存和CPU时间。这时，传递一个指向该结构体的指针，能显著提升性能。
实现链式数据结构： 像链表、树、图这类数据结构，其节点之间通常需要相互引用。这些引用自然就是通过指针来实现的，一个节点存储着下一个节点的内存地址。
方法接收者： 当你为结构体定义方法时，如果方法需要修改结构体实例的字段，或者结构体实例本身很大，就应该使用指针接收者 (
```
func (p *MyStruct) MyMethod()
```
)。如果方法只是读取数据，并且结构体较小，值接收者 (
```
func (v MyStruct) MyMethod()
```
) 也是可以的，Go编译器有时还会做优化。
表示“可选”或“不存在”的值： 在处理数据库字段或API请求时，某个字段可能为空。这时，使用
```
*string
```
或
```
*int
```
这样的指针类型，并将其设为
```
nil
```
，可以明确表示该值缺失，与零值（如空字符串、0）区分开来。

而有些情况下，即便技术上可以用指针，也应该谨慎或避免：

简单类型和小型结构体： 对于
```
int
```
,
```
bool
```
,
```
string
```
等基本类型，以及一些字段很少的小型结构体，复制的开销非常小，甚至可以忽略不计。这种情况下，使用值传递能让代码更清晰，避免不必要的解引用操作。Go的编译器对小结构体的复制优化也做得很好。
增加不必要的复杂性： 过度使用指针，或者多层指针（
```
**int
```
）会使代码变得难以阅读和理解。每次解引用都需要额外的思考，增加了心智负担。保持代码简洁通常是更好的选择。
避免“别名”问题： 当多个指针指向同一块内存时，通过一个指针修改数据，会影响到所有指向该数据的指针。这被称为“别名”（aliasing），如果处理不当，可能导致难以追踪的bug。在设计时，要清楚数据的所有权和修改权限。

总的来说，Go语言鼓励“默认按值传递”的哲学，因为它能提高局部推理的便利性。只有当性能、修改外部状态或构建特定数据结构等需求出现时，才引入指针。

Go语言的指针与C/C++的指针有何不同，以及Go的垃圾回收机制如何处理指针？

Go语言的指针，与C/C++中的指针相比，有着显著的安全性和哲学差异。我个人觉得，Go在设计指针时，明显吸取了C/C++的教训，旨在提供指针的强大功能，同时避免其带来的常见陷阱。

Go指针与C/C++指针的主要不同点：

无指针算术： 这是最大的区别。在C/C++中，你可以对指针进行加减操作（如
```
ptr++
```
），直接跳到内存中的下一个或前一个位置。这虽然强大，却是导致缓冲区溢出、非法内存访问等严重安全漏洞的罪魁祸首。Go语言明确禁止了这种操作，你不能对
```
*int
```
类型的指针进行
```
p++
```
这样的运算。这极大地提高了程序的内存安全性。

*无 `void

或泛型指针：** C/C++有

void
，可以指向任何类型的数据，但使用时需要手动进行类型转换，且编译器无法检查其安全性。Go语言是强类型语言，一个
int

只能指向

int

类型的数据。虽然Go有

interface{}` 类型可以实现某种程度的“泛型”，但它是在类型系统层面上实现的，而非底层的内存地址操作，因此是类型安全的。

无手动内存管理： C/C++程序员需要手动调用
```
malloc
```
/
```
new
```
来分配内存，并使用
```
free
```
/
```
delete
```
来释放内存。这常常导致内存泄漏（忘记释放）或悬空指针（过早释放）。Go语言则内置了垃圾回收（GC）机制，你无需手动管理指针指向的内存，GC会自动识别并回收不再使用的内存。
默认初始化为
nil
： Go的指针变量默认初始化为
```
nil
```
，表示不指向任何有效的内存地址。这与C/C++中未初始化指针可能包含任意“垃圾”值形成对比，降低了未定义行为的风险。
有限的
unsafe
包： Go提供了一个
```
unsafe
```
包，允许进行一些底层的、不安全的内存操作，包括指针算术和类型转换。但它的名字就说明了一切：这是为了特定高性能或系统级编程而设计的，不建议在日常代码中使用，且使用时必须极其谨慎，因为它绕过了Go的安全保障。

Go的垃圾回收机制如何处理指针：

Go的垃圾回收器（GC）是一个并发的、三色标记-清除（tri-color mark-and-sweep）收集器。指针在GC的工作中扮演着核心角色。

可达性分析： GC的核心任务是识别哪些内存对象是“可达的”（reachable），即程序未来可能还会使用到的。它从一组“根对象”（root objects，如全局变量、当前活跃goroutine的栈上的变量）开始，通过跟踪所有指针来遍历内存图。
指针是“引用”： 如果一个指针变量
```
p
```
存储了对象
```
a
```
的地址，那么对象
```
a
```
就被认为是“可达的”，因为它被
```
p
```
引用着。GC会沿着这些指针继续探索，标记所有可达的对象。
自动回收： 当一个对象不再被任何可达的指针引用时（即它变得“不可达”），GC就会将其标记为垃圾，并在适当的时候回收其占用的内存。这意味着，你不需要担心指针指向的内存何时释放，GC会自动处理。
避免悬空指针： 由于GC的自动回收机制，Go语言中通常不会出现C/C++中常见的“悬空指针”问题（即指针指向的内存已经被释放，但指针本身仍然存在）。GC只有在确认内存不再被引用时才会释放它。
性能考量： Go的GC被设计成低延迟和高效率，它与应用程序并发运行，尽量减少对程序执行的停顿。指针是GC理解内存布局和对象之间关系的基础。