Rust中如何从共享切片获取可变切片 Rc<[T]>实现问题

两个初始实现无法满足需求的本质是对Rust智能指针的约束和API不熟悉：

• 基于Rc<[T]>的实现：Rc<T>默认仅提供共享不可变访问，很多人不知道当Rc的强引用计数为1、不存在其他共享持有者时，可以通过标准库提供的Rc::get_mut安全获取内部值的可变引用，不需要额外包装。
• 基于Rc<RefCell<[T]>>的实现：RefCell<T>要求内部类型T必须满足Sized约束（编译期可确定大小），而[T]是动态大小类型（DST），无法直接作为RefCell的泛型参数实例化，因此代码无法编译运行。

根据你对共享访问的实际需求二选一即可，都是Rust生态的标准惯用法。

方案一：零编译开销，编译期借用保证 #

如果你的使用场景允许调用get_mut_slice时不存在其他共享同一份底层数据的切片实例，完全不需要引入内部可变性的运行时开销，直接基于你最初的结构体实现即可：

use std::rc::Rc;

#[derive(Debug, Clone)]
struct MySlice<T> {
    shared_data: Rc<[T]>,
    beg: usize,
    len: usize,
}

impl<T> From<Vec<T>> for MySlice<T> {
    fn from(value: Vec<T>) -> Self {
        let total_len = value.len();
        Self {
            // Vec到Rc<[T]>是标准库支持的零开销转换，不会额外复制数据
            shared_data: Rc::from(value),
            beg: 0,
            len: total_len,
        }
    }
}

impl<T> MySlice<T> {
    /// 返回完整底层数组的可变切片，若存在其他共享切片则返回None
    fn get_mut_slice(&mut self) -> Option<&mut [T]> {
        Rc::get_mut(&mut self.shared_data)
    }

    /// 生成共享底层数据的子切片
    fn slice(&self, start: usize, end: usize) -> Self {
        assert!(start <= end && end - start <= self.len);
        Self {
            shared_data: Rc::clone(&self.shared_data),
            beg: self.beg + start,
            len: end - start,
        }
    }
}

这个方案的特点：

• 完全没有运行时额外开销，所有借用检查在编译期完成
• 不存在运行时panic风险，内存安全由编译器保证
• 当你克隆出其他子切片后，get_mut_slice会返回None，从API层面避免了“可变引用与共享引用同时存在”的内存安全问题

方案二：支持多所有者共存时的可变访问 #

如果你需要在存在多个共享切片的场景下，依然能修改底层数组（所有共享切片都能感知到修改），就用内部可变性模式，修正之前的DST问题，用Vec<T>作为RefCell的内部类型即可：

use std::rc::Rc;
use std::cell::{RefCell, RefMut};

#[derive(Debug, Clone)]
struct MySlice<T> {
    shared_data: Rc<RefCell<Vec<T>>>,
    beg: usize,
    len: usize,
}

impl<T> From<Vec<T>> for MySlice<T> {
    fn from(value: Vec<T>) -> Self {
        let total_len = value.len();
        Self {
            shared_data: Rc::new(RefCell::new(value)),
            beg: 0,
            len: total_len,
        }
    }
}

impl<T> MySlice<T> {
    /// 返回完整底层数组的可变切片，存在活跃借用时会panic
    fn get_mut_slice(&mut self) -> RefMut<'_, [T]> {
        RefMut::map(self.shared_data.borrow_mut(), |vec| vec.as_mut_slice())
    }

    /// 生成共享底层数据的子切片
    fn slice(&self, start: usize, end: usize) -> Self {
        assert!(start <= end && end - start <= self.len);
        Self {
            shared_data: Rc::clone(&self.shared_data),
            beg: self.beg + start,
            len: end - start,
        }
    }
}

这个方案的特点：

• 支持多个切片实例共享同一份数据时的可变修改
• 存在极轻量的运行时借用检查开销，违反“同一时间仅一个可变引用/任意个不可变引用”规则时会直接panic
• 返回的RefMut<'_, [T]>实现了DerefMut，可以和普通&mut [T]一样使用，这是RefCell模式下能返回的最接近裸可变引用的安全类型，无法直接返回&mut [T]（否则无法绑定生命周期和借用计数，会破坏内存安全）

跨线程使用时，将Rc替换为Arc，RefCell替换为RwLock/Mutex即可，逻辑完全一致。

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