二级指针用于在函数内修改传入的指针变量本身，使其指向新地址，解决Go值传递导致的外部指针无法更新问题，如链表头节点修改；其核心是通过**T传递指针的地址，实现对原始指针的“回写”，但需避免过度使用，优先考虑返回值或引用类型等更Go风格的方式。
在Golang中，多级指针，最常见的就是二级指针（即指向指针的指针），它允许我们通过一个指针来修改另一个指针变量本身的值。简单来说，如果你需要在一个函数内部改变传入的指针变量所指向的地址（而不是它所指向的值），那么二级指针就是你的选择。它提供了一种更深层次的间接访问能力，使得对内存地址的控制更为灵活，尽管在Go语言的日常开发中，它的使用场景相对C/C++要少，但理解其工作原理对于深入理解Go的内存模型和某些特定场景下的编程模式至关重要。
我们来一步步剖析多级指针。首先，一个普通的指针
*T
T
**T
*T
想象一下这个场景：你有一个变量
x
addr_x
p
x
p
addr_x
pp
p
pp
p
package main
import "fmt"
func main() {
var a int = 10
var ptr *int = &a // ptr 指向 a 的地址
var pptr **int = &ptr // pptr 指向 ptr 的地址
fmt.Printf("变量 a 的值: %d\n", a)
fmt.Printf("变量 a 的地址: %p\n", &a)
fmt.Printf("指针 ptr 的值 (a 的地址): %p\n", ptr)
fmt.Printf("指针 ptr 自身存储的地址: %p\n", &ptr)
fmt.Printf("通过 ptr 解引用得到的值: %d\n", *ptr)
fmt.Printf("二级指针 pptr 的值 (ptr 的地址): %p\n", pptr)
fmt.Printf("二级指针 pptr 自身存储的地址: %p\n", &pptr)
fmt.Printf("通过 pptr 解引用一次得到的值 (ptr 的地址): %p\n", *pptr)
fmt.Printf("通过 pptr 解引用两次得到的值 (a 的值): %d\n", **pptr)
// 通过二级指针修改原始变量的值
**pptr = 20
fmt.Printf("通过 pptr 修改后，变量 a 的值: %d\n", a)
// 重点来了：通过二级指针修改一级指针指向
// 假设我们有一个新的变量
var b int = 30
var newPtr *int = &b // newPtr 指向 b 的地址
// 现在，我们想让原来的 ptr 不再指向 a，而是指向 b
// 如果我们直接 `ptr = newPtr`，那是在 main 函数内部修改 ptr
// 但如果是在一个函数里，我们想修改 main 函数里的 ptr 呢？
fmt.Printf("修改前 ptr 指向: %p, 值为: %d\n", ptr, *ptr)
modifyPointer(&ptr, newPtr) // 传入 ptr 的地址，以及新的指针
fmt.Printf("修改后 ptr 指向: %p, 值为: %d\n", ptr, *ptr) // 此时 ptr 已经指向 b
}
func modifyPointer(p **int, newTarget *int) {
// p 是一个二级指针，它存储了 main 函数中 ptr 变量的地址
// *p 解引用一次，得到的就是 main 函数中的 ptr 变量本身
// 我们可以直接修改 *p 的值，让它指向 newTarget
*p = newTarget
}这个例子清楚地展示了二级指针如何被用来修改一级指针所指向的内存地址。这和我们平时通过
*ptr = value
立即学习“go语言免费学习笔记（深入）”；
多级指针在Go语言中并非随处可见，但它确实解决了一些特定的、非常实际的问题。核心原因在于，Go语言函数参数传递默认是值传递。这意味着当你把一个变量（包括指针变量）传给函数时，函数会得到这个变量的一个副本。如果你在函数内部修改了这个副本，原始变量并不会受影响。
那么问题来了，如果我们想在一个函数内部，修改调用者（caller）传入的指针变量本身，让它指向一个新的内存地址，怎么办？这时候，我们就需要多级指针了。
一个经典的例子是，当你需要在一个函数中初始化或重新分配一个数据结构，并让调用者持有的指针指向这个新的结构时。比如，你有一个链表，你可能需要一个函数来修改链表的头节点。如果头节点是一个
*Node
*Node
**Node
package main
import "fmt"
type Node struct {
Value int
Next *Node
}
// AddToHead 试图向链表头部添加一个节点
// 错误示范：这里传入的是 *Node，函数内部修改 head 副本，外部不受影响
func AddToHeadWrong(head *Node, value int) {
newNode := &Node{Value: value, Next: head}
head = newNode // 这里的 head 是副本，修改它不会影响 main 函数中的 head
}
// AddToHeadCorrect 使用 **Node 来正确修改 head 指针
func AddToHeadCorrect(head **Node, value int) {
newNode := &Node{Value: value, Next: *head} // newNode 的 Next 指向当前 head 所指向的节点
*head = newNode // 修改 main 函数中 head 指针变量本身，让它指向 newNode
}
func printList(head *Node) {
current := head
for current != nil {
fmt.Printf("%d -> ", current.Value)
current = current.Next
}
fmt.Println("nil")
}
func main() {
var myList *Node // 初始链表为空
fmt.Println("尝试错误地添加节点:")
AddToHeadWrong(myList, 10) // myList 仍然是 nil
printList(myList) // 输出: nil
fmt.Println("\n正确地添加节点:")
AddToHeadCorrect(&myList, 10) // 传入 myList 的地址
printList(myList) // 输出: 10 -> nil
AddToHeadCorrect(&myList, 20)
printList(myList) // 输出: 20 -> 10 -> nil
AddToHeadCorrect(&myList, 30)
printList(myList) // 输出: 30 -> 20 -> 10 -> nil
}这个例子清楚地说明了，当我们需要在一个函数中改变调用者所持有的指针变量的值（即它指向的地址）时，多级指针是不可或缺的。它使得函数能够“回写”一个新的指针地址给调用者。
Golang中的多级指针与C/C++中的概念在核心上是一致的：它们都表示“指向指针的指针”。然而，由于Go语言在设计哲学和运行时环境上的差异，它们在实际使用和内存管理考量上有着显著的不同。
相同点：
**T
不同点及内存管理考量：
垃圾回收机制： 这是最大的区别。Go拥有内置的垃圾回收（GC）机制，这意味着你不需要手动管理内存分配和释放（如C/C++中的
malloc
free
**T
*T
free
安全性与类型系统： Go的类型系统比C/C++更严格，且对指针操作进行了更多的限制。
unsafe
int**
char**
使用频率与习惯：
return *T
**T
总结来说，虽然Go和C/C++在多级指针的概念上相通，但Go的GC和更严格的类型系统使得其在内存管理和安全性方面更胜一筹，同时也使得多级指针在Go中的必要性降低，通常只在修改外部指针变量的特定场景下使用。
多级指针虽然强大，但由于其多了一层间接性，也容易引入混淆和错误。理解这些误区并遵循最佳实践能帮助我们更安全、有效地使用它们。
常见误区：
*混淆`T
和
*T
T
**T
*T
*ptr
**pptr
过度使用多级指针： 有时，开发者会不假思索地使用多级指针，而实际上一个简单的
*T
*T
不清楚函数参数传递机制： 没有充分理解Go的“值传递”特性是导致多级指针误用的根源之一。如果你不清楚函数接收的是参数的副本，那么当你尝试在函数内部修改一个指针变量，并期望这个修改能反映到调用者那里时，就很容易出错。
在不必要的地方使用unsafe
unsafe
unsafe
最佳实践：
明确使用场景： 只在确实需要修改函数外部的指针变量本身时才使用多级指针。这是核心原则。如果只是修改指针指向的值，或者函数可以返回一个新的指针，那么就避免使用多级指针。
保持可读性： 尽可能减少指针的层级。在Go中，两级指针（
**T
清晰的命名和注释： 当你使用多级指针时，请确保变量命名清晰，并辅以必要的注释来解释为什么需要使用这种结构，以及每个解引用操作的含义。这对于后续的维护者（包括未来的你自己）来说至关重要。
优先考虑Go的惯用方式： 在Go中，很多C/C++需要多级指针的场景可以通过其他更“Go-idiomatic”的方式实现。
通过代码示例加深理解： 编写小段代码来测试和验证你对多级指针行为的理解。例如，尝试修改一个
*int
**int
package main
import "fmt"
func main() {
var num int = 10
var p *int = &num
// 误区示例：试图通过函数修改 p 指向的地址，但传入的是 *int
fmt.Printf("修改前 p 指向: %p, 值: %d\n", p, *p)
tryModifyPointerWrong(p) // 传入 p 的副本
fmt.Printf("修改后 p 仍然指向: %p, 值: %d (未改变)\n", p, *p)
// 正确示例：通过 **int 修改 p 指向的地址
var anotherNum int = 20
var anotherP *int = &anotherNum
fmt.Printf("再次修改前 p 指向: %p, 值: %d\n", p, *p)
tryModifyPointerCorrect(&p, anotherP) // 传入 p 的地址
fmt.Printf("再次修改后 p 指向: %p, 值: %d (已改变)\n", p, *p)
}
// tryModifyPointerWrong 这是一个错误的尝试，它无法修改外部的 p 指针
func tryModifyPointerWrong(ptr *int) {
var temp int = 99
ptr = &temp // 这里的 ptr 是 main 函数中 p 的一个副本，修改它不会影响 main 中的 p
fmt.Printf(" 函数内部 ptr 指向: %p, 值: %d\n", ptr, *ptr)
}
// tryModifyPointerCorrect 这是一个正确的做法，它能够修改外部的 p 指针
func tryModifyPointerCorrect(pptr **int, newTarget *int) {
*pptr = newTarget // *pptr 解引用得到的是 main 函数中 p 变量本身，修改它就能改变 p 的指向
fmt.Printf(" 函数内部 *pptr (即外部 p) 指向: %p, 值: %d\n", *pptr, **pptr)
}通过以上实践，我们能更好地驾驭多级指针，避免不必要的复杂性，并编写出更健壮、更易于理解的Go代码。
以上就是Golang多级指针使用及示例解析的详细内容，更多请关注php中文网其它相关文章！
每个人都需要一台速度更快、更稳定的 PC。随着时间的推移，垃圾文件、旧注册表数据和不必要的后台进程会占用资源并降低性能。幸运的是，许多工具可以让 Windows 保持平稳运行。
广告
收藏
收藏
收藏
Copyright 2014-2025 https://www.php.cn/ All Rights Reserved | php.cn | 湘ICP备2023035733号
223
