pub trait Forget {
    fn forget_me_as_ptr(self) -> *const Self
    where
        Self: Sized,
    {
        let p = addr_of!(self);
        forget(self);
        p
    }

    fn forget_me_as_mut_ptr(self) -> *mut Self
    where
        Self: Sized,
    {
        self.forget_me_as_ptr() as *mut Self
    }

    fn forget_me_as_ref(self) -> &'static Self
    where
        Self: Sized,
    {
        self.forget_me_as_mut_ref()
    }

    fn forget_me_as_mut_ref(mut self) -> &'static mut Self
    where
        Self: Sized,
    {
        let p = addr_of_mut!(self);
        forget(self);
        unsafe { p.as_mut().unwrap() }
    }
}

pub fn default<T: Forget + Default>() -> &'static T {
    T::default().forget_me_as_ref()
}

#[derive(Debug)]
struct Player {
    health: u8,
    name: String,
    aliases: Vec<String>,
}

impl Drop for Player {
    fn drop(&mut self) {
        println!("Dropping [{}, {self:p}]", type_name::<Self>());
    }
}

impl Display for Player {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(
            f,
            "[{}, {self:p}] = name: {}, health: {}, aliases: {:#?}",
            type_name::<Self>(),
            self.name,
            self.health,
            self.aliases
        )
    }
}

impl Forget for Player {}

impl Default for Player {
    fn default() -> Self {
        Self {
            health: 100,
            name: "default".into(),
            aliases: vec!["default".to_string()],
        }
    }
}

fn main() {
    let p = default::<Player>();
    println!("{p}");
}

字符串
产出：

$ cargo r
    Finished dev [unoptimized + debuginfo] target(s) in 0.00s
     Running `target/debug/static_factory`
Segmentation fault (core dumped)

型
在上面的代码片段中，为什么它是segfaulting？std::mem::forget只是获取所有权，并不运行析构函数/drop，而析构函数/drop可以用来创建生存期为静态的引用。这种逻辑的缺陷在哪里？我是Rust的新手，有点想了解引用，struct T的示例，指针之间的关系。上面的代码从一个天真的想法看起来逻辑上是正确的。请解释并更正。