为何Rust允许结构体字段多可变借用却禁止数组元素多可变借用？

问题重现 #

结构体可变借用不同字段（编译通过） #

struct Node2{
    value: i32,
    value2: i32,
}

fn main() {
    let mut node = Node2{value: 10, value2: 10};
    let a = &mut node.value2;
    let b = &mut node.value;

    *a = 5;
    *b = 4;

    println!("a: {}, b: {}", a, b);
}

输出：a: 5, b: 4

数组/Vector可变借用不同元素（编译失败） #

fn main() {
    let mut item_vector = vec![1, 2, 3, 4, 5];
    let av = &mut item_vector[0];
    let bv = &mut item_vector[1];

    *av = 10;
    *bv = 20;

    println!("av: {}, bv: {}", av, bv);
}

报错信息：

|
24 |     let av = &mut item_vector[0];
   |                   ----------- first mutable borrow occurs here
25 |     let bv = &mut item_vector[1];
   |                   ^^^^^^^^^^^ second mutable borrow occurs here
26 |
27 |     *av = 10;
   |     -------- first borrow later used here

核心原因：借用检查的规则差异 #

Rust借用检查器的核心原则是同一时间内，一个值只能有一个可变借用，或多个不可变借用，但编译器对“借用范围”的判定逻辑在结构体和数组上有区别：

1. 结构体字段的借用判定
   结构体的字段是编译期明确的独立实体，编译器能直接证明&mut node.value和&mut node.value2指向完全不重叠的内存区域，不存在数据竞争或悬垂引用风险。因此Rust支持“结构化借用”规则，允许同时持有不同字段的可变引用，在安全前提下提升代码灵活性。

2. 数组/Vector元素的借用判定
   数组或Vector的[index]操作依赖IndexMut trait实现，编译器默认不会分析索引的具体数值——哪怕你写的是0和1这种明显不重叠的索引，基础借用检查器也会保守地将对任意元素的可变借用标记为对整个容器的可变借用。这是因为索引可能是运行时计算的变量（比如i），编译器无法在通用场景下验证索引的安全性，只能用最稳妥的规则避免风险。

数组/Vector多元素可变借用的解决方案 #

方法1：用split_at_mut分割容器 #

split_at_mut会将容器拆分为两个不重叠的可变切片，编译器可确保两者内存完全独立：

fn main() {
    let mut item_vector = vec![1, 2, 3, 4, 5];
    let (first_part, second_part) = item_vector.split_at_mut(1);
    let av = &mut first_part[0];
    let bv = &mut second_part[0]; // 对应原容器索引1

    *av = 10;
    *bv = 20;

    println!("av: {}, bv: {}", av, bv);
}

方法2：用get_mut（针对固定大小数组） #

固定大小数组的get_mut返回Option<&mut T>，结合模式匹配可安全获取多个不重叠元素的可变引用：

fn main() {
    let mut arr = [1, 2, 3];
    if let (Some(a), Some(b)) = (arr.get_mut(0), arr.get_mut(1)) {
        *a = 10;
        *b = 20;
        println!("a: {}, b: {}", a, b);
    }
}

方法3：unsafe代码（不推荐） #

如果你能手动证明索引对应的内存绝对不重叠，可使用unsafe绕过借用检查，但这会失去Rust的安全保障，需谨慎：

fn main() {
    let mut item_vector = vec![1, 2, 3, 4, 5];
    let ptr = item_vector.as_mut_ptr();
    unsafe {
        let av = &mut *ptr.add(0);
        let bv = &mut *ptr.add(1);
        *av = 10;
        *bv = 20;
        println!("av: {}, bv: {}", av, bv);
    }
}

设计决策的考量 #

Rust优先保证内存安全：结构体字段的独立性可通过类型系统静态确认，而数组索引可能是运行时动态值，编译器无法在通用场景下验证安全性，因此采用保守规则。未来随着Polonius等编译器项目的推进，可能会支持更精细的索引借用分析，但目前仍需依赖标准库的安全方法或显式分割操作实现多元素可变借用。

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