go语言中，指针接收器常用于修改结构体实例的状态。然而，当涉及到修改结构体内部的指针字段时，直接对局部指针变量赋值可能无法达到预期效果。本文将通过二叉搜索树的插入操作为例，深入剖析这一常见陷阱，并详细介绍如何利用二级指针（即指向指针的指针）的概念，通过取地址和解引用操作，实现对原始结构体指针字段的正确更新。
理解Go语言中的指针与赋值
在Go语言中，变量赋值行为的核心是值拷贝。当我们将一个变量赋值给另一个变量时，实际上是复制了该变量的值。对于指针类型而言，其“值”就是它所指向的内存地址。
考虑以下简单的二叉搜索树（BST）结构：
package main
import "fmt"
// Node 定义二叉树节点
type Node struct {
key int
left, right *Node
}
// NewNode 创建一个新节点
func NewNode(key int) *Node {
return &Node{key, nil, nil}
}
// BST 定义二叉搜索树
type BST struct {
root *Node
}
// NewBinarySearchTree 创建一个空的二叉搜索树
func NewBinarySearchTree() *BST {
return &BST{nil}
}
// inorder 中序遍历
func inorder(node *Node) {
if node == nil {
return
}
inorder(node.left)
fmt.Print(node.key, " ")
inorder(node.right)
}
func main() {
tree := NewBinarySearchTree()
tree.Insert(3)
tree.Insert(1)
tree.Insert(2)
tree.Insert(4)
fmt.Print("原始插入方法结果: ")
inorder(tree.root) // 1 2 3 4
fmt.Println()
tree2 := NewBinarySearchTree()
tree2.Insert2(3) // 尝试使用简化版插入方法
tree2.Insert2(1)
tree2.Insert2(2)
fmt.Print("Insert2 方法结果: ")
inorder(tree2.root) // 预期是 1 2 3，实际为空
fmt.Println()
tree3 := NewBinarySearchTree()
tree3.Insert3(3) // 使用修正后的方法
tree3.Insert3(1)
tree3.Insert3(2)
tree3.Insert3(4)
fmt.Print("Insert3 方法结果: ")
inorder(tree3.root) // 1 2 3 4
fmt.Println()
}上述代码中的 BST.Insert 方法是正确的插入方式，它通过迭代找到合适的插入位置并直接修改 node.left 或 node.right 字段。
为什么简化版 Insert2 会失败？
问题出在尝试简化 Insert 方法时，通常会写出类似 Insert2 的版本：
立即学习“go语言免费学习笔记（深入）”；
func (t *BST) Insert2(key int) {
var node *Node
node = t.root // 1. node 复制了 t.root 的值 (即 nil)
for node != nil { // 2. 第一次插入时，t.root 为 nil，循环跳过
if key < node.key {
node = node.left
} else {
node = node.right
}
}
node = NewNode(key) // 3. 此时，node 被赋值为一个新节点的地址
// t.root 仍然是 nil，未被更新
}让我们详细分析 Insert2 的执行流程：
- node = t.root: 这一步将 t.root 的当前值（在第一次插入时为 nil）复制给局部变量 node。此时，node 和 t.root 都指向 nil。
- for node != nil: 由于 node 是 nil，循环体被跳过。
- node = NewNode(key): 这一步将新创建节点的地址赋值给局部变量 node。此时，node 指向了新节点，但 t.root 仍然是 nil。
关键在于，node = t.root 只是让 node 指向了 t.root 所指向的同一个地址。当 node 随后被重新赋值为 NewNode(key) 时，它只是改变了局部变量 node 自己所指向的地址，而没有影响到 t.root 这个变量本身。这就像你有一张纸条写着“A地址”，我复制了这张纸条，我的纸条也写着“A地址”。如果我把我的纸条上的内容改成“B地址”，你的纸条仍然写着“A地址”，并没有改变。
要修改 t.root，我们必须直接对 t.root 进行赋值，或者通过一个能够“访问并修改 t.root 变量本身”的机制。
解决方案：使用指向指针的指针
为了修改 t.root、node.left 或 node.right 这些指针变量本身，我们需要一个指向这些指针变量的指针。在Go语言中，这意味着我们需要一个 **Node 类型（指向 *Node 的指针）。
我们可以通过 & 运算符获取一个变量的地址。例如，&t.root 会得到 t.root 变量本身的内存地址，其类型是 **Node。
修正后的 Insert3 方法如下：
func (t *BST) Insert3(key int) {
nodePtr := &t.root // 1. nodePtr 现在指向了 t.root 变量的内存地址 (类型是 **Node)
for *nodePtr != nil { // 2. 解引用 nodePtr，检查它所指向的 *Node 变量是否为 nil
if key < (*nodePtr).key { // 3. 解引用 nodePtr 得到 *Node，再访问其 key 字段
nodePtr = &(*nodePtr).left // 4. nodePtr 更新为指向当前节点左子指针变量的地址
} else {
nodePtr = &(*nodePtr).right // 5. nodePtr 更新为指向当前节点右子指针变量的地址
}
}
*nodePtr = NewNode(key) // 6. 解引用 nodePtr，将其所指向的 *Node 变量赋值为新节点
}让我们再次详细分析 Insert3 的执行流程：
- nodePtr := &t.root: nodePtr 不再是一个 *Node 类型，而是一个 **Node 类型。它存储的是 t.root 变量在内存中的地址。
- for *nodePtr != nil: 这里 *nodePtr 对 nodePtr 进行解引用。这意味着我们访问的是 nodePtr 所指向的那个 *Node 变量（即 t.root）。我们检查 t.root 是否为 nil。
- key
- nodePtr = &(*nodePtr).left / nodePtr = &(*nodePtr).right: 这是核心步骤。(*nodePtr) 得到当前的 *Node 变量（例如，如果 nodePtr 指向 t.root，那么 (*nodePtr) 就是 t.root）。然后，我们访问这个 *Node 变量的 left 或 right 字段，这个字段本身又是一个 *Node 类型的变量。最后，& 运算符获取这个 left 或 right 字段变量的地址，并将其赋值给 nodePtr。这样，nodePtr 就始终指向了我们想要修改的那个 *Node 变量的地址。
- *nodePtr = NewNode(key): 当循环结束时，nodePtr 存储的是我们最终找到的那个 nil 指针变量（可能是 t.root，也可能是某个节点的 left 或 right 字段）的地址。通过 *nodePtr = NewNode(key)，我们解引用 nodePtr，直接对它所指向的那个 *Node 变量进行赋值，将其更新为新创建的节点。
总结与注意事项
- 值拷贝的理解：Go语言中的赋值操作总是值拷贝。对于指针类型，拷贝的是指针本身存储的内存地址。
- 修改指针变量本身：如果你想修改一个结构体字段（例如 t.root 或 node.left）所指向的地址，你需要获取该字段变量的地址（使用 & 运算符），然后通过这个“指向指针的指针”来间接修改它。
- *& 和 `` 的作用**：
- & (取地址运算符)：获取一个变量的内存地址。例如，&t.root 获取 t.root 变量本身的地址。
- * (解引用运算符)：访问指针所指向的内存地址中的值。例如，*nodePtr 访问 nodePtr 所指向的 *Node 变量。在赋值语句的左侧使用时，它表示修改指针所指向的值。
- 适用场景：这种“指向指针的指针”模式在需要动态修改链表、树等数据结构中的连接（即指针字段）时非常有用，因为它允许你抽象出要修改的具体指针变量，并在循环中灵活地更新它。
通过深入理解Go语言的指针机制以及 & 和 * 运算符的精确用法，我们可以避免在处理复杂数据结构时常见的指针陷阱，并编写出更加健壮和高效的代码。
