Question

fn main() {
    let mut foo = 1;

    let mut func = || foo += 1;
    while foo < 5 {
        func();
    }
}

error[E0503]: cannot use `foo` because it was mutably borrowed
 --> src/main.rs:5:11
  |
4 |     let mut func = || foo += 1;
  |                    -- borrow of `foo` occurs here
5 |     while foo < 5 {
  |           ^^^ use of borrowed `foo`

我理解为什么这不起作用，但我正在寻找一种绕过借用检查器的方法。有没有办法在这里使用闭包？除了使用函数之外还有其他好的选择吗？我有一种情况需要改变几个变量。

Answer 1

你有一个选择是将一个可变引用传递给闭包，而不是通过环境捕获隐式地借用它：

fn main() {
    let mut foo = 1;

    let func = |foo: &mut i32| *foo += 1;

    while foo < 5 {
       func(&mut foo);
    }
}

playground

Answer 2

否，你不能这样做。虽然闭包有可变借用，但没有其他东西可以访问该变量。

，而不是...

运行时可变性XOR别名执行

您可以使用Cell或RefCell：

use std::cell::Cell;

fn main() {
    let foo = Cell::new(1);

    let func = || foo.set(foo.get() + 1);

    while foo.get() < 5 {
        func();
    }
}

另见：

让闭包处理所有内容

您可以将比较烘焙到闭包中：

fn main() {
    let mut foo = 1;

    let mut func = || {
        foo += 1;
        foo < 5
    };

    while func() {}
}

使用结构

struct Thing(i32);

impl Thing {
    fn do_it(&mut self) {
        self.0 += 1
    }

    fn test_it(&self) -> bool {
        self.0 < 5
    }
}

fn main() {
    let mut foo = Thing(1);

    while foo.test_it() {
        foo.do_it();
    }
}

我怎样才能使用一个在一个循环中可变地捕获变量的闭包来检查相同的值？

2 个答案:

运行时可变性XOR别名执行

让闭包处理所有内容

使用结构