Rust 如果值超过闭包，那么在闭包之间共享引用的正确方法是什么？

我想在两个闭包之间共享一个引用；在一个闭包中可变。这是一种人为的情况，但我发现在学习生锈的背景下，这很有趣

为了让它工作，我必须使用

Rc

、

Weak

和

RefCell

。有没有更简单的方法来实现这一点

use std::cell::RefCell;
use std::rc::Rc;

#[derive(Debug)]
struct Foo {
    i: i32,
}

impl Foo {
    fn get(&self) -> i32 {
        self.i
    }
    fn incr(&mut self) {
        self.i += 1
    }
}

fn retry<O, N>(mut operation: O, mut notify: N) -> i32
where
    O: FnMut() -> i32,
    N: FnMut() -> (),
{
    operation();
    notify();
    operation()
}

fn something(f: &mut Foo) {
    let f_rc = Rc::new(RefCell::new(f));
    let f_weak = Rc::downgrade(&f_rc);

    let operation = || {
        // f.get()
        let cell = f_weak.upgrade().unwrap();
        let f = cell.borrow();
        f.get()
    };

    let notify = || {
        // f.incr();
        let cell = f_weak.upgrade().unwrap();
        let mut f = cell.borrow_mut();
        f.incr();
    };

    retry(operation, notify);

    println!("{:?}", f_rc);
}

fn main() {
    let mut f = Foo { i: 1 };
    something(&mut f);
}

使用std:：cell:：RefCell；
使用std:：rc:：rc；
#[导出（调试）]
结构Foo{
i:i32，
}
impl-Foo{
fn获取（&self）->i32{
赛尔夫，我
}
fn增量（和多个自身）{
self.i+=1
}
}
fn重试（mut操作：O，mut通知：N）->i32
哪里
O:FnMut（）->i32，
N:FnMut（）->（），
{
操作（）；
通知（）；
操作（）
}
fn某物（f:&mut-Foo）{
设f_rc=rc:：new（RefCell:：new（f））；
设f_弱=Rc:：降级（&f_Rc）；
让运算=| |{
//f.获得（）
让cell=f_弱。升级（）。展开（）；
设f=cell.borrow（）；
f、 得到（）
};
让我们通知{
//f.增量（）；
让cell=f_弱。升级（）。展开（）；
设mut f=cell.borrow_mut（）；
f、 增量（）；
};
重试（操作、通知）；
println！（“{：？}”，f_rc）；
}
fn main（）{
设mutf=Foo{i:1}；
某物（&mut f）；
}

这里不需要引用计数，因为实体的寿命比任何闭包都长。你可以逃脱：

fn something(f: &mut Foo) {
    let f = RefCell::new(f);

    let operation = || f.borrow().get();
    let notify = || {
        f.borrow_mut().incr();
    };

    retry(operation, notify);

    println!("{:?}", f);
}

这相当简单

然而，使用

RefCell

，将别名异或可变性的实施从编译时转移到运行时是必要的