Rust中Rc<RefCell<Rc<Vec<T>>>>数据结构简化方案问询

需求回顾 #

需要对HashMap中存储的Vec<T>实现两种访问方式：

• 真实惰性副本：初始与原数据共享，修改时自动拷贝，后续原数据修改不影响副本，副本修改也不影响原数据；
• 可变视图：可直接修改HashMap中的原数据，且不影响已有的真实副本；同一时间仅允许存在一个可变视图，且可变视图存在时仍能创建新的真实副本。

现有方案使用Rc<RefCell<Rc<Vec<T>>>>嵌套结构，层级复杂，可读性差，需要更简洁的替代方案。

优化方案：自定义SharedVec包装类型 #

通过自定义一个轻量包装类型，封装底层的引用计数与内部可变性逻辑，对外暴露清晰的API，既满足需求又简化结构。

核心设计思路 #

1. 用Rc<RefCell<Rc<Vec<T>>>>作为底层存储（保留核心逻辑，但封装后对外不可见）；
2. 真实惰性副本直接返回Rc<Vec<T>>，利用Rc的共享特性实现惰性拷贝（仅当副本被修改时，Rc::make_mut会自动触发拷贝）；
3. 可变视图获取时，检查底层Rc<Vec<T>>的引用计数：若存在真实副本（计数>1），则先拷贝一份新的Vec<T>替换原数据，确保修改仅影响HashMap内的实例，不波及已有的真实副本；同时通过RefMut保证同一时间仅存在一个可变视图。

完整实现代码 #

use std::cell::RefCell;
use std::collections::HashMap;
use std::rc::Rc;
use std::ops::{Deref, DerefMut};

#[derive(Clone)]
struct SharedVec<T: Clone> {
    inner: Rc<RefCell<Rc<Vec<T>>>>,
}

impl<T: Clone> SharedVec<T> {
    // 创建新的SharedVec实例
    pub fn new(data: Vec<T>) -> Self {
        SharedVec {
            inner: Rc::new(RefCell::new(Rc::new(data))),
        }
    }

    // 获取真实惰性副本：初始共享，修改时自动分离
    pub fn real_lazy_clone(&self) -> Rc<Vec<T>> {
        Rc::clone(&self.inner.borrow())
    }

    // 获取可变视图：同一时间仅一个实例，修改自动与真实副本分离
    pub fn get_mut(&self) -> impl DerefMut<Target = Vec<T>> + '_ {
        let mut inner_ref = self.inner.borrow_mut();
        // 若存在其他引用（真实副本），则复制新数据，避免影响副本
        if Rc::strong_count(&inner_ref) > 1 {
            *inner_ref = Rc::new((**inner_ref).clone());
        }
        // 将RefMut<Rc<Vec<T>>>转换为RefMut<Vec<T>>，方便直接操作Vec
        RefMutAdapter { inner: inner_ref }
    }
}

// 辅助适配器：将RefMut<Rc<Vec<T>>>适配为可直接操作Vec的类型
struct RefMutAdapter<'a, T> {
    inner: std::cell::RefMut<'a, Rc<Vec<T>>>,
}

impl<'a, T> Deref for RefMutAdapter<'a, T> {
    type Target = Vec<T>;
    fn deref(&self) -> &Self::Target {
        &**self.inner
    }
}

impl<'a, T> DerefMut for RefMutAdapter<'a, T> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut **self.inner
    }
}

fn main() {
    let mut map = HashMap::new();
    map.insert("x".to_string(), SharedVec::new(vec![1]));

    // 创建两个真实惰性副本
    let x1 = map["x"].real_lazy_clone();
    let x2 = map["x"].real_lazy_clone();

    // 获取可变视图并修改原数据
    {
        let mut x_mut = map["x"].get_mut();
        x_mut.push(2);
    }

    // 真实副本不受原数据修改影响
    println!("{:?}", x1); // 输出: [1]
    println!("{:?}", x2); // 输出: [1]
    // 原数据已更新
    println!("{:?}", map["x"].inner.borrow()); // 输出: [1, 2]

    // 可变视图存在时创建新的真实副本
    {
        let mut x_mut = map["x"].get_mut();
        let x3 = map["x"].real_lazy_clone();
        x_mut.push(3);
        println!("{:?}", x3); // 输出: [1, 2]，不受后续修改影响
    }

    println!("{:?}", map["x"].inner.borrow()); // 输出: [1, 2, 3]
}

方案优势 #

• API清晰：对外暴露real_lazy_clone和get_mut两个明确方法，无需关注内部嵌套结构；
• 满足所有需求：惰性拷贝、可变视图的排他性、原数据修改不影响副本等特性全部实现；
• 简化复杂度：将嵌套的Rc<RefCell<Rc<Vec<T>>>>封装在自定义类型内部，调用方无需处理层级嵌套的引用操作。

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