Rust中结构体成员引用同结构体其他成员的构造方法问题

问题场景 #

定义了包含引用依赖的结构体，代码如下：

struct X<'a> {
    y: Y<'a>,
    z: Z
}

struct Y<'a> {
    z: &'a Z
}

struct Z;

impl<'a> X<'a> {
    pub fn new() -> X<'a> {
        ???
    }
}

尝试编写构造函数时遇到编译错误：

impl<'a> X<'a> {
    pub fn new() -> X<'a> {
        let z = Z{};
        
        let y = Y { z: &z };
        
        X {
            y, z
        }
    }
}

这段代码无法运行，因为局部变量z的生命周期在函数返回时结束，Y持有的引用会成为悬垂引用，违反Rust内存安全规则。需求是X和Y都能修改Z，且X不持有Z的所有权，Rc的不可变特性无法满足修改需求。

符合Rust惯用的实现方式 #

若要满足共享可变的需求，可结合引用计数与内部可变性来实现，这是Rust处理此类场景的标准方案：

单线程场景（Rc + RefCell） #

use std::rc::Rc;
use std::cell::RefCell;

struct X {
    y: Y,
    z_shared: Rc<RefCell<Z>>
}

struct Y {
    z_shared: Rc<RefCell<Z>>
}

struct Z;

impl X {
    pub fn new() -> X {
        let z_rc = Rc::new(RefCell::new(Z{}));
        // 克隆Rc，仅复制引用计数，不复制Z本身
        let y = Y { z_shared: Rc::clone(&z_rc) };
        
        X {
            y,
            z_shared: z_rc
        }
    }
}

// 示例：修改Z的方法
impl Z {
    fn modify(&mut self) {
        // 执行修改逻辑
    }
}

impl Y {
    fn update_z(&self) {
        // 通过RefCell获取可变引用
        self.z_shared.borrow_mut().modify();
    }
}

impl X {
    fn update_z(&self) {
        self.z_shared.borrow_mut().modify();
    }
}

• Rc让X和Y共享Z的所有权，解决了X不应持有Z所有权的需求；
• RefCell提供内部可变性，允许在共享引用的前提下修改Z，满足双方都能修改的要求；
• 结构体不再需要生命周期参数，代码更简洁易维护。

多线程场景（Arc + Mutex/RwLock） #

如果需要在多线程环境下使用，将Rc替换为线程安全的Arc，RefCell替换为Mutex（排他访问）或RwLock（读写分离）：

use std::sync::{Arc, Mutex};

struct X {
    y: Y,
    z_shared: Arc<Mutex<Z>>
}

struct Y {
    z_shared: Arc<Mutex<Z>>
}

struct Z;

impl X {
    pub fn new() -> X {
        let z_arc = Arc::new(Mutex::new(Z{}));
        let y = Y { z_shared: Arc::clone(&z_arc) };
        
        X {
            y,
            z_shared: z_arc
        }
    }
}

重构设计思路 #

若不想使用引用计数，可从所有权和职责划分入手调整设计：

让Z的所有权由外部管理 #

将Z的所有权交给外部调用者，X和Y持有Z的引用，构造函数接收外部的Z作为参数：

struct X<'a> {
    y: Y<'a>,
    z: &'a mut Z
}

struct Y<'a> {
    z: &'a mut Z
}

struct Z;

impl<'a> X<'a> {
    // 外部传入Z的可变引用
    pub fn new(z: &'a mut Z) -> X<'a> {
        // 注意：可变引用具有排他性，此写法会触发编译错误，需调整
        // 可改为Y持有不可变引用，X持有可变引用，或拆分职责
        let y = Y { z: &mut *z };
        X {
            y,
            z
        }
    }
}

这种方式仅适合一方可变、一方不可变的场景，因为Rust不允许同时存在多个可变引用。

调整结构体职责 #

如果Y仅在特定操作中使用，可将Y作为临时对象，而非X的成员：

struct X {
    z: Z
}

struct Z;

impl X {
    pub fn new() -> X {
        X { z: Z{} }
    }
    
    // 需要Y的功能时临时创建
    pub fn perform_y_operation(&mut self) {
        let mut y = Y { z: &mut self.z };
        y.modify_z();
    }
}

struct Y<'a> {
    z: &'a mut Z
}

impl<'a> Y<'a> {
    fn modify_z(&mut self) {
        // 修改Z的逻辑
    }
}

这种设计避免了结构体间的长期引用依赖，遵循Rust单一所有权的核心原则，逻辑更清晰。

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