Go语言指针详解：理解结构体指针与原结构体的关联

新闻中心 NEWS CENTER

您当前位置：首页 > 新闻中心 > 网络学院

Go语言指针详解：理解结构体指针与原结构体的关联

2025-11-07

浏览次数：次

返回列表

Go语言指针详解：理解结构体指针与原结构体的关联

本文深入探讨go语言中结构体指针的工作原理。当一个结构体指针被赋值为另一个结构体的地址时，它并非创建了一个副本，而是直接指向了原结构体的内存位置。因此，通过该指针进行的任何修改都会直接作用于原始结构体，因为两者共享同一份底层数据，理解这一机制对于掌握go语言的内存管理和数据操作至关重要。

理解Go语言中的指针

在Go语言（以及C/C++等类C语言）中，指针是一种非常重要的数据类型。它不存储实际的数据值，而是存储另一个变量的内存地址。通过指针，我们可以间接访问和修改其所指向的变量。

Go语言中与指针相关的两个主要运算符是：

& (取地址运算符)：用于获取变量的内存地址。例如，&x 会返回变量 x 的内存地址。
*`(解引用运算符)**：用于访问指针所指向的值。例如，如果p是一个指针，那么*p表示p` 所指向的内存地址中存储的值。

结构体与结构体指针

结构体（struct）是Go语言中用于聚合不同类型数据记录的自定义类型。当我们需要在函数间传递大型结构体，或者希望函数能够修改原始结构体时，通常会使用结构体指针。

考虑以下 person 结构体：

type person struct {
    name string
    age  int
}

当我们创建一个 person 类型的变量 s 时，内存中会分配一块区域来存储 s 的数据。如果我们再创建一个指向 s 的指针 sp，那么 sp 变量本身会存储 s 的内存地址。这意味着 sp 并没有创建 s 的一个副本，它只是一个“别名”或者说一个“导航”，指向了 s 所在的实际内存位置。

示例分析

让我们通过一个具体的代码示例来深入理解这个概念：

package main

import "fmt"

type person struct {
    name string
    age  int
}

func main() {
    // 1. 初始化一个 person 结构体实例 s
    s := person{name: "Sean", age: 50}
    fmt.Printf("1. 结构体 s 的内存地址：%p，s.age 值：%d\n", &s, s.age)

    // 2. 创建一个指向 s 的指针 sp
    // sp 变量本身存储的是 s 的内存地址。
    sp := &s
    // 打印 sp 变量所存储的地址（即 s 的地址），以及通过 sp 访问 s.age 的值。
    fmt.Printf("2. 指针变量 sp 所指向的地址（即 s 的地址）：%p，通过 sp 访问 s.age：%d\n", sp, sp.age)
    // 打印指针变量 sp 自身的内存地址。
    // 注意：这是 sp 变量在内存中的位置，与 s 的地址以及 sp 所指向的地址都不同。
    fmt.Printf("3. 指针变量 sp 自身的内存地址：%p\n", &sp)

    // 3. 通过指针 sp 修改 age 字段
    // 实际上修改的是 sp 所指向的内存位置的数据，也就是 s 的 age 字段。
    sp.age = 51
    fmt.Printf("4. 通过 sp 修改后，sp 访问 s.age 的值：%d\n", sp.age)

    // 4. 再次查看原始结构体 s 的 age 字段
    // 由于 sp 修改的是 s 所在的内存，因此 s.age 的值也会随之改变。
    fmt.Printf("5. 通过 sp 修改后，原始结构体 s.age 的值：%d\n", s.age)
}

代码输出解析：

易标AI

告别低效手工，迎接AI标书新时代！3分钟智能生成，行业唯一具备查重功能，自动避雷废标项

135 查看详情易标AI

假设运行时的内存地址如下（具体地址可能不同）：

1. 结构体 s 的内存地址：0xc0000120a0，s.age 值：50
2. 指针变量 sp 所指向的地址（即 s 的地址）：0xc0000120a0，通过 sp 访问 s.age：50
3. 指针变量 sp 自身的内存地址：0xc0000100b0
4. 通过 sp 修改后，sp 访问 s.age 的值：51
5. 通过 sp 修改后，原始结构体 s.age 的值：51

s := person{name: "Sean", age: 50}:
- Go运行时在内存中为 s 分配了一块空间，其地址为 0xc0000120a0（示例地址）。s.age 的初始值为 50。
sp := &s:
- &s 获取了 s 的内存地址 0xc0000120a0。
- 这个地址值被赋给了指针变量 sp。因此，sp 现在“指向”了 s。
- sp 变量本身也在内存中占有一席之地，例如其自身的地址可能是 0xc0000100b0。
- 当我们打印 sp（不带 &）时，它会输出它所存储的地址，即 s 的地址 0xc0000120a0。
- sp.age 是Go语言提供的一种语法糖，它等价于 (*sp).age。这意味着Go会自动解引用 sp，然后访问其指向的结构体的 age 字段。此时，它访问的是 s.age，所以值为 50。
sp.age = 51:
- 通过 sp.age，我们访问的是 sp 所指向的内存地址（即 s 的内存地址）中的 age 字段。
- 将该内存位置的值从 50 修改为 51。
后续打印:
- fmt.Printf("...sp 访问 s.age 的值：%d\n", sp.age)：由于 sp 指向的内存位置的 age 已经变为 51，所以这里输出 51。
- fmt.Printf("...原始结构体 s.age 的值：%d\n", s.age)：由于 sp 直接修改的就是 s 的内存，所以 s.age 的值也变成了 51。

关键点与注意事项

指针是引用，而非副本：这是理解此现象的核心。当您将一个结构体的地址赋给一个指针时，您并没有创建该结构体的一个独立副本。相反，您是创建了一个指向原始结构体内存位置的引用。任何通过该指针进行的修改都将直接作用于原始结构体。
Go语言的语法糖：Go语言为了方便操作结构体指针，允许直接使用 . 运算符来访问指针所指向结构体的字段，例如 sp.age。在底层，Go编译器会自动将其转换为 (*sp).age，即先解引用指针，再访问字段。
内存地址的一致性：&s 和 sp 所存储的地址是完全相同的，它们都指向内存中同一块存储 s 数据的区域。而 &sp 则是指针变量 sp 自身在内存中的地址，与 s 的地址不同。
值传递与指针传递：在Go语言中，函数参数默认是值传递。如果将一个结构体作为参数传递给函数，函数会接收到该结构体的一个副本，函数内部对副本的修改不会影响原始结构体。但如果将结构体指针作为参数传递，函数内部通过指针进行的修改会直接作用于原始结构体。