首页 > Golang > Go教程

Golang指针赋值与内存地址变化详解

时间：2025-09-03 12:14:38 254浏览收藏

本文深入解析了 Golang 中指针赋值与内存地址变化的关键概念，旨在帮助开发者透彻理解 Go 语言的内存模型。文章通过实例代码，详细区分了修改指针所指向的值与给指针重新赋值地址两种情况，并阐明了这两种操作对指针变量及其所指地址的影响。此外，还探讨了 Go 语言的“传值”特性在指针传递中的作用，以及指针在性能优化和内存管理中的实际应用，例如避免大对象拷贝和构建链式数据结构。本文旨在帮助 Golang 开发者更好地掌握指针的使用，编写更高效、更安全的代码。

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

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

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

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

Go语言中的指针，本质上就是一个存储另一个变量内存地址的变量。我们用&操作符来获取变量的地址，用*操作符来解引用（dereference），也就是访问或修改该地址处的值。

让我们来看一个例子：

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指针解引用等潜在问题。

好了，本文到此结束，带大家了解了《Golang指针赋值与内存地址变化详解》，希望本文对你有所帮助！关注golang学习网公众号，给大家分享更多Golang知识！