Question

我试图制作类似＆＃34;回调系统＆＃34;。例如，有一个窗口和几个按钮。该窗口为每个按钮设置回调。两个回调都应该改变窗口的状态。编译器不允许在我的闭包/回调中捕获&self，而且我不知道如何使其工作。

我应该遵循回调的常见模式吗？

这是一个简单的例子，因为所有组件都具有相同的生命周期。如果组件的生命周期不同会怎么样？

struct Button<'a> {
    f: Option<Box<Fn() + 'a>>,
}

impl<'a> Button<'a> {
    fn new() -> Button<'a> { Button { f: None } }
    fn set<T: Fn() + 'a>(&mut self, f: T) { self.f = Some(Box::new(f)); }
    fn unset(&mut self) { self.f = None; }
    fn call(&self) { match self.f { Some(ref f) => f(), None => () } }
}

struct Window<'a> {
    btn: Button<'a>,
    //btns: Vec<Button<'a>>,
}

impl<'a> Window<'a> {
    fn new() -> Window<'a> {
        Window { btn: Button::new() }
    }

    fn hi(&mut self) { // self is mutable
        println!("callback");
    }

    fn run(&mut self) {
        // Compile error: cannot infer an appropriate lifetime for
        // capture of `self` by closure due to conflicting requirements
        self.btn.set(|| self.hi()); // How to make it work?
        self.btn.call();
        self.btn.unset();
    }
}

fn main() {
    let mut wnd = Window::new();
    wnd.run();
}

Answer 1

这条线路会立即遇到问题：

self.btn.set(|| self.hi());

在这里，您需要借用self作为可变对象来修改btn。您还试图在闭包中借用self作为可变对象。这将立即遇到问题，因为Rust不允许您对同一对象进行多次可变引用（称为别名）。这是该语言的记忆安全保证的基本部分。

此外，从概念上讲，您正在尝试设置引用循环 - Window知道Button和Button知道Window。虽然这是可能的，但通常不是你想要的。一旦参考文献有一个循环，就很难解开它们。您还可以搜索有关在Rust中创建图形的其他问题（而不是树），以查看其他人遇到的类似问题。

理想情况下，您可以将代码构建为树。在这里，我选择Button可以了解Window，但反之亦然：

struct Button<'a> {
    f: Option<Box<FnMut() + 'a>>,
}

impl<'a> Button<'a> {
    fn new() -> Button<'a> { Button { f: None } }
    fn set<T: FnMut() + 'a>(&mut self, f: T) { self.f = Some(Box::new(f)); }
    fn unset(&mut self) { self.f = None; }
    fn call(&mut self) { match self.f { Some(ref mut f) => f(), None => () } }
}

struct Window;

impl Window {
    fn hi(&mut self) {
        println!("callback");
    }
}

fn main() {
    let mut wnd = Window;
    let mut btn = Button::new();
    btn.set(|| wnd.hi());
    btn.call();
    btn.unset();
}

使用闭包创建回调系统

1 个答案: