如何在Rust中强制使用结构体构造函数以避免无效实例？

一、是否可以禁止直接构造无效实例？ #

完全可行，核心是利用Rust的可见性控制机制：将结构体的字段设为私有（默认就是私有，无需额外标记），同时保持结构体本身为公有，仅对外暴露经过校验的构造函数。这样外部代码无法直接通过结构体字面量创建实例，必须通过你提供的构造方法。

二、实现示例（模块封装版） #

mod email {
    #[derive(Debug)]
    pub struct InvalidEmailAddress;

    // 结构体对外可见，但字段默认私有
    #[derive(Debug)]
    pub struct EmailAddress {
        value: String,
    }

    impl EmailAddress {
        // 对外暴露的校验构造函数
        pub fn new(value: String) -> Result<Self, InvalidEmailAddress> {
            if value.contains("@") { // 示例校验逻辑，实际需替换为严谨规则
                Ok(Self { value })
            } else {
                Err(InvalidEmailAddress)
            }
        }

        // 对外提供只读访问字段的方法（避免外部修改内部值）
        pub fn value(&self) -> &str {
            &self.value
        }
    }
}

use email::{EmailAddress, InvalidEmailAddress};

fn send_report(to: EmailAddress) {
    println!("Sending report to: {}", to.value());
}

fn main() {
    // 合法构造：通过校验后的new方法
    let valid_email = EmailAddress::new("hi@example.com".to_string()).unwrap();
    send_report(valid_email);

    // 以下代码都会编译失败，因为无法访问私有字段
    // let invalid_email = EmailAddress { value: "hi-at-example.com".to_string() };
    // let mut email = valid_email;
    // email.value = "invalid".to_string();
}

三、可能构造无效实例的边缘场景 #

除了直接字面量构造，还有几种需要注意的情况：

1. Unsafe代码：通过std::mem::transmute等unsafe操作强制转换类型，绕过构造校验。但这属于显式的unsafe操作，一般业务代码不会使用，且违背安全编程的初衷。
2. 序列化/反序列化：使用serde等库时，默认反序列化会直接构造结构体。解决方式是自定义反序列化逻辑，在反序列化时调用校验构造函数：

// 需添加serde依赖到Cargo.toml
use serde::{Deserialize, Serialize};

mod email {
    use super::*;

    #[derive(Debug, Serialize)]
    pub struct InvalidEmailAddress;

    #[derive(Debug, Serialize)]
    pub struct EmailAddress {
        value: String,
    }

    impl EmailAddress {
        pub fn new(value: String) -> Result<Self, InvalidEmailAddress> {
            if value.contains("@") {
                Ok(Self { value })
            } else {
                Err(InvalidEmailAddress)
            }
        }

        pub fn value(&self) -> &str {
            &self.value
        }
    }

    // 自定义反序列化，强制校验
    impl<'de> Deserialize<'de> for EmailAddress {
        fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
        where
            D: serde::Deserializer<'de>,
        {
            let raw_value = String::deserialize(deserializer)?;
            EmailAddress::new(raw_value)
                .map_err(|_| serde::de::Error::custom("Invalid email address format"))
        }
    }
}

3. 模块内部违规代码：如果模块内部有其他函数直接构造EmailAddress而不经过校验，也会产生无效实例。因此模块内部要严格控制实例创建路径，仅保留经过校验的构造函数。

四、关于模块可见性的关键要点 #

你之前的误解在于忽略了结构体字段的可见性：即使结构体是公有的，只要其字段是私有的，外部代码就无法通过EmailAddress { value: ... }的方式构造实例——因为外部无法访问私有字段。模块封装的核心就是通过字段私有性，把实例创建的权力完全收归到你提供的校验构造函数中。

内容的提问来源于stack exchange，提问作者berkes