如何从Vector起始偏移位置开始序列化数据

问题场景 #

想要将数据序列化到缓冲区，但不从第一个字节开始，尝试传递切片时遇到问题：

• 传递整个Vec时序列化正常：

let mut buffer = Vec::new();
let mut serializer = Serializer::new(&mut buffer);

• 传递长度为0的切片时序列化失败：

let mut buffer = Vec::new();
let mut serializer = Serializer::new(&mut buffer[..]);

• 提前调整缓冲区大小可以解决序列化失败，但无法得知实际写入的字节数：

let mut buffer = Vec::new();
buffer.resize(20, 0);
let mut serializer = Serializer::new(&mut buffer[..]);

解决方案 #

原因分析 #

&mut [u8]实现的Write trait只能向已分配的内存空间写入数据，空切片没有可写入的空间，因此序列化时会触发写入失败（通常返回ErrorKind::WriteZero）。要实现从指定偏移位置序列化+跟踪写入字节数，可以用以下两种方式：

方式1：使用Cursor<&mut [u8]>（简单直接） #

借助Cursor记录写入位置，先定位到目标偏移，序列化后计算实际写入字节数：

use std::io::Cursor;

// 提前分配足够的缓冲区空间
let mut buffer = vec![0; 20];
// 创建Cursor并定位到偏移位置（比如第5个字节，索引从0开始）
let mut cursor = Cursor::new(&mut buffer[..]);
cursor.set_position(5);

// 将Cursor传给序列化器
let mut serializer = Serializer::new(&mut cursor);
// 执行序列化操作...

// 计算实际写入的字节数：当前位置减去初始偏移
let bytes_written = cursor.position() - 5;

这种方式无需自定义代码，适合提前知道缓冲区大致大小的场景。

方式2：自定义简易OffsetWriter（自动管理缓冲区大小） #

如果不想提前固定缓冲区大小，希望自动扩容并从指定偏移开始写入，可以实现一个轻量的Write包装器：

use std::io::{self, Write};

struct OffsetWriter<'a> {
    inner: &'a mut Vec<u8>,
    offset: usize,
    written: usize,
}

impl<'a> OffsetWriter<'a> {
    // 创建实例：传入目标Vec和起始偏移，自动补全偏移前的空间（填充0）
    fn new(inner: &'a mut Vec<u8>, offset: usize) -> Self {
        if inner.len() < offset {
            inner.resize(offset, 0);
        }
        OffsetWriter {
            inner,
            offset,
            written: 0,
        }
    }

    // 获取实际写入的字节数
    fn written(&self) -> usize {
        self.written
    }
}

impl<'a> Write for OffsetWriter<'a> {
    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
        let start = self.offset + self.written;
        // 自动扩容缓冲区以容纳新数据
        if self.inner.len() < start + buf.len() {
            self.inner.resize(start + buf.len(), 0);
        }
        // 复制数据到目标位置
        self.inner[start..start + buf.len()].copy_from_slice(buf);
        let len = buf.len();
        self.written += len;
        Ok(len)
    }

    fn flush(&mut self) -> io::Result<()> {
        Ok(())
    }
}

// 使用示例
let mut buffer = Vec::new();
// 从第5个字节开始序列化
let mut writer = OffsetWriter::new(&mut buffer, 5);
let mut serializer = Serializer::new(&mut writer);
// 执行序列化操作...

// 获取实际写入的字节数
let bytes_written = writer.written();
// buffer的前5字节为0，后续为序列化数据

总结 #

如果只是临时需求，用Cursor配合提前分配的缓冲区最省事；如果需要频繁处理动态偏移的序列化场景，自定义OffsetWriter能更灵活地管理缓冲区和写入计数，不需要复杂的逻辑实现。

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