Rust中如何追踪调用方法的子结构体（通过引用）

问题描述 #

我想给MyStruct结构体实现add_ten方法，让它能追踪调用该方法的子结构体（用引用保存）。原始代码如下：

struct MyStruct<'a> {
    value: i32,
    child: Option<&'a mut MyStruct<'a>>,
}

impl MyStruct<'_> {
    fn add_ten(&mut self) -> MyStruct {
        MyStruct {
            value: self.value + 10,
            child: Some(self),
        }
    }
}

fn main() {
    let mut a = MyStruct { value: 10, child: None }; // 创建结构体实例
    let b = a.add_ten(); // 处理并返回包含调用者引用的新结构体
    
    println!("{}", a.value); // 希望能在这里读取a的值
    println!("{}", b.value); // 还有这里
}

运行时触发生命周期错误：

error: lifetime may not live long enough
  --> src/main.rs:10:9
   |
9  |       fn add_ten(&mut self) -> MyStruct {
   |                  ---------
   |                  |
   |                  let's call the lifetime of this reference `'1`
   |                  has type `&mut MyStruct<'2>`
10 | /         MyStruct {
11 | |             value: self.value + 10,
12 | |             child: Some(self),
13 | |         }
   | |_________^ associated function was supposed to return data with lifetime `'2` but it is returning data with lifetime `'1`
   |
   = note: requirement occurs because of the type `MyStruct<'_>`, which makes the generic argument `'_` invariant
   = note: the struct `MyStruct<'a>` is invariant over the parameter `'a`
   = help: see <https://doc.rust-lang.org/nomicon/subtyping.html> for more information about variance

补充需求
使用引用的目的是实现回溯修改子结构体的值，期望的示例行为如下：

struct MyStruct<'a> {
    value: i32,
    child: Option<&'a mut MyStruct<'a>>,
}

impl MyStruct<'_> {
    fn add_ten(&mut self) -> MyStruct {
        MyStruct {
            value: self.value + 10,
            child: Some(self),
        }
    }

    fn set_childs_to_zero(self) {
        if self.child.is_none() { return; }
        let mut child = self.child.unwrap();
        
        loop {
            child.value = 0;
            if child.child.is_none() { break; }
            child = child.child.unwrap();
        }
    }
}

fn main() {
    let mut a = MyStruct { value: 10, child: None }; // 创建结构体实例
    let b = a.add_ten(); // 处理并返回包含调用者引用的新结构体
    
    println!("a: {}", a.value); // 期望输出10
    println!("b: {}", b.value); // 期望输出20

    b.set_childs_to_zero();
    
    println!("a: {}", a.value); // 期望输出0
}

解决方案 #

核心问题分析 #

1. 生命周期不匹配：add_ten返回的MyStruct的生命周期参数需要与self的生命周期绑定，但当前写法中，返回结构体的child引用仅拥有方法调用时的临时生命周期，无法满足结构体自身的生命周期要求。
2. 可变引用独占性冲突：main中创建b后仍试图访问a，违反了Rust“同一时间只能有一个可变引用”的规则。

推荐方案：使用Rc实现灵活的共享可变访问 #

如果要实现回溯修改的需求，裸可变引用的限制太多，更合适的方式是结合Rc（引用计数智能指针）和RefCell（内部可变性容器），安全实现多所有者共享与修改：

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

#[derive(Clone)]
struct MyStruct {
    value: i32,
    child: Option<Rc<RefCell<MyStruct>>>,
}

impl MyStruct {
    // 构造函数
    fn new(value: i32) -> Self {
        MyStruct { value, child: None }
    }

    fn add_ten(&self) -> Self {
        MyStruct {
            value: self.value + 10,
            // 克隆当前实例的Rc，传递给新结构体的child字段
            child: Some(Rc::new(RefCell::new(self.clone()))),
        }
    }

    fn set_childs_to_zero(self) {
        let mut current_child = self.child;
        // 遍历所有子节点并设为0
        while let Some(child_rc) = current_child {
            let mut child = child_rc.borrow_mut();
            child.value = 0;
            // 移动到下一个子节点，避免借用冲突
            current_child = child.child.take();
        }
    }
}

fn main() {
    let a = MyStruct::new(10);
    let b = a.add_ten();
    
    println!("a: {}", a.value); // 输出10
    println!("b: {}", b.value); // 输出20

    b.set_childs_to_zero();
    
    println!("a: {}", a.value); // 输出0
}

关键改动说明

• 替换裸引用为Rc：Rc允许多个实例共享同一个对象的所有权，RefCell提供内部可变性，突破编译期可变引用的限制。
• 派生Clone trait：方便复制MyStruct实例，用于创建Rc包裹的对象。
• 调整add_ten方法：通过克隆Rc传递子节点引用，确保生命周期不受限。
• 优化set_childs_to_zero方法：使用while let循环遍历子节点，通过borrow_mut()获取可变引用修改值，take()转移子节点所有权避免借用冲突。

备选方案：严格遵守借用规则的裸引用实现 #

如果坚持使用裸引用，需要严格遵循Rust的借用规则，此时持有b期间无法访问a，直到b被销毁：

struct MyStruct<'a> {
    value: i32,
    child: Option<&'a mut MyStruct<'a>>,
}

impl<'a> MyStruct<'a> {
    fn add_ten(&'a mut self) -> MyStruct<'a> {
        MyStruct {
            value: self.value + 10,
            child: Some(self),
        }
    }

    fn set_childs_to_zero(mut self) {
        while let Some(child) = self.child.take() {
            child.value = 0;
            self = *child;
        }
    }
}

fn main() {
    let mut a = MyStruct { value: 10, child: None };
    let b = a.add_ten();
    
    // 持有b期间不能访问a，否则会触发借用冲突
    println!("b: {}", b.value); // 输出20

    b.set_childs_to_zero();
    
    // b已被销毁，可重新访问a
    println!("a: {}", a.value); // 输出0
}

这种写法可行但灵活性极低，仅适合简单场景。

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