rust - 为什么滴胶有时不跑？

Question

我在其他情况下也遇到过这种情况，但不会重复发生。

基本上，有时当你有一个 *mut Foo , 然后你把它变成一个 Foo使用 ptr::read() ，有时您的滴胶似乎没有运行。

这是一个可重复的示例，它在不使用 FFI 的情况下在 playpen 上运行(这是您将原始指针提升回对象的主要原因):http://is.gd/X6vdAK

use std::ptr::read;
use std::mem::forget;

#[repr(C)]
struct Foo {
  id: i32,
  dispose:Option<Box<Fn(Foo) + 'static>> //'
}

impl Foo {
  pub fn new(id:i32) -> Foo {
    return Foo {
        id: id,
        dispose: None
    };
  }
  pub fn release(mut self) {
    if self.dispose.is_some() {
      self.dispose.take().unwrap()(self);
    }
  }
}

impl Drop for Foo {
  fn drop(&mut self) {
    println!("Discarding a foo with dispose of {:?}", self.dispose.is_some());
  }
}

#[repr(C)]
struct Goblin {
  foo:Foo,
  angry: bool,
  friends: i32
}

#[repr(C)]
struct Bat {
  foo:Foo,
  hungry: bool
}

#[repr(C)]
struct Dragon {
  foo:Foo,
  lairs: i32
}

trait IsFoo {
  fn foo(&mut self) -> &mut Foo; 
  fn as_foo<T: IsFoo>(mut self) -> Foo where Self: Sized {
    let ptr:*const Foo = self.foo() as *mut Foo;
    {
        self.foo().dispose = Some(Box::new(|&:foo:Foo| {
          println!("Incoming release for id {}", foo.id);
          unsafe {
            let tmp = &foo as *const Foo as *const T; // Avoid ICE. :(
            let mut instance:T = read::<T>(tmp);
            println!("Dropping instance with id: {}", instance.foo().id);
            drop(instance);
          }
        }));
    }
    unsafe { 
        let rtn = read(ptr);
        forget(self);
        return rtn;
    }
  }
}
impl IsFoo for Bat { fn foo(&mut self) -> &mut Foo { return &mut self.foo; } }
impl IsFoo for Goblin { fn foo(&mut self) -> &mut Foo { return &mut self.foo; } }
impl IsFoo for Dragon { fn foo(&mut self) -> &mut Foo { return &mut self.foo; } }

// Test drops work
impl Drop for Bat { fn drop(&mut self) { println!("Dropped a Bat"); } }
impl Drop for Goblin { fn drop(&mut self) { println!("Dropped a Goblin....!"); } }
impl Drop for Dragon { fn drop(&mut self) { println!("Dropped a Dragon"); } }

fn main() {
  {
    // Generic collection
    let monsters:Vec<Foo> = vec!(
      Bat { foo: Foo::new(1), hungry: true }.as_foo::<Bat>(),
      Goblin { foo: Foo::new(2), angry: true, friends: 100 }.as_foo::<Goblin>(),
      Dragon { foo: Foo::new(3), lairs: 33 }.as_foo::<Dragon>()
    );

    println!("Vector exists without dropping contents");

    // Cleanup
    for m in monsters.into_iter() { 
      println!("Dropping an instance: {}", m.id);
      m.release(); 
    }
  }
}

这里的输出是:

Vector exists without dropping contents
Dropping an instance: 1
Incoming release for id 1
Dropping instance with id: 1
Discarding a foo with dispose of false
Dropping an instance: 2
Incoming release for id 2
Dropping instance with id: 2
Discarding a foo with dispose of false
Dropping an instance: 3
Incoming release for id 3
Dropping instance with id: 3
Discarding a foo with dispose of false

即虽然我正在转换引用 *mut Foo进入 T在封口处，滴胶用于Goblin , Dragon & Bat不运行。

如果您稍微调整代码，例如 http://is.gd/mRzj8H ，您可以运行这些(或其中一些):

Vector exists without dropping contents
Dropping an instance: 1
Dropped a Bat
Dropping an instance: 2 <--- WTF, the others work but this one doesn't?
Dropping an instance: 3
Dropped a Dragon

我在这里看到的是某种竞争条件的产物，还是更复杂的东西？

Answer 1

尝试使用不同的优化级别编译您的程序。 (在 Rust playpen 上有一个下拉菜单；默认是 -O2。)您会看到输出不一致。在这种情况下，您正在调用未定义的行为。

当您向 Vec 添加项目时，您会创建包含 Foo 的 Bat 对象，然后您只需添加 Vec 中的 Foo。 Bat 不再存在。 IsFoo::as_foo 按值获取 Bat，这意味着它获取了所有权它。 Bat 在 as_foo 的末尾实际上被丢弃了，但是您通过调用 forget 抑制了丢弃胶水。

在您的“处置”lambda 中，您尝试通过将指向 Foo 的指针转换为指向 Bat 的指针来取回 Bat。这是未定义的行为，因为向量只包含Foo，而不是整个Bat。请记住，Bat 在离开 IsFoo::as_foo 时被销毁。

使用 -O2 和 -O3，程序可能根本没有创建 Vec，而 Bat、Dragon 和 Goblin 值在堆栈中仍然完好无损。但是，Goblin 没有 #[repr(C)]，而其他两个有，所以这可能就是析构函数不只在那个上运行的原因.