如何定义Rust函数读取动态字节数组为i16/i32/i64类型向量？

1. 定义转换Trait #

先定义一个Trait，抽象“从字节块转换为对应数值类型”的逻辑，同时处理长度不匹配的错误：

use std::io;

trait FromLeByteChunk: Sized {
    /// 从小端字节块转换为当前类型，字节长度不匹配则返回错误
    fn from_le_chunk(chunk: &[u8]) -> io::Result<Self>;
    
    /// 返回当前类型对应的字节长度
    fn byte_length() -> usize;
}

为i16、i32、i64实现该Trait：

impl FromLeByteChunk for i16 {
    fn from_le_chunk(chunk: &[u8]) -> io::Result<Self> {
        let bytes = chunk.try_into()
            .map_err(|_| io::Error::new(io::ErrorKind::InvalidData, "Chunk length mismatch for i16"))?;
        Ok(i16::from_le_bytes(bytes))
    }

    fn byte_length() -> usize {
        std::mem::size_of::<i16>()
    }
}

impl FromLeByteChunk for i32 {
    fn from_le_chunk(chunk: &[u8]) -> io::Result<Self> {
        let bytes = chunk.try_into()
            .map_err(|_| io::Error::new(io::ErrorKind::InvalidData, "Chunk length mismatch for i32"))?;
        Ok(i32::from_le_bytes(bytes))
    }

    fn byte_length() -> usize {
        std::mem::size_of::<i32>()
    }
}

impl FromLeByteChunk for i64 {
    fn from_le_chunk(chunk: &[u8]) -> io::Result<Self> {
        let bytes = chunk.try_into()
            .map_err(|_| io::Error::new(io::ErrorKind::InvalidData, "Chunk length mismatch for i64"))?;
        Ok(i64::from_le_bytes(bytes))
    }

    fn byte_length() -> usize {
        std::mem::size_of::<i64>()
    }
}

2. 泛型读取函数实现 #

结合Trait约束实现泛型读取函数，提前检查字节长度匹配性，避免后续转换出错：

use std::fs::File;
use std::io::Read;

struct YourStruct {
    byte_per_block: u8,
    sampled_data: Vec<Box<dyn std::any::Any>>,
    // 其他字段...
}

impl YourStruct {
    fn read_data<T: FromLeByteChunk + 'static>(&mut self, file: &mut File) -> io::Result<Vec<T>> {
        // 校验字节长度是否匹配目标类型
        let target_len = T::byte_length();
        if self.byte_per_block as usize != target_len {
            return Err(io::Error::new(
                io::ErrorKind::InvalidData,
                format!("Byte per block ({}) doesn't match type {}'s length ({})",
                    self.byte_per_block,
                    std::any::type_name::<T>(),
                    target_len)
            ));
        }

        let mut data = Vec::new();
        file.read_to_end(&mut data)?;

        // 校验总数据长度是否为块大小的整数倍
        if data.len() % target_len != 0 {
            return Err(io::Error::new(
                io::ErrorKind::InvalidData,
                "Total data length is not a multiple of byte per block"
            ));
        }

        let sampled_data = data.chunks(target_len)
            .map(T::from_le_chunk)
            .collect::<io::Result<Vec<T>>>()?;

        self.sampled_data = vec![Box::new(sampled_data.clone())];
        Ok(sampled_data)
    }
}

3. 动态类型场景的枚举方案 #

如果byte_per_block是运行时动态确定的，用枚举封装所有可能的结果更灵活：

enum SampledData {
    I16(Vec<i16>),
    I32(Vec<i32>),
    I64(Vec<i64>),
}

struct YourStruct {
    byte_per_block: u8,
    sampled_data: Option<SampledData>,
    // 其他字段...
}

impl YourStruct {
    fn read_dynamic_data(&mut self, file: &mut File) -> io::Result<()> {
        let mut data = Vec::new();
        file.read_to_end(&mut data)?;

        let byte_len = self.byte_per_block as usize;
        if data.len() % byte_len != 0 {
            return Err(io::Error::new(
                io::ErrorKind::InvalidData,
                "Total data length is not a multiple of byte per block"
            ));
        }

        self.sampled_data = match byte_len {
            2 => Some(SampledData::I16(
                data.chunks(2)
                    .map(|c| i16::from_le_bytes(c.try_into().unwrap()))
                    .collect()
            )),
            4 => Some(SampledData::I32(
                data.chunks(4)
                    .map(|c| i32::from_le_bytes(c.try_into().unwrap()))
                    .collect()
            )),
            8 => Some(SampledData::I64(
                data.chunks(8)
                    .map(|c| i64::from_le_bytes(c.try_into().unwrap()))
                    .collect()
            )),
            _ => return Err(io::Error::new(
                io::ErrorKind::InvalidData,
                format!("Unsupported byte per block: {}", byte_len)
            )),
        };

        Ok(())
    }
}

核心说明 #

• 泛型方案适合提前知晓目标类型的场景，通过Trait约束保证类型安全，同时加入多维度错误检查避免运行时崩溃。
• 枚举方案适配byte_per_block完全动态的场景，无需提前指定类型，直接根据字节长度选择转换逻辑。

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