使用Rc<RefCell>实现二叉树子节点和属性时的借用检查器错误

错误原因分析 #

你遇到的E0596错误核心问题是在不可变借用上下文里尝试获取可变引用：

• node.borrow()返回的是Ref<'_, Node>（不可变引用包装），它仅实现了不可变解引用trait，没有实现可变解引用，因此无法通过它调用as_mut()获取子节点的可变引用。
• 原代码中多次交替调用borrow()和borrow_mut()，容易触发RefCell的借用规则冲突——同一时间只能存在一个可变借用，或多个不可变借用。

修复后的代码实现 #

下面是重构后的代码，通过优化借用时机和减少重复操作解决错误：

use std::rc::Rc;
use std::cell::RefCell;

#[derive(Debug, Clone, Eq, PartialEq)]
pub struct Node {
    value: i32,
    left: Option<Rc<RefCell<Node>>>,
    right: Option<Rc<RefCell<Node>>>,
}

impl Node {
    pub fn new(value: i32) -> Self {
        Node {
            value,
            left: None,
            right: None,
        }
    }

    pub fn add_left(&mut self, value: i32) {
        self.left = Some(Rc::new(RefCell::new(Node::new(value))));
    }

    pub fn add_right(&mut self, value: i32) {
        self.right = Some(Rc::new(RefCell::new(Node::new(value))));
    }
}

pub fn children_sum_property(node: Option<Rc<RefCell<Node>>>) {
    if let Some(node_rc) = node {
        // 计算子节点值之和，用代码块限制不可变借用的生命周期
        let child_sum = {
            let node_ref = node_rc.borrow();
            let mut sum = 0;
            if let Some(left) = &node_ref.left {
                sum += left.borrow().value;
            }
            if let Some(right) = &node_ref.right {
                sum += right.borrow().value;
            }
            sum
        };

        // 一次性获取可变借用，统一操作当前节点和子节点
        let mut node_mut = node_rc.borrow_mut();
        if child_sum >= node_mut.value {
            node_mut.value = child_sum;
        } else {
            let parent_val = node_mut.value;
            if let Some(left) = &mut node_mut.left {
                left.borrow_mut().value = parent_val;
            }
            if let Some(right) = &mut node_mut.right {
                right.borrow_mut().value = parent_val;
            }
        }

        // 提前克隆子节点的Rc，主动释放当前节点的可变借用
        let left_clone = node_mut.left.clone();
        let right_clone = node_mut.right.clone();
        drop(node_mut);

        // 递归处理子节点
        children_sum_property(left_clone);
        children_sum_property(right_clone);

        // 再次计算子节点之和，更新当前节点值
        let total = {
            let node_ref = node_rc.borrow();
            let mut sum = 0;
            if let Some(left) = &node_ref.left {
                sum += left.borrow().value;
            }
            if let Some(right) = &node_ref.right {
                sum += right.borrow().value;
            }
            sum
        };

        let mut node_mut = node_rc.borrow_mut();
        if node_mut.left.is_some() || node_mut.right.is_some() {
            node_mut.value = total;
        }
    }
}

// 测试用例
fn main() {
    let mut root = Node::new(10);
    root.add_left(5);
    root.add_right(3);
    children_sum_property(Some(Rc::new(RefCell::new(root))));
}

关键优化点 #

• 控制借用作用域：用代码块{}包裹不可变借用逻辑，让借用在代码块结束后自动释放，避免和后续可变借用冲突。
• 统一借用入口：一次性获取节点的可变借用node_mut，直接通过它操作子节点，避免重复调用borrow()/borrow_mut()引发规则冲突。
• 主动释放可变借用：递归前调用drop(node_mut)主动释放可变借用，确保递归时可以正常获取子节点的引用。
• 提前克隆子节点引用：在持有可变借用阶段先克隆子节点的Rc，避免递归时因当前节点的可变借用未释放而无法访问子节点。

内容的提问来源于stack exchange，提问作者KillerFC