Rust简单模式闭包生命周期问题：双结构体回调场景编译失败如何重构

你的代码编译失败的核心是Rust对trait对象的默认生命周期约束：Box<dyn Fn()>默认要求实现'static生命周期，而你创建的闭包捕获了Foo实例的临时引用&self，该引用的生命周期短于'static，因此无法满足约束。

这里提供两种最常用的适配方案，你可以根据自己的业务场景选择：

方案1：添加生命周期标注（零运行时开销） #

如果你的使用场景可以保证Bar实例的生命周期永远短于对应的Foo实例，可以直接通过生命周期标注明确二者的绑定关系，完全不需要额外运行时开销：

// 为Bar添加生命周期标注，明确闭包的生命周期和外部引用绑定
struct Bar<'a> {
    closure: Box<dyn Fn() + 'a>,
}

struct Foo {
    value: bool,
}

impl Foo {
    fn new() -> Self {
        Foo { value: false }
    }
    // 标注生命周期，明确Bar的生命周期不超过当前Foo实例
    fn set_closure<'a>(&'a self, b: &mut Bar<'a>) {
        b.closure = self.get_closure();
    }
    fn get_closure<'a>(&'a self) -> Box<dyn Fn() + 'a> {
        Box::new(|| {
            if self.value {
                println!("true");
            } else {
                println!("false");
            }
        })
    }
}

impl<'a> Bar<'a> {
    fn new() -> Self {
        Bar {
            closure: Box::new(|| {}),
        }
    }
}

fn main() {
    let foo = Foo::new();
    let mut bar = Bar::new();
    foo.set_closure(&mut bar);
    let closure = bar.closure;
    closure(); // 输出 false
}

方案2：使用智能指针共享所有权（灵活通用） #

如果你需要后续修改Foo的value值也能同步到闭包逻辑，或者不想处理生命周期标注，可以用Rc<RefCell<>>组合实现共享可变性，这是Rust中回调场景的常用写法：

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

struct Foo {
    value: bool,
}

struct Bar {
    closure: Box<dyn Fn()>,
}

impl Foo {
    fn new() -> Rc<RefCell<Self>> {
        Rc::new(RefCell::new(Foo { value: false }))
    }
    // 接收Rc包裹的Foo实例，把所有权复制一份move到闭包里
    fn set_closure(self: &Rc<RefCell<Self>>, b: &mut Bar) {
        let self_clone = self.clone();
        b.closure = Box::new(move || {
            let this = self_clone.borrow();
            if this.value {
                println!("true");
            } else {
                println!("false");
            }
        });
    }
}

impl Bar {
    fn new() -> Self {
        Bar {
            closure: Box::new(|| {}),
        }
    }
}

fn main() {
    let foo = Foo::new();
    let mut bar = Bar::new();
    foo.set_closure(&mut bar);
    
    // 后续修改Foo的值也会生效
    foo.borrow_mut().value = true;
    
    let closure = bar.closure;
    closure(); // 输出 true
}

内容的提问来源于stack exchange，提问作者Bogdan