本文深入解析Go语言中指针操作符 * 和 & 的核心功能。* 用于声明指针类型、解引用指针获取其指向的值，以及通过指针进行间接赋值；而 & 则用于获取变量的内存地址，即创建指向该变量的指针。理解这两个操作符对于掌握Go语言的数据传递、内存管理及高效编程至关重要。

1. Go语言中的指针基础

在go语言中，指针是一种特殊的变量，它存储了另一个变量的内存地址。通过指针，我们可以间接访问或修改其指向的变量的值。理解指针对于掌握go语言的数据传递机制（尤其是函数参数的传递）和内存管理至关重要。

Go语言中的指针操作主要围绕两个核心符号：&（取地址操作符）和 *（指针操作符，用于声明、解引用和间接赋值）。

2. 地址操作符 &：获取变量地址

& 符号用于获取一个变量的内存地址，并返回一个指向该变量的指针。

作用： &v 表示获取变量 v 的内存地址，返回类型为 *T，其中 T 是 v 的类型。

示例：

立即学习“”；

package main  import "fmt"  func main() {     name := "Go语言"     fmt.Printf("变量 name 的值: %sn", name)     fmt.Printf("变量 name 的内存地址: %pn", &name) // 使用 & 获取 name 的地址 }

输出可能类似于：

变量 name 的值: Go语言 变量 name 的内存地址: 0xc000010200

这里的 0xc000010200 就是变量 name 在内存中的地址。

3. 指针操作符 *：声明、解引用与间接赋值

* 符号在Go语言中有三种主要用途：

3.1 声明指针类型

当 * 紧跟在一个类型前面时（例如 *string，*int，*MyStruct），它表示声明一个指向该类型变量的指针。

作用： *T 表示一个指向类型 T 的指针。

示例：

立即学习“”；

package main  import "fmt"  func main() {     var p *string // 声明一个名为 p 的变量，它是一个指向 string 类型的指针     fmt.Printf("指针 p 的零值: %vn", p) // 指针的零值是 nil }

3.2 解引用指针（Dereferencing）

当 * 放在一个指针变量前面时（例如 *p），它表示解引用该指针，即访问该指针所指向的内存地址中存储的值。

作用： *p 表示获取指针 p 所指向的值。

示例：

立即学习“”；

package main  import "fmt"  func main() {     value := 10     ptr := &value // ptr 是指向 value 的指针     fmt.Printf("ptr 指向的值: %dn", *ptr) // 使用 * 解引用 ptr，获取 value 的值 }

3.3 间接赋值

当 * 放在赋值操作的左侧时（例如 *p = newValue），它表示通过指针 p 来修改其所指向的内存地址中存储的值。

作用： *p = newValue 表示将 newValue 赋值给指针 p 所指向的变量。

示例：

立即学习“”；

package main  import "fmt"  func main() {     num := 20     ptr := &num // ptr 指向 num     fmt.Printf("num 初始值: %dn", num) // num: 20      *ptr = 30 // 通过 ptr 间接修改 num 的值     fmt.Printf("num 更改后: %dn", num) // num: 30 }

4. 综合示例与解析

让我们通过一个具体的代码示例来理解 & 和 * 的联合使用：

package main  import (     "fmt"     "os" // 引入 os 包用于 os.Exit )  func main() {     s := "hello"     fmt.Printf("1. s 的初始值: %q, s 的地址: %pn", s, &s)      // 这一行在原始问题中用于检查，与指针概念直接关联不大，但作为上下文保留     if s[1] != 'e' {         fmt.Println("Error: s[1] is not 'e'")         os.Exit(1)     }      s = "good bye" // 重新赋值 s，s 的值改变，但地址通常不变     fmt.Printf("2. s 重新赋值后: %q, s 的地址: %pn", s, &s)      var p *string = &s // 声明一个 string 类型的指针 p，并将其指向 s 的地址     fmt.Printf("3. p 的值 (s 的地址): %p, p 指向的值 (*p): %qn", p, *p)      *p = "ciao" // 通过指针 p 间接修改 s 的值     fmt.Printf("4. 通过 *p 更改后，s 的值: %q, s 的地址: %pn", s, &s)     fmt.Printf("5. 此时 p 的值 (s 的地址): %p, p 指向的值 (*p): %qn", p, *p) }

代码解析：

1. s := “hello”: 声明并初始化一个字符串变量 s。
2. s = “good bye”: s 的值被修改为 “good bye”。
3. var p *string = &s:
   • var p *string: 声明了一个名为 p 的变量，其类型是 *string，表示 p 是一个指向 string 类型数据的指针。
   • &s: 获取变量 s 的内存地址。
   • = &s: 将 s 的内存地址赋值给指针变量 p。现在 p 存储了 s 的地址，即 p 指向了 s。
4. *p = “ciao”:
   • *p: 解引用指针 p，表示访问 p 所指向的内存位置。
   • = “ciao”: 将字符串 “ciao” 赋值给 p 所指向的内存位置。由于 p 指向 s，这意味着 s 的值被修改为 “ciao”。这是一个间接赋值操作。

运行此代码，您会看到 s 的值从 “hello” 变为 “good bye”，最终通过指针 p 的操作，变为 “ciao”，而 s 的内存地址始终保持不变。

5. 指针的应用场景与注意事项

5.1 应用场景

• 修改函数参数的值： Go语言函数参数默认是值传递。如果需要在函数内部修改外部变量的值，必须传递该变量的指针。

  func increment(x *int) {     *x++ // 修改 x 指向的值 }  func main() {     num := 5     increment(&num) // 传递 num 的地址     fmt.Println(num) // 输出 6 }

  登录后复制

• 传递大型数据结构： 传递结构体等大型数据时，如果采用值传递会复制整个数据结构，开销较大。传递指针可以避免复制，提高效率。

• 链表、树等数据结构： 这些数据结构天然依赖指针来连接各个节点。

5.2 注意事项

• 零值： 指针的零值是 nil。尝试解引用一个 nil 指针会导致运行时错误（panic）。

  var ptr *int fmt.Println(ptr)   // 输出 <nil> // fmt.Println(*ptr) // 会导致运行时错误：panic: runtime error: invalid memory address or nil pointer dereference

  登录后复制
• Go的垃圾回收： Go语言有自动垃圾回收机制，开发者无需手动分配或释放内存。当没有指针再指向某个内存地址时，垃圾回收器会在适当时候回收这块内存。
• 指针算术： Go语言不支持C/C++那样的指针算术（如 ptr++），这提高了代码的安全性和可读性。

6. 总结

在Go语言中，* 和 & 是理解和使用指针的关键操作符：

• & (取地址操作符)：用于获取变量的内存地址，返回一个指向该变量的指针。
• * (指针操作符)：
  • 用于声明指针类型（例如 var p *int）。
  • 用于解引用指针，获取其指向的值（例如 value := *p）。
  • 用于间接赋值，通过指针修改其指向的值（例如 *p = newValue）。

熟练掌握这两个操作符，是编写高效、安全Go程序的基础。它们使得Go语言能够在保持内存效率的同时，提供相对简单的内存管理体验。

以上就是Go语言中指针操作符 * 和 & 的核心用法解析的详细内容，更多请关注php中文网其它相关文章！