Rust可变借用冲突问题：如何安全使用Builder模式生成的数据

我是Rust新手，这是我尝试编写的第一段Rust代码。以下是问题代码的简化版本，错误与原代码完全一致：

struct A {
    pub value : i32
}

impl A {
    pub fn new() -> Self {
        A {value : 0}
    }
}

struct B {
    vec_a : Vec<A>
}

impl B {
    pub fn new() -> Self {
        B {
            vec_a : Vec::new()
        }
    }
    pub fn create_A(&mut self) -> &mut A {
        let a = A::new();
        self.vec_a.push(a);
        let last_index = self.vec_a.len() - 1;
        &mut self.vec_a[last_index]
    }
}

fn main() {
    let mut b = B::new();
    let a1 : &mut A = b.create_A();
    let a2 : &mut A = b.create_A();
    
    println!("{}, {}", a1.value, a2.value);
}

编译时出现如下错误：

error[E0499]: cannot borrow `b` as mutable more than once at a time
  --> src/main.rs:32:23
   |
31 |     let a1 : &mut A = b.create_A();
   |                       ------------ first mutable borrow occurs here
32 |     let a2 : &mut A = b.create_A();
   |                       ^^^^^^^^^^^^ second mutable borrow occurs here
33 |     
34 |     println!("{}, {}", a1.value, a2.value);
   |                        -------- first borrow later used here

我的理解是：由于a1由b生成，后续对b的可变借用可能修改b导致a1失效，所以使用a1不安全。这个理解是否正确？如果正确，如何告知编译器a1和a2是b的完全独立部分，后续使用a1是安全的？

解答 #

你的理解完全正确。Rust的借用规则禁止同一时间存在多个可变借用，而create_A方法返回&mut A时，编译器会默认将整个b的可变借用生命周期延长到返回的引用被销毁——它无法自动识别返回的是Vec中独立的元素引用，只会认为整个b处于可变借用状态，直到a1的使用周期结束。

以下是几种解决方法：

1. 调整引用使用顺序 #

如果可以分开使用两个引用，先完成第一个引用的所有操作再创建第二个，避免同时持有多个可变借用：

fn main() {
    let mut b = B::new();
    
    let a1 = b.create_A();
    println!("a1: {}", a1.value);
    
    let a2 = b.create_A();
    println!("a2: {}", a2.value);
}

2. 使用RefCell实现内部可变性 #

如果需要同时持有多个可变引用，可以用RefCell将可变检查从编译期推迟到运行时，绕开静态借用规则：

use std::cell::RefCell;

struct A {
    pub value: i32
}

impl A {
    pub fn new() -> Self {
        A { value: 0 }
    }
}

struct B {
    vec_a: RefCell<Vec<A>>
}

impl B {
    pub fn new() -> Self {
        B {
            vec_a: RefCell::new(Vec::new())
        }
    }
    
    pub fn create_A(&self) -> std::cell::RefMut<A> {
        let mut vec = self.vec_a.borrow_mut();
        vec.push(A::new());
        vec.last_mut().unwrap()
    }
}

fn main() {
    let b = B::new();
    let a1 = b.create_A();
    let a2 = b.create_A();
    
    println!("{}, {}", a1.value, a2.value);
}

注意：RefCell在运行时会检查可变借用规则，如果违反会直接panic，适合确定不会出现冲突借用的场景。

3. 手动拆分可变引用 #

通过split_at_mut方法向编译器证明两个引用指向Vec中完全不重叠的部分，从而允许同时持有：

fn main() {
    let mut b = B::new();
    // 先创建两个元素
    b.create_A();
    b.create_A();
    
    // 拆分Vec为两个独立的可变切片
    let (first_slice, rest_slice) = b.vec_a.split_at_mut(1);
    let a1 = &mut first_slice[0];
    let a2 = &mut rest_slice[0];
    
    println!("{}, {}", a1.value, a2.value);
}

这种方法完全依赖Rust的静态借用规则，不会有运行时开销，但需要提前创建好所有元素。

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