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]占据不同的记忆位置，因此将它们组合在一起并不危险。如果我遇到这个问题该怎么办？
答案 0 :(得分：26)
您可以使用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：Index out of bounds，II：Indices equal，III：Separate indices）。
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)
}
}
}
}
答案 1 :(得分：8)
需要在编译时检查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(..) method。
在更通用的情况下，您可能需要另一个容器。可能性是将Vec的所有值包装成具有内部可变性的类型，例如Cell或RefCell，或甚至使用完全不同的容器，如@llogiq在其回答中所建议的那样par-vec
答案 2 :(得分：8)
在夜间频道上，可以使用切片进行模式匹配。您可以使用它，只要您没有大量索引并且您的索引在编译时就已知。
#![feature(slice_patterns)]
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 &mut [ref mut a, _, ref mut b, _..] = &mut arr;
change(a, b);
}
assert_eq!(arr, [7, 6, 5, 8]);
}
请注意，您需要启用功能slice_patterns。
答案 3 :(得分：3)
方法[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)
}
}
}
}
答案 4 :(得分：2)
您无法对同一数据进行两次可变引用。这是借用检查器明确禁止的，以防止并发修改。但是，您可以使用unsafe块绕过借用检查器。
虽然在您的情况下v[0]和v[1]明显是单独的块，但这并不会受到严格的审查。如果v是某种名为NullMap的地图，将所有元素映射到单个字段，该怎么办？编译器如何知道Vec操作v[0];v[1];是安全的，但在NullMap中是不是<？p？
如果您尝试交换数组的两个元素，为什么不去slice::swap？
fn main() {
let mut v = vec![1, 2, 3];
v.swap(0,1);
println!("{:?}",v);
}
同样v需要mut，因为您正在更改向量。不可变版本将克隆并对其执行交换。
答案 5 :(得分：0)