Rust中如何从MaybeUninit获取&mut [u8]用于写入？求规范方案

为什么原代码属于未定义行为？ #

原代码里unsafe { &mut *buf.as_mut_ptr() }直接把MaybeUninit<[u8; BUF_SIZE]>的指针解引用为&mut [u8]，这违反了Rust的内存安全规则。&mut [u8]这个类型强制要求切片内所有字节都处于已初始化状态，编译器会基于这个假设做优化——哪怕你实际只写入不读取，这种类型上的错误声明已经触发了未定义行为，并非只有实际读取未初始化内存才会触发UB。

规范实现方式 #

方式1：正确使用std::slice::from_raw_parts_mut #

不要直接解引用指针，而是用该函数创建切片，同时明确保留缓冲区总大小，避免出错：

use std::mem::MaybeUninit;

const BUF_SIZE: usize = 1024;

// 初始化未初始化缓冲区
let mut buf: MaybeUninit<[u8; BUF_SIZE]> = MaybeUninit::uninit();
// 创建指向未初始化内存的切片，类型为&mut [MaybeUninit<u8>]
let buf_slice = unsafe { std::slice::from_raw_parts_mut(buf.as_mut_ptr() as *mut MaybeUninit<u8>, BUF_SIZE) };

let mut len = 0;
loop {
    // 仅将待写入区域转换为&mut [u8]
    let write_slice = unsafe { std::slice::from_raw_parts_mut(buf_slice[len..].as_mut_ptr() as *mut u8, buf_slice.len() - len) };
    let n = stream.read(write_slice)?;
    if n == 0 {
        break; // 读取结束
    }
    len += n;
    // ...处理已写入的数据
}

// 最后将已写入部分转换为已初始化切片
let initialized_buf = unsafe { std::slice::from_raw_parts(buf.as_ptr() as *const u8, len) };

这种方式明确区分未初始化、待写入、已写入区域，不会向编译器传递错误的类型假设。

方式2：利用Rust 1.59+的MaybeUninit切片支持 #

从Rust 1.59开始，MaybeUninit支持直接转换为切片，代码更简洁：

use std::mem::MaybeUninit;

const BUF_SIZE: usize = 1024;

let mut buf: MaybeUninit<[u8; BUF_SIZE]> = MaybeUninit::uninit();
let buf_slice: &mut [MaybeUninit<u8>] = buf.as_mut_slice();

let mut len = 0;
loop {
    let write_slice = unsafe { std::slice::from_raw_parts_mut(buf_slice[len..].as_mut_ptr() as *mut u8, buf_slice.len() - len) };
    let n = stream.read(write_slice)?;
    if n == 0 {
        break;
    }
    len += n;
    // ...
}

易用的第三方库推荐 #

arrayvec #

arrayvec的ArrayVec提供栈上固定大小缓冲区，安全封装未初始化内存操作：

use arrayvec::ArrayVec;

const BUF_SIZE: usize = 1024;

let mut buf = ArrayVec::<u8, BUF_SIZE>::new();
loop {
    let n = stream.read(buf.spare_capacity_mut())?;
    if n == 0 {
        break;
    }
    unsafe {
        buf.set_len(buf.len() + n);
    }
    // 处理buf中的数据
}

spare_capacity_mut()返回指向未初始化内存的&mut [MaybeUninit<u8>]，写入后通过set_len标记为已初始化，unsafe块范围极小，降低出错概率。

uninit #

专门简化未初始化内存操作的库，完全封装unsafe逻辑，对外提供安全API：

use uninit::UninitSlice;

const BUF_SIZE: usize = 1024;

let mut buf = UninitSlice::<u8, BUF_SIZE>::uninit();
let mut len = 0;
loop {
    let n = stream.read(buf.slice_from(len))?;
    if n == 0 {
        break;
    }
    len += n;
    // ...
}
let initialized = buf.init_to(len);

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