如何同时获取两个数组元素的可变引用？该问题涉及IT技术。

Question

fn change(a: &mut i32, b: &mut i32) {
    let c = *a;
    *a = *b;
    *b = c;
}

fn main() {
    let mut v = vec![1, 2, 3];
    change(&mut v[0], &mut v[1]);
}

当我编译上述代码时，会出现错误：

error[E0499]: cannot borrow `v` as mutable more than once at a time
 --> src/main.rs:9:32
  |
9 |         change(&mut v[0], &mut v[1]);
  |                     -          ^   - first borrow ends here
  |                     |          |
  |                     |          second mutable borrow occurs here
  |                     first mutable borrow occurs here

编译器为何会禁止这样做？v[0] 和 v[1] 占据不同的内存位置，所以同时使用它们并不会有危险。如果我遇到这个问题该怎么办？

- user2925565

---

请注意，在这种情况下，您可以使用<[T]>::swap()。 - Chayim Friedman

Answer 1

你可以使用 split_at_mut() 来解决这个问题：

let mut v = vec![1, 2, 3];
let (a, b) = v.split_at_mut(1);   // Returns (&mut [1], &mut [2, 3])
change(&mut a[0], &mut b[0]); 

有很多安全的操作，但编译器尚未识别。 split_at_mut() 就是这样一个安全的抽象，内部使用了 unsafe 块实现。

对于这个问题，我们也可以这样做。以下是我在需要分离所有三种情况（I：索引超出范围，II：索引相等，III：分离索引）的代码中使用的方法。

enum Pair<T> {
    Both(T, T),
    One(T),
    None,
}

fn index_twice<T>(slc: &mut [T], a: usize, b: usize) -> Pair<&mut T> {
    if a == b {
        slc.get_mut(a).map_or(Pair::None, Pair::One)
    } else {
        if a >= slc.len() || b >= slc.len() {
            Pair::None
        } else {
            // safe because a, b are in bounds and distinct
            unsafe {
                let ar = &mut *(slc.get_unchecked_mut(a) as *mut _);
                let br = &mut *(slc.get_unchecked_mut(b) as *mut _);
                Pair::Both(ar, br)
            }
        }
    }
}

- bluss

Answer 2

自 Rust 1.26 版本起，可以对切片进行模式匹配。只要您的索引不是太大并且这些索引在编译时已知，就可以使用此功能。

fn change(a: &mut i32, b: &mut i32) {
    let c = *a;
    *a = *b;
    *b = c;
}

fn main() {
    let mut arr = [5, 6, 7, 8];
    {
        let [ref mut a, _, ref mut b, ..] = arr;
        change(a, b);
    }
    assert_eq!(arr, [7, 6, 5, 8]);
}

- oli_obk

Answer 3

Rust的借用规则需要在编译时进行检查，这就是为什么像可变地借用Vec的一部分这样的问题很难解决（如果不是不可能的），也是为什么它在Rust中不可能实现的原因。

因此，当您执行像&mut v[i]这样的操作时，它将可变地借用整个向量。

想象一下，我做了这样的事情

let guard = something(&mut v[i]);
do_something_else(&mut v[j]);
guard.do_job();

在这里，我创建了一个对象guard，它内部存储了对v[i]的可变引用，并且在调用do_job()时将对其进行操作。

与此同时，我做了一些改变，改变了v[j]。 guard持有一个可变引用，应该保证没有其他东西可以修改v[i]。在这种情况下，只要i和j不相等，一切都很好；如果两个值相等，则违反了借用规则。

由于编译器无法保证 i！= j ，因此被禁止。

这是一个简单的例子，但类似的情况很多，这就是为什么这样的访问会可变地借用整个容器的原因。另外，编译器实际上并不了解Vec的内部情况，无法确保即使 i！= j 也是安全的。

---

在您的特定情况下，您可以查看Vec上可用的swap(..)方法，该方法执行您手动实现的交换。

在更普遍的情况下，您可能需要另一个容器。可能性是将Vec的所有值包装到具有内部可变性的类型中，例如Cell或RefCell，甚至使用完全不同的容器，如@llogiq在其答案中建议的par-vec。

- Levans

Answer 4

最近的nightly版本中，新增了get_many_mut()方法:

#![feature(get_many_mut)]

fn main() {
    let mut v = vec![1, 2, 3];
    let [a, b] = v
        .get_many_mut([0, 1])
        .expect("out of bounds or overlapping indices");
    change(a, b);
}

- Chayim Friedman

Answer 5

方法 [T]::iter_mut() 返回一个迭代器，它可以为切片中的每个元素生成可变引用。其他集合也有 iter_mut 方法。这些方法通常封装了不安全的代码，但它们的接口是完全安全的。

这里有一个通用的扩展特性，它在切片上添加了一个方法，通过索引返回两个不同的可变引用：

pub trait SliceExt {
    type Item;

    fn get_two_mut(&mut self, index0: usize, index1: usize) -> (&mut Self::Item, &mut Self::Item);
}

impl<T> SliceExt for [T] {
    type Item = T;

    fn get_two_mut(&mut self, index0: usize, index1: usize) -> (&mut Self::Item, &mut Self::Item) {
        match index0.cmp(&index1) {
            Ordering::Less => {
                let mut iter = self.iter_mut();
                let item0 = iter.nth(index0).unwrap();
                let item1 = iter.nth(index1 - index0 - 1).unwrap();
                (item0, item1)
            }
            Ordering::Equal => panic!("[T]::get_two_mut(): received same index twice ({})", index0),
            Ordering::Greater => {
                let mut iter = self.iter_mut();
                let item1 = iter.nth(index1).unwrap();
                let item0 = iter.nth(index0 - index1 - 1).unwrap();
                (item0, item1)
            }
        }
    }
}

- Francis Gagné

Answer 6

在@bluss的回答的基础上，您可以使用split_at_mut()来创建一个函数，将向量的可变借用转换为向量元素的可变借用向量：

    fn borrow_mut_elementwise<'a, T>(v:&'a mut Vec<T>) -> Vec<&'a mut T> {
        let mut result:Vec<&mut T> = Vec::new();
        let mut current: &mut [T];
        let mut rest = &mut v[..];
        while rest.len() > 0 {
            (current, rest) = rest.split_at_mut(1);
            result.push(&mut current[0]);
        }
        result
    }

然后你可以使用它来获取一个绑定，让你一次性地改变原始 Vec 中的多个项，即使你在迭代它们时（如果你在循环中通过索引访问它们，而不是通过任何迭代器）。

    let mut items = vec![1,2,3];
    let mut items_mut = borrow_mut_elementwise(&mut items);
    for i in 1..items_mut.len() {
        *items_mut[i-1] = *items_mut[i];
    }
    println!("{:?}", items); // [2, 3, 3]

- Kamil Szot

Answer 7

我将我的日常工具发布到crate.io上。文档链接。

你可以像这样使用它。

use arref::array_mut_ref;
let mut arr = vec![1, 2, 3, 4];
let (a, b) = array_mut_ref!(&mut arr, [1, 2]);
assert_eq!(*a, 2);
assert_eq!(*b, 3);
let (a, b, c) = array_mut_ref!(&mut arr, [1, 2, 0]);
assert_eq!(*c, 1);

// ⚠️ The following code will panic. Because we borrow the same element twice.
// let (a, b) = array_mut_ref!(&mut arr, [1, 1]);

这是一个简单的包装器，包装以下代码，代码本身是可靠的。但是运行时需要确保两个索引不同。

pub fn array_mut_ref<T>(arr: &mut [T], a0: usize, a1: usize) -> (&mut T, &mut T) {
    assert!(a0 != a1);
    // SAFETY: this is safe because we know a0 != a1
    unsafe {
        (
            &mut *(&mut arr[a0] as *mut _),
            &mut *(&mut arr[a1] as *mut _),
        )
    }
}

或者，您可以使用一种不会因为 mut_twice 而导致程序崩溃的方法。

#[inline]
pub fn mut_twice<T>(arr: &mut [T], a0: usize, a1: usize) -> Result<(&mut T, &mut T), &mut T> {
    if a0 == a1 {
        Err(&mut arr[a0])
    } else {
        unsafe {
            Ok((
                &mut *(&mut arr[a0] as *mut _),
                &mut *(&mut arr[a1] as *mut _),
            ))
        }
    }
}

- zxch3n

Answer 8

问题在于&mut v[…]首先可变借用了v，然后将可变引用交给了改变函数。

这个Reddit评论有一个解决方案。

编辑：感谢Shepmaster的提醒。par-vec是一个库，允许可变地借用vec的不相交分区。

- llogiq

---

请将解决方案嵌入文本中。链接会随时间失效。 - Shepmaster