Rust中Cell的反向用例：仅少数字段不可变的结构体实现

1. 拆分可变/不可变字段，用UnsafeCell集中管理可变部分 #

这是最贴合你需求的方案：把所有可变字段放进一个子结构体，用UnsafeCell包裹，不可变字段直接放在顶层结构体中。既避免了给每个可变字段套Cell<T>，又保证了不可变字段的只读性，同时保持和Cell<T>一致的线程安全特性（当可变字段的类型都是Sync时，整个结构体也是Sync）。

代码示例 #

首先定义存放可变字段的子结构体：

#[derive(Default)]
struct UserMutable {
    age: u32,
    email: String,
    // 其他需要可变的字段都放这里
}

然后定义顶层User结构体，包含不可变字段和可变部分：

use std::cell::UnsafeCell;

struct User {
    // 不可变字段，直接定义，只能读取不能修改
    username: String,
    // 可变部分用UnsafeCell包裹，提供内部可变性
    mutable: UnsafeCell<UserMutable>,
}

接下来为User实现安全的访问方法，模仿Cell<T>的行为保证安全性：

impl User {
    // 构造函数
    pub fn new(username: String) -> Self {
        Self {
            username,
            mutable: UnsafeCell::new(UserMutable::default()),
        }
    }

    // ---- 不可变字段的访问 ----
    pub fn get_username(&self) -> &str {
        &self.username
    }

    // ---- 可变字段的访问（Copy类型示例：age） ----
    pub fn get_age(&self) -> u32 {
        // 对于Copy类型，直接读取是安全的
        unsafe { (*self.mutable.get()).age }
    }

    pub fn set_age(&self, age: u32) {
        unsafe { (*self.mutable.get()).age = age; }
    }

    // ---- 可变字段的访问（非Copy类型示例：email） ----
    // 模仿Cell的take方法，取出并替换为空值
    pub fn take_email(&self) -> String {
        unsafe { std::mem::take(&mut (*self.mutable.get()).email) }
    }

    pub fn set_email(&self, email: String) {
        unsafe { (*self.mutable.get()).email = email; }
    }

    // 模仿Cell的replace方法，替换并返回旧值
    pub fn replace_email(&self, email: String) -> String {
        unsafe { std::mem::replace(&mut (*self.mutable.get()).email, email) }
    }
}

// 确保User是Sync（当UserMutable是Sync时）
unsafe impl Sync for User where UserMutable: Sync {}

2. 用RefCell替代（单线程场景） #

如果你的代码只在单线程环境下运行，可以用RefCell包裹整个可变子结构体，无需手动编写unsafe代码，Rust会在运行时检查借用规则：

use std::cell::RefCell;

struct User {
    username: String,
    mutable: RefCell<UserMutable>,
}

impl User {
    pub fn new(username: String) -> Self {
        Self {
            username,
            mutable: RefCell::new(UserMutable::default()),
        }
    }

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

    pub fn get_age(&self) -> u32 {
        self.mutable.borrow().age
    }

    pub fn set_age(&self, age: u32) {
        self.mutable.borrow_mut().age = age;
    }

    pub fn get_email(&self) -> String {
        self.mutable.borrow().email.clone()
    }

    pub fn set_email(&self, email: String) {
        self.mutable.borrow_mut().email = email;
    }
}

注意RefCell不是Sync，不能跨线程共享，这是和Cell<T>/UnsafeCell方案的核心区别。

方案优势 #

• 减少重复代码：不用给每个可变字段手动套Cell<T>，集中管理可变部分。
• 边界清晰：顶层结构体直接展示不可变字段，可变字段统一归类，可读性更强。
• 性能一致：UnsafeCell的底层实现和Cell<T>完全相同，无额外性能开销。

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