本文深入探讨go语言中指针接收器更新变量时常见的误区，特别是当尝试通过局部指针变量修改结构体字段时为何不生效。通过分析二叉搜索树的插入操作，文章阐明了go语言中指针赋值与通过指针间接修改变量的本质区别，并提出了一种使用多一级指针间接（即指向指针的指针）来正确更新目标变量的解决方案，确保结构体字段能被有效修改。

Go语言指针基础与变量更新机制

在Go语言中，指针是一种特殊类型，它存储了另一个变量的内存地址。通过指针，我们可以间接访问和修改其指向的变量。当一个函数或方法接收一个指针作为参数或接收器时，它能够修改该指针所指向的底层数据。然而，一个常见的误解是，对局部指针变量的重新赋值，会影响到它最初引用的外部变量。

考虑以下二叉搜索树（BST）的简化插入方法 Insert2：

package main

import "fmt"

type Node struct {
  key         int
  left, right *Node
}

func NewNode(key int) *Node {
  return &Node{key, nil, nil}
}

type BST struct {
  root *Node
}

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)
        return
      } else {
        node = node.left
      }
    } else {
      if node.right == nil {
        node.right = NewNode(key)
        return
      } else {
        node = node.right
      }
    }
  }
}

// 简化后的 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 被再次重新赋值，指向新创建节点的内存地址
}

func inorder(node *Node) {
  if node == nil {
    return
  }
  inorder(node.left)
  fmt.Print(node.key, " ")
  inorder(node.right)
}

func main() {
  tree := NewBinarySearchTree()
  tree.Insert2(3) // 尝试使用 Insert2
  tree.Insert2(1)
  tree.Insert2(2)
  tree.Insert2(4)
  inorder(tree.root) // 输出为空或不符合预期
}

在上述 Insert2 方法中，初次调用时，如果 t.root 为 nil：

1. node = t.root 使得局部变量 node 也为 nil。
2. for node != nil 循环被跳过。
3. node = NewNode(key) 将一个新创建的 Node 对象的地址赋值给了局部变量 node。

这里的关键问题在于：node = NewNode(key) 仅仅改变了局部变量 node 所指向的内存地址，使其指向新创建的节点。它并没有修改 t.root（或其他任何 node.left 或 node.right 字段）所指向的地址。因此，t.root 仍然保持为 nil，树结构未被更新。

立即学习“go语言免费学习笔记（深入）”；

解决之道：利用多一级指针间接

要正确地更新 t.root 或 node.left/node.right 这样的 *Node 类型变量，我们需要一个指向这些变量本身的指针。换句话说，如果 t.root 的类型是 *Node，那么我们需要一个类型为 **Node 的指针来修改 t.root。

我们可以通过在遍历过程中始终持有一个指向“待更新指针变量”的指针来实现这一点。当找到合适的插入位置时，这个“待更新指针变量”可能是 t.root、某个节点的 left 字段，或者某个节点的 right 字段。

Rydberg Agent Node

使用一条命令部署ProbeChain Rydberg测试网代理节点。自动注册为Agent(NodeType=1)，免gas，支持macOS/Linux/Windows。触发词：/r

下载

以下是修正后的 Insert3 方法：

func (t *BST) Insert3(key int) {
    // node 现在是一个指向 *Node 类型的指针（即 **Node 类型）
    // 它最初指向 t.root 变量本身的内存地址
    node := &t.root 

    // 循环条件：*node != nil 检查的是当前 *node 所指向的 Node 对象是否为 nil
    // 也就是检查 t.root, node.left, 或 node.right 是否为 nil
    for *node != nil { 
        if key < (*node).key { // 访问当前 Node 的 key
            // node 被重新赋值，使其指向当前节点左子指针变量的内存地址
            node = &(*node).left 
        } else {
            // node 被重新赋值，使其指向当前节点右子指针变量的内存地址
            node = &(*node).right
        }
    }
    // 循环结束时，*node 是 nil，表示找到了插入位置。
    // *node = NewNode(key) 会将新创建的节点赋值给 node 当前指向的 *Node 变量。
    // 这个变量可能是 t.root，也可能是某个 Node 的 left 或 right 字段。
    *node = NewNode(key) 
}

func main() {
  tree := NewBinarySearchTree()
  tree.Insert3(3) // 使用 Insert3
  tree.Insert3(1)
  tree.Insert3(2)
  tree.Insert3(4)
  inorder(tree.root) // 预期输出: 1 2 3 4 
}

让我们详细解析 Insert3 的关键步骤：

1. node := &t.root:

   • t.root 是一个 *Node 类型的变量，它存储了二叉树根节点的地址。
   • &t.root 取 t.root 这个变量本身的内存地址。
   • 因此，node 的类型是 **Node（指向 *Node 的指针），它存储了 t.root 变量的内存地址。通过 node，我们可以直接修改 t.root 变量的值。

2. *`for node != nil`**:

   • *node 对 node 进行解引用，得到 node 所指向的 *Node 变量的值。
   • 在第一次迭代中，*node 实际上就是 t.root 的值。如果 t.root 是 nil，循环就不会执行。
   • 在后续迭代中，*node 可能是 某个节点.left 或 某个节点.right 的值。

3. *`if key < (node).key { node = &(node).left } else { node = &(node).right }`**:

   • (*node).key：这里 *node 解引用得到当前的 Node 对象（例如，如果 node 指向 t.root，那么 *node 就是 t.root 所指向的 Node 对象）。然后通过 . 运算符访问其 key 字段。
   • &(*node).left：(*node).left 访问当前 Node 对象的 left 字段（这是一个 *Node 类型的变量）。& 运算符取这个 left 字段变量本身的内存地址。然后将这个地址赋值给 node。
   • 通过这种方式，node 始终指向下一个需要被检查或被更新的 *Node 变量（即 left 或 right 指针变量）。

4. *`node = NewNode(key)`**:

   • 当循环结束时，*node 的值为 nil，表示我们已经找到了一个空位来插入新节点。
   • 此时，node 正确地指向了应该被更新的 *Node 变量（例如 t.root，或某个 Node 的 left 字段，或 right 字段）。
   • *node = NewNode(key) 对 node 进行解引用，然后将新创建的 Node 对象的地址赋值给 node 所指向的那个 *Node 变量。这有效地更新了树结构。

总结与注意事项

• 指针赋值与间接修改的区别: 当你写 ptr = newValue 时，你改变的是 ptr 变量本身存储的地址，使其指向 newValue。而当你写 *ptr = newValue 时，你改变的是 ptr 所指向的内存地址中的值。理解这个区别是掌握Go指针的关键。
• 多级指针的用途: 在需要修改一个指针变量本身（而不是它指向的数据）时，就需要使用多一级指针。例如，如果你有一个 *T 类型的变量 p，并且你想在一个函数中修改 p 所存储的地址，那么你需要将 **T 类型的值传入该函数，或者像本例中一样，使用 &p 获取 p 的地址。
• 代码可读性: 虽然使用多一级指针可以实现简洁的代码，但有时可能会降低可读性。在实际开发中，需要权衡代码的简洁性和可理解性。对于二叉树插入这类操作，这种模式是 Go 语言中一种惯用的、高效且优雅的实现方式。

通过深入理解Go语言中指针的赋值行为和间接引用机制，我们可以避免常见的陷阱，并编写出更健壮、更符合预期的代码。