Rust 为什么在结构分解后会有掉话？

我正在包装一个C API。为了简化这个问题，我使用了

NonNull:：dangling

use std::ptr::NonNull;

struct Foo(NonNull<i32>);

impl Drop for Foo {
    fn drop(&mut self) {
        println!("Foo::drop: {:?}", self.0);
    }
}

struct Moo(NonNull<i32>);
//impl Drop for Moo exists, but not important for question

fn f1() -> Result<Foo, String> {
    Ok(Foo(unsafe { NonNull::dangling() }))
}

fn f2() -> Result<Moo, String> {
    f1().map(|Foo(x)| Moo(x))//1
}

fn main() {
    f2();
}

使用std:：ptr:：NonNull；
结构Foo（非空）；
为Foo的impl Drop{
fn下降（&mut自我）{
println！（“Foo:：drop:{：？}”，self.0）；
}
}
结构Moo（非空）；
//存在Moo的impl Drop，但对问题不重要
fn f1（）->结果{
Ok（Foo（不安全的{NonNull:：dangling（）}））
}
fn f2（）->结果{
f1（）.map（| Foo（x）| Moo（x））//1
}
fn main（）{
f2（）；
}

在第（1）点，我解包/解构

Foo

。我希望在那之后，

Foo:：drop

不应该被调用，但是出于某种原因，

Foo:：drop

被打印出来

---

解构（

让Struct1{field1，field2，…}=Struct1；

）应该阻止调用

Struct1:：drop

？

如果用未实现的结构替换

NonNull

，行为会更清楚：

#[derive(Debug)]
struct NoCopy;

struct Foo(NoCopy);

impl Drop for Foo {
    fn drop(&mut self) {
        println!("Foo::drop: {:?}", self.0);
    }
}

struct Moo(NoCopy);
//impl Drop for Moo exists, but not important for question

fn f1() -> Result<Foo, String> {
    Ok(Foo(NoCopy))
}

fn f2() -> Result<Moo, String> {
    f1().map(|Foo(x)| Moo(x))//1
}

fn main() {
    f2();
}

---

因此，在（1）中，您从

Foo

中复制

NonNull

，并且

Foo

被删除。

Btw。您不能从

Foo

中移出（

f1（）.map（| x | Moo（x.0））

），因为

Foo

实现了

Drop