Rust中父结构体向子结构体传递引用时编译错误的解决方法

需求与问题 #

我需要实现父结构体持有子结构体向量的结构，CommonParams结构体存储子结构体从父结构体继承的、可更新的参数，所有子结构体必须能访问最新的参数。父结构体创建时必须包含一个子结构体，但编写的代码编译时出现了生命周期相关错误。

原代码 #

struct Parent<'a> {
    children: Vec<Child<'a>>,
    common_params: CommonParams,
    name: &'a str,
}

impl<'a> Parent<'a> {
    fn new(name: &str, child_name: &str, child_age: u8, address: String) -> Parent<'a> {
        let common = CommonParams {
            address,
        };
        let mut parent = Parent {
            children: Vec::new(),
            common_params: common,
            name,
        };
        let child = Child::new(&parent.common_params, child_name);
        parent.add_child(child);
        parent
    }

    fn add_child(&mut self, child: Child<'a>) {
        self.children.push(child);
    }
}

struct Child<'a> {
    common_params: &'a CommonParams,
    name: &'a str,
}

impl<'a> Child<'a> {
    fn new(common_params: &'a CommonParams, name: &'a str) -> Child<'a> {
        Child {
            common_params,
            name,
        }
    }
}

struct CommonParams {
    address: String,
}

编译错误 #

9  | impl<'a> Parent<'a> {
   |      -- lifetime `'a` defined here
...
14 |         let mut parent = Parent {
   |             ---------- binding `parent` declared here
...
19 |         let child = Child::new(&parent.common_params, child_name);
   |                                --------------------- borrow of `parent.common_params` occurs here
20 |         parent.add_child(child);
21 |         parent
   |         ^^^^^^
   |         |
   |         move out of `parent` occurs here
   |         returning this value requires that `parent.common_params` is borrowed for `'a`

错误原因 #

这段代码的核心问题是子结构体持有了父结构体内部CommonParams的引用，但在Parent::new中，我们先创建parent，再借用它的common_params创建Child，接着把Child加入parent的children，最后返回parent。这形成了"自引用"结构：parent的所有权被转移（返回给调用者），但它内部的Child还持有它自身的引用。Rust的借用检查器严格禁止这种情况，因为会违反借用规则——引用的生命周期不能超过被引用对象，且不能同时存在可变和不可变引用。

解决方案 #

要实现子结构体访问父结构体中可更新且共享的参数，需要用智能指针绕过单纯引用的生命周期限制。这里使用Rc<RefCell<CommonParams>>组合：

• Rc：允许多个所有者共享同一个对象，父和子都能持有CommonParams的所有权
• RefCell：提供内部可变性，允许在共享所有权的情况下修改CommonParams的内容

修改后的代码 #

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

struct Parent<'a> {
    children: Vec<Child<'a>>,
    common_params: Rc<RefCell<CommonParams>>,
    name: &'a str,
}

impl<'a> Parent<'a> {
    fn new(name: &str, child_name: &str, address: String) -> Parent<'a> {
        let common = Rc::new(RefCell::new(CommonParams { address }));
        // 克隆Rc，仅增加引用计数，不拷贝实际数据
        let child = Child::new(Rc::clone(&common), child_name);
        
        Parent {
            children: vec![child],
            common_params: common,
            name,
        }
    }

    fn add_child(&mut self, child: Child<'a>) {
        self.children.push(child);
    }

    // 示例：更新公共参数的方法
    fn update_address(&self, new_address: String) {
        self.common_params.borrow_mut().address = new_address;
    }
}

struct Child<'a> {
    common_params: Rc<RefCell<CommonParams>>,
    name: &'a str,
}

impl<'a> Child<'a> {
    fn new(common_params: Rc<RefCell<CommonParams>>, name: &'a str) -> Child<'a> {
        Child {
            common_params,
            name,
        }
    }

    // 示例：子结构体访问最新的公共参数
    fn print_address(&self) {
        let params = self.common_params.borrow();
        println!("{}'s address: {}", self.name, params.address);
    }
}

struct CommonParams {
    address: String,
}

// 测试功能
fn main() {
    let mut parent = Parent::new("Parent", "Child1", "123 Main St".to_string());
    parent.children[0].print_address(); // 输出：Child1's address: 123 Main St

    parent.update_address("456 Oak Ave".to_string());
    parent.children[0].print_address(); // 输出：Child1's address: 456 Oak Ave

    let child2 = Child::new(Rc::clone(&parent.common_params), "Child2");
    parent.add_child(child2);
    parent.children[1].print_address(); // 输出：Child2's address: 456 Oak Ave
}

关键修改点说明 #

1. 替换引用为智能指针：将Parent和Child中的CommonParams引用改为Rc<RefCell<CommonParams>>，实现共享所有权与内部可变性
2. 避免自引用：Parent::new中直接创建Child并放入初始化的children向量，不再需要先创建空parent再添加子对象
3. 安全访问与修改：通过borrow()（不可变访问）和borrow_mut()（可变访问）操作RefCell，RefCell会在运行时检查借用规则，避免数据竞争
4. 共享参数更新：父结构体更新CommonParams后，所有子结构体都能访问到最新的参数值

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