Rust中如何在函数内借用可变切片并获取其首部片段？

我是Rust新手，正在编写一个运行在#[no_std]无堆环境的数据包解析器。解析器输入是字节切片的可变引用(&mut [u8])，输出是heapless::Vec，其中每个元素是包含对应切片引用及首部字段获取方法的结构体。

我无法将初始切片拆分为单个数据包首部所需的更小切片。用slice.take_mut()在函数中借用切片并获取首部片段后，剩余切片的权限无法正确返回，导致第二次调用该函数时编译失败。尝试用slice.split_at_mut()实现也遇到类似问题，加上对生命周期理解不足，问题更复杂。

我把代码简化成最小示例，可能遗漏部分关键上下文：

#![feature(slice_take)]

fn main() {
    let mut bytes: [u8; 30] = [
        1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
        11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
        21, 22, 23, 24, 25, 26, 27, 28, 29, 30,
    ];
    let mut s1 = MyStruct::from_bytes(&mut bytes).unwrap();
    let mut s2 = MyStruct::from_bytes(&mut bytes).unwrap();
    println!("{:?}", s1);
    println!("{:?}", s2);
    println!("{:?}", bytes);
}

#[derive(Debug)]
struct MyStruct<'a> {
    data: &'a mut [u8],  // 应该是10字节的切片
}

impl<'a> MyStruct<'a> {
    fn from_bytes(mut data: &'a mut [u8]) -> Result<MyStruct<'a>, &'static str> {
        if data.len() < 10 {
            return Err("Need 10 bytes.");
        }
        let struct_data = data.take_mut(..10).unwrap();
        Ok(MyStruct{data: struct_data})
    }
}

MyStruct { data: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] }
MyStruct { data: [11, 12, 13, 14, 15, 16, 17, 18, 19, 20] }
[21, 22, 23, 24, 25, 26, 27, 28, 29, 30]

error[E0499]: cannot borrow `bytes` as mutable more than once at a time
  --> src\main.rs:10:39
   |
9  |     let mut s1 = MyStruct::from_bytes(&mut bytes).unwrap();
   |                                       ---------- first mutable borrow occurs here
10 |     let mut s2 = MyStruct::from_bytes(&mut bytes).unwrap();
   |                                       ^^^^^^^^^^ second mutable borrow occurs here
11 |     println!("{:?}", s1);
   |                      -- first borrow later used here

核心问题在于：当前的from_bytes函数通过生命周期绑定拿走了整个输入切片的所有权，导致原切片在MyStruct存活期间无法再次被借用。要解决这个问题，需要让函数同时返回解析后的结构体和剩余的切片，将剩余切片的所有权交还给调用者，后续才能继续使用。

修改后的代码 #

#![feature(slice_take)]

fn main() {
    let mut bytes: [u8; 30] = [
        1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
        11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
        21, 22, 23, 24, 25, 26, 27, 28, 29, 30,
    ];
    
    // 第一次解析，拿到结构体和剩余切片
    let (mut s1, mut remaining_bytes) = MyStruct::from_bytes(&mut bytes).unwrap();
    // 用剩余切片做第二次解析
    let (mut s2, remaining_bytes) = MyStruct::from_bytes(remaining_bytes).unwrap();
    
    println!("{:?}", s1);
    println!("{:?}", s2);
    println!("{:?}", remaining_bytes);
}

#[derive(Debug)]
struct MyStruct<'a> {
    data: &'a mut [u8],  // 10字节切片
}

impl<'a> MyStruct<'a> {
    fn from_bytes(data: &'a mut [u8]) -> Result<(MyStruct<'a>, &'a mut [u8]), &'static str> {
        if data.len() < 10 {
            return Err("Need 10 bytes.");
        }
        // 拆分切片：前10字节给结构体，剩下的返回
        let (struct_data, remaining) = data.split_at_mut(10);
        Ok((MyStruct{data: struct_data}, remaining))
    }
}

关键改动说明 #

• 返回值调整：from_bytes不再只返回MyStruct，而是返回(MyStruct<'a>, &'a mut [u8])，将剩余切片交还给调用者。
• 使用split_at_mut：相比take_mut，split_at_mut更直观地将切片拆分为不重叠的两部分，符合Rust借用规则——两个可变切片指向原始切片的不同区域，不会产生重叠借用冲突。
• 调用逻辑修改：每次解析后用剩余切片进行下一次解析，避免重复借用原始的bytes变量。

如果一定要用take_mut，可以调整函数逻辑：

fn from_bytes(mut data: &'a mut [u8]) -> Result<(MyStruct<'a>, &'a mut [u8]), &'static str> {
    if data.len() < 10 {
        return Err("Need 10 bytes.");
    }
    let struct_data = data.take_mut(..10).unwrap();
    Ok((MyStruct{data: struct_data}, data))
}

这里take_mut会修改输入的data切片，使其指向剩余部分，最后返回的data就是剩余切片，效果和split_at_mut一致。

生命周期补充说明 #

• 结构体MyStruct<'a>中的data引用的生命周期'a，绑定的是拆分后的子切片生命周期，而非原始切片的整体生命周期。
• 返回的剩余切片生命周期同样是'a，由于子切片和剩余切片指向原始切片的不同区域，Rust借用检查器允许同时存在这两个可变引用，因为它们没有重叠。

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