Rust中如何向所属对象的方法传递可变引用？

我有一个嵌套在结构体B中的结构体实例A，需要通过调用父对象B的方法来处理两者的数据，但调用b.process()时触发了可变引用冲突错误。

原代码 #

struct A {
    val : u8
}

struct B {
    data : u8,
    a : A
}

impl A {
    pub fn process(&mut self, b : &mut B) {
        println!("Processing {} - {}", b.data, self.val);
        //do stuff with val and data...
    }
}

impl B {
    pub fn process(&mut self) {
        self.a.process(self);
    }
}

fn main() {
    let mut b = B {
        data : 0,
        a : A {
            val : 3
        }
    };

    b.process();
}

报错信息 #

error[E0499]: cannot borrow `self.a` as mutable more than once at a time
  --> src/main.rs:47:9
   |
47 |         self.a.process(self);
   |         ^^^^^^^-------^----^
   |         |      |       |
   |         |      |       first mutable borrow occurs here
   |         |      first borrow later used by call
   |         second mutable borrow occurs here

error[E0499]: cannot borrow `*self` as mutable more than once at a time
  --> src/main.rs:47:24
   |
47 |         self.a.process(self);
   |         ---------------^^^^-
   |         |      |       |
   |         |      |       second mutable borrow occurs here
   |         |      first borrow later used by call
   |         first mutable borrow occurs here

可行解决方式 #

1. 仅传递所需字段的可变引用 #

这是最推荐的方案，我们不需要传递整个B的可变引用，只传递实际需要操作的字段即可，完全符合Rust的借用规则。

修改后的代码：

struct A {
    val: u8
}

struct B {
    data: u8,
    a: A
}

impl A {
    pub fn process(&mut self, data: &mut u8) {
        println!("Processing {} - {}", data, self.val);
        // 直接操作所需的字段
        *data += 1;
        self.val += 2;
    }
}

impl B {
    pub fn process(&mut self) {
        self.a.process(&mut self.data);
    }
}

fn main() {
    let mut b = B {
        data: 0,
        a: A { val: 3 }
    };
    b.process();
    println!("After process: data={}, val={}", b.data, b.a.val);
}

2. 使用内部可变性（RefCell） #

如果确实需要传递整个B的引用，可以用RefCell实现内部可变性，允许在不可变引用内部获取可变数据。注意这种方式会带来运行时开销，且多次可变借用会触发panic，需确保逻辑安全。

修改后的代码：

use std::cell::RefCell;

struct A {
    val: u8
}

struct B {
    data: RefCell<u8>,
    a: A
}

impl A {
    pub fn process(&mut self, b: &B) {
        let mut data = b.data.borrow_mut();
        println!("Processing {} - {}", data, self.val);
        *data += 1;
        self.val += 2;
    }
}

impl B {
    pub fn process(&mut self) {
        self.a.process(self);
    }
}

fn main() {
    let mut b = B {
        data: RefCell::new(0),
        a: A { val: 3 }
    };
    b.process();
    println!("After process: data={}, val={}", b.data.borrow(), b.a.val);
}

3. 将处理逻辑移至父结构体B中 #

直接在B的方法里处理内部所有数据，避免跨结构体传递可变引用，更符合Rust的设计思路。

修改后的代码：

struct A {
    val: u8
}

struct B {
    data: u8,
    a: A
}

impl B {
    pub fn process(&mut self) {
        println!("Processing {} - {}", self.data, self.a.val);
        // 直接操作两个字段
        self.data += 1;
        self.a.val += 2;
    }
}

fn main() {
    let mut b = B {
        data: 0,
        a: A { val: 3 }
    };
    b.process();
    println!("After process: data={}, val={}", b.data, b.a.val);
}

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