Go语言指针操作符*与&详解

大家好，今天本人给大家带来文章《Go语言指针操作符*与&详解》，文中内容主要涉及到，如果你对Golang方面的知识点感兴趣，那就请各位朋友继续看下去吧~希望能真正帮到你们，谢谢！

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

1. Go语言中的指针基础

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

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

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

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

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

示例：

package main

import "fmt"

func main() {
    name := "Go语言"
    fmt.Printf("变量 name 的值: %s\n", name)
    fmt.Printf("变量 name 的内存地址: %p\n", &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 的零值: %v\n", p) // 指针的零值是 nil
}

3.2 解引用指针（Dereferencing）

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

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

示例：

package main

import "fmt"

func main() {
    value := 10
    ptr := &value // ptr 是指向 value 的指针
    fmt.Printf("ptr 指向的值: %d\n", *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 初始值: %d\n", num) // num: 20

    *ptr = 30 // 通过 ptr 间接修改 num 的值
    fmt.Printf("num 更改后: %d\n", num) // num: 30
}

4. 综合示例与解析

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

package main

import (
    "fmt"
    "os" // 引入 os 包用于 os.Exit
)

func main() {
    s := "hello"
    fmt.Printf("1. s 的初始值: %q, s 的地址: %p\n", 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 的地址: %p\n", s, &s)

    var p *string = &s // 声明一个 string 类型的指针 p，并将其指向 s 的地址
    fmt.Printf("3. p 的值 (s 的地址): %p, p 指向的值 (*p): %q\n", p, *p)

    *p = "ciao" // 通过指针 p 间接修改 s 的值
    fmt.Printf("4. 通过 *p 更改后，s 的值: %q, s 的地址: %p\n", s, &s)
    fmt.Printf("5. 此时 p 的值 (s 的地址): %p, p 指向的值 (*p): %q\n", 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语言指针操作符*与&详解》，希望本文对你有所帮助！关注golang学习网公众号，给大家分享更多Golang知识！