如何要求Rust trait实现类型具有固定大小？

我想定义一个由MaybeUninit包裹的 trait 对象切片，比如[MaybeUninit<dyn MyTrait>;2]，但这么做行不通——因为 Rust 编译时无法确定dyn MyTrait的大小。所以我想问：有没有办法要求某个 trait 的所有实现类型必须占用特定大小？比如强制所有实现MyTrait的类型都是4字节？

补充背景：我正在做一个“可组合”的内存分配器，有个ChunkAllocator<CHUNK_SIZE>结构体，它按固定大小的块分配内存。我想把多个这类分配器存在一个切片里，做成一个能分配不同大小内存的分配器。这些分配器都实现了同一个trait（Allocator），并且大小相同（或者我可以限制它们的大小），但它们的类型签名不一样。我希望把分配大小保留在类型里，而不是移到结构体的字段中。

1. 用Sized约束 + 关联常量强制固定大小 #

给 trait 加上Sized约束，再通过关联常量强制实现类型的大小符合要求，编译器会自动检查：

use std::mem;

trait MyTrait: Sized {
    const REQUIRED_SIZE: usize = 4;
}

// 符合大小要求的实现
struct FourByteType(u32);
impl MyTrait for FourByteType {}

// 以下代码会编译报错，因为类型大小不符合要求
// struct EightByteType(u64);
// impl MyTrait for EightByteType {}

// 可选：用宏显式验证大小
macro_rules! assert_size {
    ($ty:ty, $size:expr) => {
        const _: () = assert!(mem::size_of::<$ty>() == $size, "Type size mismatch");
    };
}

assert_size!(FourByteType, 4);

2. 用字节数组存储，强制类型转换 #

如果要存到固定大小的数组里，可以直接用字节数组存储未初始化内存，再把符合大小的类型指针转进去：

use std::mem::{self, MaybeUninit};

trait Allocator {
    fn allocate(&self, size: usize) -> *mut u8;
}

struct ChunkAllocator<const CHUNK_SIZE: usize>;

impl<const CHUNK_SIZE: usize> Allocator for ChunkAllocator<CHUNK_SIZE> {
    fn allocate(&self, size: usize) -> *mut u8 {
        // 简化实现，实际需补充内存分配逻辑
        std::ptr::null_mut()
    }
}

// 假设所有Allocator实现均为4字节
const ALLOCATOR_SIZE: usize = 4;
type AllocatorStorage = [MaybeUninit<u8>; ALLOCATOR_SIZE];

fn main() {
    let mut storage: [AllocatorStorage; 2] = [MaybeUninit::uninit_array(); 2];
    
    // 存入ChunkAllocator<16>
    let alloc1 = ChunkAllocator::<16>;
    assert!(mem::size_of_val(&alloc1) == ALLOCATOR_SIZE);
    unsafe {
        std::ptr::copy_nonoverlapping(&alloc1 as *const _ as *const u8, storage[0].as_mut_ptr(), ALLOCATOR_SIZE);
    }
    
    // 取出并使用trait对象
    unsafe {
        let alloc_ref = &*storage[0].as_ptr() as *const ChunkAllocator<16> as *const dyn Allocator;
        let _ = (*alloc_ref).allocate(16);
    }
}

3. 用枚举封装所有可能的实现 #

如果你的分配器类型是有限的，直接用枚举把它们包起来，枚举的大小是固定的（取最大成员的大小加对齐）：

trait Allocator {
    fn allocate(&self, size: usize) -> *mut u8;
}

struct ChunkAllocator<const CHUNK_SIZE: usize>;

impl<const CHUNK_SIZE: usize> Allocator for ChunkAllocator<CHUNK_SIZE> {
    fn allocate(&self, size: usize) -> *mut u8 {
        std::ptr::null_mut()
    }
}

enum ComposedAllocator {
    Small(ChunkAllocator<16>),
    Medium(ChunkAllocator<64>),
    Large(ChunkAllocator<256>),
}

impl Allocator for ComposedAllocator {
    fn allocate(&self, size: usize) -> *mut u8 {
        match self {
            ComposedAllocator::Small(a) => a.allocate(size),
            ComposedAllocator::Medium(a) => a.allocate(size),
            ComposedAllocator::Large(a) => a.allocate(size),
        }
    }
}

// 直接存储固定大小的枚举数组
let allocators: [ComposedAllocator; 3] = [
    ComposedAllocator::Small(ChunkAllocator),
    ComposedAllocator::Medium(ChunkAllocator),
    ComposedAllocator::Large(ChunkAllocator),
];

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