如何构造运行时才知晓大小的DST结构体实例？

问题背景 #

我定义了一个可适配固定或动态大小场景的结构体，最后一个元素是u8数组：

struct MyStructImpl<E: ?Sized> {
    field: char,
    extendable: E,
}
type MyStructFixed<const N: usize> = MyStructImpl<[u8; N]>;
type MyStructUnsized = MyStructImpl<[u8]>;

编译时已知数组大小的情况下，可以轻松构造动态大小版本的Box实例：

impl MyStructUnsized {
    fn new_from_fixed_array<const N: usize>(field: char, arr: [u8; N]) -> Box<Self> {
        Box::new(MyStructFixed {
            field,
            extendable: arr,
        })
    }
}

但如果仅在运行时才知晓数组大小，找不到可行的构造方法，比如这个未实现的函数：

impl MyStructUnsized {
    fn new_from_slice(field: char, arr: &[u8]) -> Box<Self> {
        todo!(); // 求助！
    }
}

理论上这完全可行：分配对应大小的内存，在其中构造结构体，最后复制u8元素即可。Box<T>本身支持释放动态大小的T，所以内存回收不是问题。但Rust中实现起来并不像C/C++那样直接——后者的结构体布局是明确指定的。

尝试过用Box::from_raw()，它能把*mut T转换成Box<T>，而内存可以通过std::alloc::alloc()分配，但这个分配函数需要std::alloc::Layout（包含大小和对齐信息）。问题在于，运行时才知道N的情况下，MyStructFixed<N>的大小和对齐方式无法直接获取——因为默认的#[repr(Rust)]类型布局是未指定的。

理论上编译器肯定知道这些信息（毕竟要为MyStructUnsized的成员函数生成代码），应该存在类似这样的编译器内置函数：

fn get_layout<T: ?Sized>(len: usize) -> Layout;

但找不到对应的实现。

自己猜了一个可能的布局计算方式：

fn guess_required_layout(len: usize) -> Layout {
    Layout::from_size_align(
        std::mem::size_of::<MyStructFixed<0>>() + len * std::mem::size_of::<u8>(),
        std::mem::align_of::<MyStructFixed<0>>(),
    )
    .unwrap()
}

但这完全是对可扩展结构体布局的假设，并没有官方保证。

请问在Rust 1.74.0（当前稳定版）中，构造这种运行时确定大小的动态大小结构体Box实例的惯用方法是什么？

解决方案 #

在稳定版Rust中，正确的做法是结合未初始化内存分配、指针操作和布局计算，同时依赖Rust对DST（动态大小类型）布局的隐含稳定保证——对于最后一个字段是切片的结构体，其布局满足：结构体固定部分的大小 + 切片元素总大小，对齐方式与固定部分的对齐一致（因为u8的对齐是1，不会影响整体对齐）。

直接实现方案 #

以下是可工作的安全（在unsafe块内遵循规则）实现：

use std::alloc::Layout;
use std::mem;
use std::ptr;

impl MyStructUnsized {
    fn new_from_slice(field: char, arr: &[u8]) -> Box<Self> {
        // 计算结构体的布局：固定部分大小 + 数组长度，对齐取固定部分的对齐
        let fixed_layout = Layout::new::<MyStructFixed<0>>();
        let total_size = fixed_layout.size() + arr.len();
        let layout = Layout::from_size_align(total_size, fixed_layout.align()).unwrap();

        // 分配未初始化内存，分配失败时触发OOM处理
        let ptr = unsafe { std::alloc::alloc(layout) };
        if ptr.is_null() {
            std::alloc::handle_alloc_error(layout);
        }

        unsafe {
            // 写入固定字段char
            ptr::write(ptr.cast::<char>(), field);
            // 复制切片数据到结构体的extendable字段位置
            let data_ptr = ptr.add(fixed_layout.size()) as *mut u8;
            ptr::copy_nonoverlapping(arr.as_ptr(), data_ptr, arr.len());

            // 将裸指针转换为Box<MyStructUnsized>，由Box接管内存管理
            Box::from_raw(ptr as *mut MyStructUnsized)
        }
    }
}

方案说明 #

虽然#[repr(Rust)]的布局未完全指定，但Rust对DST结构体有以下隐含的稳定保证：

1. 结构体的固定部分会按声明顺序排列，最后跟随DST字段的内容
2. 整体对齐由结构体中对齐要求最高的字段决定——这里char的对齐是4，u8是1，所以整体对齐与MyStructFixed<0>一致
3. 切片类型的DST结构体，其长度信息会被Box正确跟踪，确保后续的内存释放和方法调用正常工作

注意事项 #

• 如果最后一个字段是对齐要求更高的类型（比如u64），需要额外计算固定部分和DST字段之间的填充空间，避免内存对齐错误
• 所有unsafe操作必须严格遵循Rust的内存安全规则：确保指针有效、内存未被重复释放、数据正确初始化等

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