本文深入探讨go语言中指针接收器在更新结构体字段时常遇到的问题，特别是当局部指针变量被重新赋值时无法影响原始结构体。通过二叉搜索树的插入操作为例，文章详细解释了指针赋值与指向值修改的区别，并引入了“指针的指针”这一高级概念，展示了如何通过多一层间接引用来正确更新结构体内部的指针字段，从而确保数据结构的持久性修改。
在Go语言中，指针接收器（pointer receiver）是方法定义中常见的模式，它允许方法修改接收器所指向的实际值。然而，对于初学者来说，指针的赋值行为与通过指针修改其指向的值之间的区别常常会造成混淆。本文将通过一个二叉搜索树（BST）的插入操作实例，深入剖析这一常见陷阱，并提供正确的解决方案。
理解Go语言中的指针赋值与值修改
考虑以下二叉搜索树的结构定义：
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}
}
// Insert 方法：原始的正确插入实现
func (t *BST) Insert(key int) {
if t.root == nil {
t.root = NewNode(key)
return
}
var node = t.root
for {
if key < node.key {
if node.left == nil {
node.left = NewNode(key) // 直接修改了 node.left 指针
return
} else {
node = node.left // 移动到左子节点
}
} else {
if node.right == nil {
node.right = NewNode(key) // 直接修改了 node.right 指针
return
} else {
node = node.right // 移动到右子节点
}
}
}
}
// 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("原始Insert方法结果: ")
inorder(tree.root) // 预期输出: 1 2 3 4
fmt.Println()
// 尝试使用错误的Insert2方法
tree2 := NewBinarySearchTree()
tree2.Insert2(3) // 期望插入3
fmt.Print("Insert2方法结果: ")
inorder(tree2.root) // 预期输出: 空 (或没有任何输出)
fmt.Println()
// 使用Insert3方法
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()
}在上述 Insert 方法中，当找到插入位置时，我们直接通过 node.left = NewNode(key) 或 node.right = NewNode(key) 来修改当前节点的左子节点或右子节点指针。这能够正确地更新二叉树结构。
然而，如果尝试对 Insert 方法进行如下“简化”：
立即学习“go语言免费学习笔记（深入）”；
// Insert2 方法：错误的插入实现
func (t *BST) Insert2(key int) {
var node *Node
node = t.root // 1. node 变量指向 t.root 所指向的地址
for node != nil {
if key < node.key {
node = node.left // 2. node 变量被重新赋值为 node.left 所指向的地址
} else {
node = node.right // 3. node 变量被重新赋值为 node.right 所指向的地址
}
}
node = NewNode(key) // 4. node 变量被重新赋值为新节点的地址
}使用 Insert2 方法，二叉树将永远不会被更新。原因在于Go语言的赋值行为。当执行 node = t.root 时，node 只是获得了 t.root 所存储的指针值的副本，即它们现在指向同一个内存地址。在循环内部，node = node.left 或 node = node.right 同样只是将 node 这个局部变量重新指向了树中其他节点的子节点。
最关键的一步是 node = NewNode(key)。这一行代码将 node 这个局部变量重新赋值，使其指向了一个全新的 Node 对象。这并不会影响 t.root，也不会影响之前遍历过程中任何节点的 left 或 right 字段，因为 node 只是一个局部变量，它的重新赋值不会回溯到它曾经指向的那些原始指针变量（如 t.root 或 parent.left）。
可以将其想象成：你复制了一份房子的地址给朋友（node = t.root）。朋友去这个地址（遍历），然后决定要买一套新房子，于是他把新房子的地址写在了自己的纸条上（node = NewNode(key)）。这并不会改变你纸条上的地址，也不会改变原始房子的地址簿。
解决方案：使用指针的指针 (**Node)
为了解决这个问题，我们需要修改的不是 node 这个局部指针变量本身，而是 t.root、node.left 或 node.right 这些“存储指针的变量”本身。换句话说，我们需要一个指针来指向这些存储指针的变量。这就是“指针的指针”（pointer to pointer）或者说多一层间接引用的概念。
如果我们要修改一个类型为 *Node 的变量（例如 t.root、someNode.left 或 someNode.right），那么我们需要一个类型为 **Node 的指针来指向它。
以下是 Insert 方法的正确实现，它利用了指针的指针：
// Insert3 方法：使用指针的指针实现正确插入
func (t *BST) Insert3(key int) {
// node 现在是一个指向 *Node 类型变量的指针，即 **Node
// 初始时，它指向 t.root 的内存地址
node := &t.root
// 循环条件：*node != nil 检查当前 *Node 变量（例如 t.root, parent.left）是否为 nil
for *node != nil {
// key < (*node).key：解引用 node 得到 *Node，然后访问其 key 字段
if key < (*node).key {
// node = &(*node).left：
// 1. 解引用 node 得到当前的 *Node 对象 (例如某个父节点)
// 2. 访问该 *Node 对象的 left 字段 (它是一个 *Node 类型变量)
// 3. 取 left 字段的地址 (&)，这个地址是一个 **Node 类型的值
// 4. 将这个 **Node 值赋值给 node 变量，使 node 现在指向 parent.left 的内存地址
node = &(*node).left
} else {
// 同理，使 node 指向 parent.right 的内存地址
node = &(*node).right
}
}
// 循环结束后，node 指向了应该插入新节点的那个 *Node 变量的内存地址
// 例如，如果树为空，node 指向 &t.root
// 如果插入到叶子节点的左侧，node 指向 &parent.left
// *node = NewNode(key)：
// 解引用 node，得到它所指向的 *Node 变量（例如 t.root 或 parent.left），
// 然后将新创建的节点赋值给它，从而更新了树的结构。
*node = NewNode(key)
}通过 node := &t.root，我们让 node 变量存储了 t.root 变量的内存地址。因此，node 的类型是 **Node。
在循环中：
- *node != nil：这里 *node 对 node 进行解引用，得到的是 t.root（或其他 *Node 变量）的实际值。我们检查这个实际值是否为 nil。
- if key
- node = &(*node).left：这是核心。(*node) 得到当前节点（例如父节点），.left 访问其左子节点字段（这个字段本身是一个 *Node 类型的变量），然后 & 取这个 left 字段的内存地址。这个地址（类型为 **Node）被赋值回 node。这意味着 node 现在指向了父节点的 left 字段的内存位置。
- 循环结束时，node 变量存储的正是我们想要更新的那个 *Node 变量（可能是 t.root、某个父节点的 left 字段或 right 字段）的内存地址。
- *node = NewNode(key)：最后一步，对 node 进行解引用，得到它所指向的 *Node 变量，然后将 NewNode(key) 返回的新节点赋值给它。这样就成功地更新了树的结构。
总结与注意事项
-
指针赋值与值修改的区别：
- ptr = anotherPtr：这只是将 anotherPtr 的值（一个内存地址）复制给 ptr。ptr 现在指向与 anotherPtr 相同的位置，但它们仍然是两个独立的指针变量。对 ptr 后续的重新赋值（如 ptr = NewValue()）不会影响 anotherPtr 或 ptr 曾经指向的原始变量。
- *ptr = newValue：这才是通过 ptr 修改它所指向的内存位置上的值。newValue 将被写入 ptr 所指向的地址。
-
何时需要指针的指针：
- 当你需要修改一个已经存在的指针变量本身（而不是它所指向的值）时，例如将其从 nil 变为指向某个对象，或者将其从指向对象A变为指向对象B，并且这个修改需要对调用者可见（即影响原始变量），你就需要一个指向该指针变量的指针。
- 在数据结构（如链表、树）中，当需要更新 root、next、left、right 等指针字段以连接新节点或移除旧节点时，这种模式非常有用。
- *清晰使用 `和&`**：
- & (Address-of Operator)：获取一个变量的内存地址。
- * (Dereference Operator)：访问指针所指向的内存地址上的值。
理解Go语言中指针的赋值语义和多级指针的使用是编写高效、正确数据结构操作的关键。通过上述示例，希望能帮助读者更深入地掌握Go语言中指针接收器的工作原理及其在复杂数据结构操作中的应用。
