Rust拆分借用时不允许可变借用的问题咨询

DevOps 小满

2026-5-7

为什么Rust的借用检查器会阻止这个看似合法的操作？

先把你的代码和遇到的错误列出来，方便我们一起分析：

struct Test { a: i32, b: i32, }
fn other(x: &mut i32, _refs: &Vec<&i32>) { *x += 1; }
fn main() {
    let mut xes: Vec<Test> = vec![Test { a: 3, b: 5 }];
    let mut refs: Vec<&i32> = Vec::new();
    for y in &xes {
        refs.push(&y.a);
    }
    xes.iter_mut().for_each(|val| other(&mut val.b, &refs));
}

报错信息：

error[E0502]: cannot borrow xes as mutable because it is also borrowed as immutable
--> /src/main.rs:16:5
|
13 | for y in &xes {
| ---- immutable borrow occurs here
...
16 | xes.iter_mut().for_each(|val| other(&mut val.b, &refs));
| ^^^ mutable borrow occurs here
---- immutable borrow later captured here by closure

核心问题：容器级别的借用冲突，而非字段拆分问题

你说得对，理论上拆分借用（同时使用结构体的不同字段的不可变和可变引用）应该是允许的——而且对于单个结构体实例来说，确实是允许的。但这里的问题出在你借用的是整个Vec<Test>容器，而不是仅仅借用元素的单个字段：

当你写for y in &xes时，你创建了一个对整个xes向量的不可变借用（&Vec<Test>）。你添加到refs里的每一个&y.a引用，其生命周期都绑定在这个容器级别的不可变借用上。
当你调用xes.iter_mut()时，你试图获取一个对整个xes向量的可变借用（&mut Vec<Test>）。根据Rust的核心借用规则，同一时间不能对同一个对象同时存在可变借用和不可变借用——不管你实际操作的是哪个字段。

目前Rust的借用检查器还无法“穿透”容器，识别到你只是在操作容器内元素的不同字段。它只会看到整个容器同时存在两个冲突的借用，所以直接报错。

解决方案：如何实现合法的字段级拆分借用？

方案1：拆分数据结构（推荐）

最简洁的安全解决方案是把a和b字段拆分成两个独立的向量，这样它们可以被独立借用，完全不会有冲突：

fn other(x: &mut i32, _refs: &Vec<&i32>) { *x += 1; }
fn main() {
    let mut a_values: Vec<i32> = vec![3];
    let mut b_values: Vec<i32> = vec![5];
    
    let refs: Vec<&i32> = a_values.iter().collect();
    b_values.iter_mut().for_each(|val| other(val, &refs));
}

这里a_values的不可变借用和b_values的可变借用完全独立，借用检查器不会有任何异议。

方案2：针对单个元素的字段拆分（如果必须保留结构体）

如果你一定要保留Test结构体，可以直接操作单个元素，避免借用整个容器。不过常规的索引访问还是会触发容器级别的借用，所以你有两个选择：

不安全代码（谨慎使用）

你可以用unsafe代码手动获取b字段的可变引用，同时保留a字段的不可变引用。这会绕过容器级别的借用检查，但你必须保证向量在这些引用存活期间不会重新分配（比如不能执行push/pop操作）：

struct Test { a: i32, b: i32, }
fn other(x: &mut i32, _refs: &Vec<&i32>) { *x += 1; }
fn main() {
    let mut xes: Vec<Test> = vec![Test { a: 3, b: 5 }];
    let mut refs: Vec<&i32> = Vec::new();
    
    // 收集`a`字段的不可变引用
    for test in &xes {
        refs.push(&test.a);
    }
    
    // 通过裸指针手动获取`b`字段的可变引用
    unsafe {
        for i in 0..xes.len() {
            let b_ptr = &mut xes[i].b as *mut i32;
            other(&mut *b_ptr, &refs);
        }
    }
}

内部可变性（如果你的场景允许）

如果运行时的借用检查对你的场景来说是可接受的，可以用RefCell包装b字段，这样不需要整个容器的可变借用就能修改b：

use std::cell::RefCell;

struct Test { a: i32, b: RefCell<i32>, }
fn other(x: &RefCell<i32>, _refs: &Vec<&i32>) { *x.borrow_mut() += 1; }
fn main() {
    let xes: Vec<Test> = vec![Test { a: 3, b: RefCell::new(5) }];
    let refs: Vec<&i32> = xes.iter().map(|t| &t.a).collect();
    
    xes.iter().for_each(|val| other(&val.b, &refs));
}

这种方式把借用检查从编译期移到了运行期，适合需要共享引用同时修改内部状态的场景。

总结

你忽略的关键细节是：对容器的借用是针对整个容器的，而不是你实际使用的元素或字段。Rust的借用检查器目前还无法自动对容器内的元素字段进行拆分借用，所以你需要通过调整数据结构、使用内部可变性，或者谨慎使用unsafe代码来解决这个问题。

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

Rust拆分借用时不允许可变借用的问题咨询

核心问题：容器级别的借用冲突，而非字段拆分问题 #

解决方案：如何实现合法的字段级拆分借用？ #

方案1：拆分数据结构（推荐） #

方案2：针对单个元素的字段拆分（如果必须保留结构体） #