rust - 用子切片引用覆盖切片引用时出错

Question

我正在尝试确定所有权规则。我想:

• 从对切片的可变引用开始
• 对其内容进行一些修改
• 减少对子切片引用的切片引用并重复

下面是我的尝试:

pub fn example() {
    // Make a mutable slice
    let mut v = [0, 1, 2, 3];

    // Make a mutable reference to said slice
    let mut v_ref = &mut v[..];

    while v_ref.len() > 1 {
        // Involves some edits -> need mut
        v_ref.swap(0, v_ref.len() - 1);

        // Try to reduce slice to sub-slice (some simplification here)
        // Errors!
        let (v_l, v_h) = v.split_at_mut(v.len() / 2);
        v_ref = v_l;
    }
}

但是我得到了错误:

error[E0502]: cannot borrow `*v_ref` as immutable because it is also borrowed as mutable
  --> src/lib.rs:11:23
   |
11 |         v_ref.swap(0, v_ref.len() - 1);
   |         -----         ^^^^^          - mutable borrow ends here
   |         |             |
   |         |             immutable borrow occurs here
   |         mutable borrow occurs here

error[E0499]: cannot borrow `v` as mutable more than once at a time
  --> src/lib.rs:15:26
   |
7  |     let mut v_ref = &mut v[..];
   |                          - first mutable borrow occurs here
...
15 |         let (v_l, v_h) = v.split_at_mut(v.len() / 2);
   |                          ^ second mutable borrow occurs here
...
18 | }
   | - first borrow ends here

error[E0502]: cannot borrow `v` as immutable because it is also borrowed as mutable
  --> src/lib.rs:15:41
   |
7  |     let mut v_ref = &mut v[..];
   |                          - mutable borrow occurs here
...
15 |         let (v_l, v_h) = v.split_at_mut(v.len() / 2);
   |                                         ^ immutable borrow occurs here
...
18 | }
   | - mutable borrow ends here

我知道您不能在与单个可变引用相同的范围内对一个对象有多个引用。

应该有一种安全的方法来缩小切片的范围，因为您只是在缩小当前可变引用的范围。最好的方法是什么？

Answer 1

问题 1:可变地和不可变地使用同一个变量

作为Peter Hall points out ，代码尝试引用变量 v，同时存在对它的并发可变引用，即使您不再关心 v_ref。一个 MCVE:

pub fn example() {
    let mut v = 0;
    let mut v_ref = &mut v;
    println!("{}", v)
}

另见:

• What are non-lexical lifetimes?

问题2:可变和不可变地使用同一个变量

然后代码尝试在单个函数调用中重叠可变和可变借用。一个 MCVE:

pub fn example() {
    let mut v = [0, 1, 2, 3];
    v.split_at_mut(v.len());
}

另见:

• Cannot borrow as immutable because it is also borrowed as mutable in function arguments

问题3:可变地和可变地使用同一个变量

然后代码在循环中重叠了 v 的可变借用。

另见:

• Cannot obtain a mutable reference when iterating a recursive structure: cannot borrow as mutable more than once at a time

---

一起:

pub fn example() {
    let mut v = [0, 1, 2, 3];
    let mut v_ref = &mut v[..];

    while v_ref.len() > 1 {
        let len = v_ref.len();
        v_ref.swap(0, len - 1);
        let (v_l, _) = { v_ref }.split_at_mut(len / 2);
        v_ref = v_l;
    }
}