1. Go语言中的指针基础
在go语言中，指针是一种特殊的变量，它存储了另一个变量的内存地址。通过指针，我们可以间接访问或修改其指向的变量的值。理解指针对于掌握go语言的数据传递机制（尤其是函数参数的传递）和内存管理至关重要。
Go语言中的指针操作主要围绕两个核心符号：&（取地址操作符）和 *（指针操作符，用于声明、解引用和间接赋值）。
2. 地址操作符 &：获取变量地址
& 符号用于获取一个变量的内存地址，并返回一个指向该变量的指针。
作用： &v 表示获取变量 v 的内存地址，返回类型为 *T，其中 T 是 v 的类型。
示例：
立即学习“go语言免费学习笔记（深入）”；
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 的指针。
示例：
立即学习“go语言免费学习笔记（深入）”；
package main
import "fmt"
func main() {
var p *string // 声明一个名为 p 的变量，它是一个指向 string 类型的指针
fmt.Printf("指针 p 的零值: %v\n", p) // 指针的零值是 nil
}3.2 解引用指针（Dereferencing）
当 * 放在一个指针变量前面时（例如 *p），它表示解引用该指针，即访问该指针所指向的内存地址中存储的值。
作用： *p 表示获取指针 p 所指向的值。
示例：
立即学习“go语言免费学习笔记（深入）”；
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 所指向的变量。
示例：
立即学习“go语言免费学习笔记（深入）”；
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)
}代码解析：
- s := "hello": 声明并初始化一个字符串变量 s。
- s = "good bye": s 的值被修改为 "good bye"。
- var p *string = &s:
- var p *string: 声明了一个名为 p 的变量，其类型是 *string，表示 p 是一个指向 string 类型数据的指针。
- &s: 获取变量 s 的内存地址。
- = &s: 将 s 的内存地址赋值给指针变量 p。现在 p 存储了 s 的地址，即 p 指向了 s。
- *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) // 输出
// 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语言能够在保持内存效率的同时，提供相对简单的内存管理体验。
