使用自我回调

Question

我正在尝试使用使用对象的自我参数的回调。阻止此编译的部分是self.make_sandwhich（）位。我该如何做这样的事情并实际上将其编译为Rust？目的是使Thinguser能够为事物指定功能。在这种情况下，当您垃圾土豆时，用户会制作一个沙子。

pub trait Thing {
  fn stuff(&self);
  fn junk(&mut self);
}

pub struct Potato {
    thing: Box<dyn FnMut()+Send>,
}

impl Potato {
  fn new() -> Self {
    Self{
        thing: Box::new(||{println!("Original callback");}),
    }
  }
  
  fn give_callback(&mut self, thing: Box<dyn FnMut()+Send>) {
      self.thing = thing;
  }
}

impl Thing for Potato {
  fn stuff(&self) {
  }
  fn junk(&mut self) {
    (self.thing)();
  }
}

fn make_thing() -> Box<dyn Thing> {
    Box::new(Potato::new())
}

pub trait ThingUser {
    fn get_thing(&mut self) -> Option<Box<dyn Thing>>;
}

pub struct Person {
    
}

impl Person {
    fn make_sandwhich(&self) {
        println!("I made a sandwhich");
    }
}

impl ThingUser for Person {
    fn get_thing(&mut self) -> Option<Box<dyn Thing>> {
        let mut p = Potato::new();
        p.give_callback(Box::new(||{self.make_sandwhich()}));
        Some(Box::new(p))
    }
}

fn main() {
    println!("Hello, world!");
  let mut p  = Potato::new();
  p.stuff();
  
  p.give_callback(Box::new(||{println!("Callback");}));
  (p.thing)();
  p.junk();
  
  let mut q = make_thing();
  q.junk();
  
  let mut tu = Person{};
  let used_thing = tu.get_thing();
  used_thing.unwrap().junk();
}

Answer 1

您发布的设计无法正常工作。在Thinguser :: get_thing中采用＆amp; mut self，这意味着self是类型＆amp; mut dyn thinguser的借用。闭合|| {self.make_sandwhich（）}还必须借用self（尽管它只需要非 - mut ＆amp; dyn thinguser to调用make_sand）。 self的借用只要封闭生活就必须生存。

但是，您想将封闭存储在马铃薯中。这意味着在存储马铃薯也是借用的＆amp; thiteuser，但是马铃薯根本没有定义任何东西（马铃薯的定义中没有终身参数）。因此，您将能够将任何关闭传递给give_callback 必须具有'static lifeTime（这意味着它不借任何东西，除了可能是整个程序长度的生活）。

这就是您的编译器错误所表达的内容（游乐场）

error: lifetime may not live long enough
  --> src/main.rs:51:25
   |
49 |     fn get_thing(&mut self) -> Option<Box<dyn Thing>> {
   |                  - let's call the lifetime of this reference `'1`
50 |         let mut p = Potato::new();
51 |         p.give_callback(Box::new(||{self.make_sandwhich()}));
   |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ cast requires that `'1` must outlive `'static`

编译器正在阻止您这样做：

let person = Person {};
let mut potato = Potato::new();
p.give_callback(Box::new(|| { person.make_sandwhich() } ));
drop(person);
potato.junk(); // ! This would be trying to call `person.make_sandwhich()`, but `person` has been dropped! This is a horrible memory safety error!

---

从广义上讲，您有两个选择。

首先是用终身参数定义马铃薯，但这会随着终生参数与马铃薯类型绑定而迅速变得凌乱，并且几乎可以使每种用途的用途复杂化potagy>马铃薯曾经。

第二个（可能是最好的）选项是使您的关闭具有'静态寿命。例如，可以通过将您的人存储在arc＆lt; person＆gt;中来完成。然后，您使用移动封闭来创建一个拥有arc＆lt; person＆gt;的关闭，以便person才能删除直到删除关闭之前。例如

let person = Arc::new(Person {});
let mut potato = Potato::new();
let person_clone = person.clone();  // Not strictly necessary for this simple example, but I'm assuming you might want access to `person` after creating the callback in which case this is necessary
p.give_callback(Box::new(move || { person_clone.make_sandwhich() } ));
drop(person);
potato.junk(); // This is now fine! The first `Arc<Person>` was dropped, but the closure is still holding one so the internal `Person` object has not been dropped. Hooray!

P.S.我强烈建议您使用Rustfmt格式化您的代码（理想情况下，每个保存）。它会让您更快地编写它，并将帮助人们阅读它。