Question

在以下示例中：

struct SimpleMemoryBank {
    vec: Vec<Box<i32>>,
}

impl SimpleMemoryBank {
    fn new() -> SimpleMemoryBank {
        SimpleMemoryBank{ vec: Vec::new() }
    }

    fn add(&mut self, value: i32) -> &mut i32 {
        self.vec.push(Box::new(value));
        let last = self.vec.len() - 1;
        &mut *self.vec[last]
    }
}

fn main() {
    let mut foo = SimpleMemoryBank::new();

    // Works okay
    foo.add(1);
    foo.add(2);

    // Doesn't work: "cannot borrow `foo` as mutable more than once at a time"
    let one = foo.add(1);
    let two = foo.add(2);
}

只要我不存储函数调用的结果，就可以连续多次调用

add()。但是如果我存储函数的结果（let one = ...），那么我得到错误：

problem.rs:26:15: 26:18 error: cannot borrow `foo` as mutable more than once at a time
problem.rs:26     let two = foo.add(2);
                            ^~~
problem.rs:25:15: 25:18 note: previous borrow of `foo` occurs here; the mutable borrow prevents subsequent moves, borrows, or modification of `foo` until the borrow ends
problem.rs:25     let one = foo.add(1);
                            ^~~
problem.rs:27:2: 27:2 note: previous borrow ends here
problem.rs:17 fn main() {
...
problem.rs:27 }
              ^
error: aborting due to previous error

这是issue #6393: borrow scopes should not always be lexical的表现吗？

我该如何解决这个问题？基本上，我想向向量添加一个新的Box，然后返回对它的引用（这样调用者就可以使用它）。

Answer 1

这正是Rust旨在阻止您造成的问题。如果你这样做会发生什么：

let one = foo.add(1);
foo.vec.clear();
println!("{}", one);

或者如果foo.add通过在向量的开头处推送新值，该怎么办？坏事会发生！主要的是，当你借用一个变量时，你不能再改变变量了。如果你能够改变它，那么你可能会使借用的内存无效，然后你的程序可以做很多事情，最好的情况就是它会崩溃。

这是问题＃6393的表现：借用范围不应该总是词汇吗？

有点但不是真的。在此示例中，您从不使用one或two，因此理论上非词法范围将允许它进行编译。但是，您可以说明

我想在向量中添加一个新Box，然后返回对它的引用（这样调用者就可以使用它）

这意味着您的真实代码想成为

let one = foo.add(1);
let two = foo.add(2);
do_something(one);
do_something(two);

因此变量的生命周期会重叠。

在这种情况下，如果您只想要一个地方来存储无法单独解除分配的变量，请不要相互重叠，并且无法移动，请尝试使用TypedArena：

extern crate arena;

use arena::TypedArena;

fn main() {
    let arena = TypedArena::new();
    let one = arena.alloc(1);
    let two = arena.alloc(2);

    *one = 3;
    println!("{}, {}", one, two);
}

为什么我不能连续两次调用一个可变方法（并存储结果）？

1 个答案: