Rust 如何使用在检查相同值的循环中可变捕获变量的闭包？ fn main（）{ 设mut-foo=1； 设mut func=| | foo+=1； 而foosrc/main.rs:5:11 | 4 |设mut func=| | foo+=1； |“foo”的借词出现在这里 5 |而foo

我理解为什么这样做不起作用，但我正在寻找一种绕过借阅检查器的方法。这里有没有一种方法可以使用闭包？除了使用函数之外，还有什么好的选择吗？我遇到了一种情况，我必须更改几个变量。

一种方法是将可变引用传递给闭包，而不是隐式引用ITL通过环境捕获借用它：

fn main() {
    let mut foo = 1;

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

fn main（）{
设mut-foo=1；
设func=|foo:&mut i32 |*foo+=1；
而foo<5{
func（和mut-foo）；
}
}

---

否，您无法执行此操作。虽然闭包具有可变借用，但其他任何内容都无法访问该变量

相反

运行时可变异或别名强制 您可以使用

单元格

或

参考单元格

：

fn main() {
    let mut foo = 1;

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

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

使用std:：cell:：cell；
fn main（）{
设foo=Cell:：new（1）；
设func=| | foo.set（foo.get（）+1）；
而foo.get（）<5{
func（）；
}
}

另见：

让闭包来处理一切 可以将比较烘焙到闭包中：

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（）{
设mut-foo=1；
设mut func=||{
foo+=1；
foo<5
};
while func（）{}
}

使用结构

struct-Thing（i32）；
暗示的事情{
fn do_it（&mut self）{
self.0+=1
}
fn测试（自身）->bool{
自我评价0<5
}
}
fn main（）{
设mut-foo=Thing（1）；
而foo.test_it（）{
foo.do_it（）；
}
}

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();
    }
}