嵌入式Rust：如何将大数组/缓冲区拆分为多个较小缓冲区

你的核心问题是Rust借用检查器不允许同时存在多个可变引用，哪怕你逻辑上保证了缓冲区不重叠——unsafe关键字只能跳过边界检查，无法绕过借用规则。以下是几种可行的实现方案：

方案1：安全的一次性拆分（推荐嵌入式场景） #

如果提前知道所有工作缓冲区的大小，直接用标准库的split_at_mut一次性拆分全局缓冲区，编译器会自动保证切片不重叠，无需unsafe：

/// 将全局缓冲区按指定大小拆分为多个不重叠的可变切片
fn split_global_buffer<const TOTAL: usize>(
    mut global: &mut [f32; TOTAL],
    sizes: &[usize]
) -> Vec<&mut [f32]> {
    let mut result = Vec::with_capacity(sizes.len());
    let mut offset = 0;
    
    for &size in sizes {
        assert!(offset + size <= TOTAL, "缓冲区总大小超出限制");
        // split_at_mut 是安全方法，编译器保证拆分出的切片无重叠
        let (chunk, rest) = global.split_at_mut(size);
        result.push(chunk);
        global = rest;
        offset += size;
    }
    
    result
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_split_buffers() {
        let mut global_buffer: [f32; 1024] = [0.0; 1024];
        // 按需求拆分出2个512大小的缓冲区
        let buffers = split_global_buffer(&mut global_buffer, &[512, 512]);
        
        let mut b1 = buffers[0];
        let mut b2 = buffers[1];
        
        b1[0] = 1.0;
        b2[0] = 2.0;
        
        assert_eq!(global_buffer[0], 1.0);
        assert_eq!(global_buffer[512], 2.0);
    }
}

这种方案完全安全，没有内存风险，适合嵌入式这种对稳定性要求高的场景。

方案2：用裸指针实现动态分配（需手动保证安全） #

如果必须动态分配缓冲区（比如运行时才知道大小或数量），可以使用裸指针绕过借用检查，但你需要自己保证所有缓冲区不重叠、不越界：

pub struct BufferManager<const N: usize> {
    global_ptr: *mut f32,
    offset: usize,
}

impl<const N: usize> BufferManager<N> {
    pub fn new(global_buffer: &mut [f32; N]) -> Self {
        BufferManager {
            global_ptr: global_buffer.as_mut_ptr(),
            offset: 0,
        }
    }

    /// 注意：此方法为unsafe，调用者需保证：
    /// 1. 所有get_buffer请求的总大小不超过N
    /// 2. 已获取的缓冲区不再被重复分配
    pub unsafe fn get_buffer(&mut self, size: usize) -> &mut [f32] {
        assert!(self.offset + size <= N, "缓冲区分配超出总大小");
        // 从裸指针创建可变切片
        let slice = std::slice::from_raw_parts_mut(
            self.global_ptr.add(self.offset),
            size
        );
        self.offset += size;
        slice
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_dynamic_allocation() {
        let mut global_buffer: [f32; 1024] = [0.0; 1024];
        let mut buffer_manager = BufferManager::<1024>::new(&mut global_buffer);

        // 手动保证安全：两次分配的总大小不超过1024，且无重叠
        let mut b1 = unsafe { buffer_manager.get_buffer(512) };
        let mut b2 = unsafe { buffer_manager.get_buffer(512) };

        b1[0] = 1.0;
        b2[0] = 1.0;

        assert_eq!(global_buffer[0], 1.0);
        assert_eq!(global_buffer[512], 1.0);
    }
}

原代码失败原因说明 #

你原代码中的get_buffer返回的&mut [f32]生命周期与&mut self绑定，第一次调用后buffer_manager会被持续可变借用，直到b1被销毁——这就是第二次调用报错的原因。unsafe { get_unchecked_mut(...) }仅跳过边界检查，并未改变引用的生命周期规则，所以无法绕过借用检查。

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