使用转换的递归数据结构的零成本构建器模式这安全吗？有没有更好的方法？

如何解决使用转换的递归数据结构的零成本构建器模式这安全吗？有没有更好的方法？

我想使用构建器模式创建一个 struct，该模式必须在构建前进行验证，并且我希望最小化构建开销。

我想出了一个使用 std::mem::transmute 的好方法，但我不确定这种方法是否真的安全，或者它是最好的方法。

#[derive(Debug)]
pub struct ValidStruct {
    items: Vec<ValidStruct>
}

#[derive(Debug)]
pub struct Builder {
    pub items: Vec<Builder>
}

#[derive(Debug)]
pub struct InvalidStructError {}

impl Builder {
    pub fn new() -> Self {
        Self { items: vec![] }
    }
    
    pub fn is_valid(&self) -> bool {
        self.items.len() % 2 == 1
    }
    
    pub fn build(self) -> Result<ValidStruct,InvalidStructError> {
        if !self.is_valid() {
            return Err(InvalidStructError {});
        }
        unsafe {
            Ok(std::mem::transmute::<Builder,ValidStruct>(self))
        }
    }
}

fn main() {
    let mut builder = Builder::new();
    builder.items.push(Builder::new());
    let my_struct = builder.build().unwrap();
    
    println!("{:?}",my_struct)
}

所以，这似乎有效。我认为它应该是安全的，因为我知道这两个结构是相同的。我错过了什么吗？这实际上是否会以某种方式导致问题，或者是否有更清洁/更好的方法可用？

解决方法

您通常不能仅仅因为它们似乎具有相同顺序的相同字段而在不同结构之间进行转换，因为编译器可能会改变它。您可以通过强制内存布局来避免风险，但随后您会与编译器作斗争并阻止优化。通常不推荐使用这种方法，而且我认为这里不需要。

你想要的是什么

具有公共字段的递归数据结构，以便您可以轻松构建它
一个相同的结构，从第一个构建，但没有公共访问权限，仅在第一个验证后构建

出于性能原因，您希望避免无用的副本。

我的建议是有一个包装类。这是有道理的，因为在 Rust 中将一个结构体包装在另一个结构体中是完全没有成本的。

你可以这样

/// This is the "Builder" struct
pub struct Data {
    pub items: Vec<Data>,}
pub struct ValidStruct {
    data: Data,// no public access here
}
impl Data {
    pub fn build(self) -> Result<ValidStruct,InvalidStructError> {
        if !self.is_valid() {
            return Err(InvalidStructError {});
        }
        Ok(Self{ data })
    }
}

（或者，您也可以将 struct Builder 声明为 Data 的包装器，但可以对其字段进行公共访问）