Rust嵌套循环可变借用冲突（E0499）问题求助及概念解惑

问题背景 #

我是Rust（编译型语言）新手，把可用的Python埃拉托斯特尼筛法转译为Rust时，遇到了类型和引用相关问题，最终卡在了可变借用冲突的E0499错误上。目标是生成给定整数N以下的所有素数向量，目前先保证代码能运行，后续再处理结果修剪。

原代码与错误信息 #

原代码 #

pub fn primes_up_to(upper_bound: u64) -> Vec<u64> {
    let mut vec: Vec<u64> = (2..=upper_bound).collect();
    for i in &vec {
        if *i != 0 {
            let lower: u64 = u64::pow(*i, 2) - 2;       
            for n in (lower..(upper_bound-1)).step_by(*i as usize) {
                vec[n as usize] = 0
            }
        }
    }
    return vec
}

编译错误 #

Compiling sieve v1.1.0 (/mnt/exercism-iteration)
error[E0499]: cannot borrow `vec` as mutable more than once at a time
  --> src/lib.rs:10:17
   |
5  |     for i in &mut vec {
   |              --------
   |              |
   |              first mutable borrow occurs here
   |              first borrow later used here
...
10 |                 vec[n as usize] = 0
   |                 ^^^ second mutable borrow occurs here

For more information about this error, try `rustc --explain E0499`.
error: could not compile `sieve` due to previous error
warning: build failed, waiting for other jobs to finish...
error: could not compile `sieve` due to previous error

借用规则与错误原因 #

核心借用规则 #

Rust的借用检查器是为了保证内存安全，核心规则如下：

• 同一时间，要么存在任意数量的不可变借用（&T），要么只能存在一个可变借用（&mut T），二者不可共存。
• 借用的生命周期不能超过被借用值的有效范围。

错误定位 #

你的代码中，for i in &vec（或错误信息中的&mut vec）会创建一个迭代器，这个迭代器持有vec的借用（不可变或可变），且该借用在整个循环周期内持续有效。而循环体中的vec[n as usize] = 0是对vec的可变借用，这就导致：

• 如果迭代器是不可变借用：同一时间既有不可变借用又有可变借用，违反规则。
• 如果迭代器是可变借用：同一时间存在两个可变借用（迭代器的借用和修改时的借用），同样违反规则。

简单说，你不能在遍历vec的同时修改它——迭代器依赖vec的原始状态，修改会让迭代器的有效性无法保证，Rust直接禁止了这种行为。

修复方案 #

方案1：先收集候选数再遍历 #

先把初始的候选素数（2到upper_bound）克隆到临时数组，遍历临时数组的元素去修改原vec，这样两次借用的对象不同，不会冲突：

pub fn primes_up_to(upper_bound: u64) -> Vec<u64> {
    let mut vec: Vec<u64> = (2..=upper_bound).collect();
    // 克隆初始候选数到临时数组，避免迭代原vec时修改它
    let candidates = vec.clone();
    
    for &i in &candidates {
        if i == 0 {
            continue;
        }
        let start = i * i;
        // 若平方超过上限，无需处理
        if start > upper_bound {
            continue;
        }
        // 计算起始索引：原vec从2开始，所以start对应的索引是start - 2
        let start_idx = (start - 2) as usize;
        // 从start_idx开始，按步长i标记非素数为0
        for idx in (start_idx..vec.len()).step_by(i as usize) {
            vec[idx] = 0;
        }
    }
    // 过滤掉标记为0的元素，得到最终素数列表
    vec.into_iter().filter(|&x| x != 0).collect()
}

方案2：遍历索引而非元素引用 #

直接遍历vec的索引，通过索引获取元素值，再修改指定位置。这种方式下，每次的借用都是短暂且不重叠的，编译器能识别并允许：

pub fn primes_up_to(upper_bound: u64) -> Vec<u64> {
    let mut vec: Vec<u64> = (2..=upper_bound).collect();
    let vec_len = vec.len();
    
    for idx in 0..vec_len {
        let i = vec[idx];
        // 已经被标记为非素数，跳过
        if i == 0 {
            continue;
        }
        let start = i * i;
        if start > upper_bound {
            continue;
        }
        let start_idx = (start - 2) as usize;
        for mark_idx in (start_idx..vec_len).step_by(i as usize) {
            vec[mark_idx] = 0;
        }
    }
    vec.into_iter().filter(|&x| x != 0).collect()
}

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