如何在Rust中初始化包含依赖字段的结构体？

我希望在Rust中初始化一个字段间存在依赖关系的结构体——最后一个字段依赖于结构体中另一个字段创建的变量。

示例代码 #

基础结构体定义 #

pub struct NeedToRelyOnThis {
}

pub struct Breaking {
}

impl Breaking {
    pub fn new() -> Self {
        Self {}
    }
}

pub struct Depending<'a> {
    needed: &'a NeedToRelyOnThis,
    breaking: &'a Breaking
}

impl<'a> Depending<'a> {
    pub fn new(needed: &'a NeedToRelyOnThis, breaking: &'a Breaking) -> Self {
        Self { needed, breaking }
    }
}

可正常运行的实现 #

当Breaking实例从外部传入时，初始化逻辑可以正常工作：

pub struct BaseWorking<'a> {
    needed: &'a NeedToRelyOnThis,
    d: Depending<'a>
}

impl<'a> BaseWorking<'a> {
    pub fn new(needed: &'a NeedToRelyOnThis, breaking: &'a Breaking) -> Self {
        Self { 
            needed,
            d: Depending::new(needed, breaking)
        }
    }
}

无法运行的实现 #

当Breaking由结构体自身创建，且Depending需要引用这个内部的Breaking时，直接初始化会失败：

pub struct BaseBroken<'a> {
    needed: &'a NeedToRelyOnThis, // 必须使用引用
    breaking: Breaking,
    d: Depending<'a>
}

impl<'a> BaseBroken<'a> {
    // 注释掉该函数则不会报错
    pub fn new(needed: &'a NeedToRelyOnThis) -> Self {
        Self { 
            needed,
            breaking: Breaking::new(),
            // 此处无法引用刚创建的breaking字段，且Rust不允许分步初始化结构体
            d: Depending::new(needed, breaking) 
        }
   }
}

背景与尝试 #

我尝试过分步初始化结构体，但Rust要求必须一次性完成所有字段的初始化；也看过相关问题，但不知道如何应用到当前场景中。

背景说明：BaseBroken是一个实现算法的结构体，NeedToRelyOnThis是从外部传入的数学图。算法结构体包含用于外包计算的字段，其中一个字段需要引用另一个字段来访问特定信息。在Java等语言中可以通过构造函数逐个设置字段实现这种逻辑，但Rust的借用规则限制了这种操作。

解决方案 #

方案1：使用Option实现安全的延迟初始化 #

通过将d字段声明为Option<Depending<'a>>，先以None占位，初始化完成后再赋值为Some。这种方法完全符合Rust的安全规则：

pub struct BaseFixed<'a> {
    needed: &'a NeedToRelyOnThis,
    breaking: Breaking,
    d: Option<Depending<'a>>,
}

impl<'a> BaseFixed<'a> {
    pub fn new(needed: &'a NeedToRelyOnThis) -> Self {
        let mut res = Self {
            needed,
            breaking: Breaking::new(),
            d: None,
        };
        // 此时res.breaking已经初始化，可以安全地获取其引用
        res.d = Some(Depending::new(needed, &res.breaking));
        res
    }

    // 提供访问d的方法，确保不会返回None
    pub fn get_d(&self) -> &Depending<'a> {
        self.d.as_ref().expect("d should be initialized")
    }
}

方案2：重构结构体层级 #

将存在依赖关系的字段封装到子结构体中，明确生命周期的关联：

// 封装存在依赖的字段
struct AlgorithmCore<'a> {
    breaking: Breaking,
    d: Option<Depending<'a>>,
}

impl<'a> AlgorithmCore<'a> {
    fn new(needed: &'a NeedToRelyOnThis) -> Self {
        let mut core = Self {
            breaking: Breaking::new(),
            d: None,
        };
        core.d = Some(Depending::new(needed, &core.breaking));
        core
    }
}

pub struct BaseRefactored<'a> {
    needed: &'a NeedToRelyOnThis,
    core: AlgorithmCore<'a>,
}

impl<'a> BaseRefactored<'a> {
    pub fn new(needed: &'a NeedToRelyOnThis) -> Self {
        Self {
            needed,
            core: AlgorithmCore::new(needed),
        }
    }
}

方案3：unsafe初始化（谨慎使用） #

如果可以接受使用unsafe代码，可以直接分步初始化结构体。这种方法利用对结构体内存布局的了解确保引用有效，但需要承担unsafe代码的风险：

impl<'a> BaseBroken<'a> {
    pub unsafe fn new(needed: &'a NeedToRelyOnThis) -> Self {
        // 先用零值占位（注意：零值可能对某些类型不安全，此处会被后续赋值覆盖）
        let mut res = Self {
            needed,
            breaking: Breaking::new(),
            d: std::mem::zeroed(),
        };
        // 替换为有效的Depending实例
        res.d = Depending::new(needed, &res.breaking);
        res
    }
}

方案4：调整依赖关系（推荐） #

如果业务逻辑允许，修改Depending的定义，让它不再持有Breaking的引用，而是通过结构体间接访问：

// 修改Depending，不再持有breaking的引用
pub struct Depending<'a> {
    needed: &'a NeedToRelyOnThis,
}

impl<'a> Depending<'a> {
    pub fn new(needed: &'a NeedToRelyOnThis) -> Self {
        Self { needed }
    }

    // 当需要访问breaking时，通过传入引用的方式
    pub fn do_something(&self, breaking: &Breaking) {
        // 执行需要访问breaking的逻辑
    }
}

pub struct BaseAdjusted<'a> {
    needed: &'a NeedToRelyOnThis,
    breaking: Breaking,
    d: Depending<'a>,
}

impl<'a> BaseAdjusted<'a> {
    pub fn new(needed: &'a NeedToRelyOnThis) -> Self {
        Self {
            needed,
            breaking: Breaking::new(),
            d: Depending::new(needed),
        }
    }

    pub fn run_algorithm(&self) {
        self.d.do_something(&self.breaking);
    }
}

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