本文深入探讨go语言中指针接收器更新变量时常见的误区，特别是当尝试通过局部指针变量修改结构体字段时为何不生效。通过分析二叉搜索树的插入操作，文章阐明了go语言中指针赋值与通过指针间接修改变量的本质区别，并提出了一种使用多一级指针间接（即指向指针的指针）来正确更新目标变量的解决方案，确保结构体字段能被有效修改。
Go语言指针基础与变量更新机制
在Go语言中，指针是一种特殊类型，它存储了另一个变量的内存地址。通过指针，我们可以间接访问和修改其指向的变量。当一个函数或方法接收一个指针作为参数或接收器时，它能够修改该指针所指向的底层数据。然而，一个常见的误解是，对局部指针变量的重新赋值，会影响到它最初引用的外部变量。
考虑以下二叉搜索树（BST）的简化插入方法 Insert2：
package mainimport "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：
node = t.root 使得局部变量 node 也为 nil。for node != nil 循环被跳过。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 字段。
以下是修正后的 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 的关键步骤：
node := &t.root:
t.root 是一个 *Node 类型的变量，它存储了二叉树根节点的地址。&t.root 取 t.root 这个变量本身的内存地址。因此，node 的类型是 **Node（指向 *Node 的指针），它存储了 t.root 变量的内存地址。通过 node，我们可以直接修改 t.root 变量的值。
*`for node != nil`**:
*node 对 node 进行解引用，得到 node 所指向的 *Node 变量的值。在第一次迭代中，*node 实际上就是 t.root 的值。如果 t.root 是 nil，循环就不会执行。在后续迭代中，*node 可能是 某个节点.left 或 某个节点.right 的值。
*`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 指针变量）。
*`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语言中指针的赋值行为和间接引用机制，我们可以避免常见的陷阱，并编写出更健壮、更符合预期的代码。
以上就是深入理解Go语言指针接收器与变量更新机制的详细内容，更多请关注创想鸟其它相关文章！
版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。
如发现本站有涉嫌抄袭侵权/违法违规的内容， 请发送邮件至 chuangxiangniao@163.com 举报，一经查实，本站将立刻删除。
发布者：程序猿，转转请注明出处：https://www.chuangxiangniao.com/p/1421295.html
微信扫一扫 
支付宝扫一扫 
