如何防止MaybeUninit提前将内存初始化为零？

你的代码中clear()调用*self = SmallVec::new()时触发了整个内联数组的清零，核心原因有两点：

• 你用const { MaybeUninit::uninit() }; N创建内联数组，虽然MaybeUninit设计为跳过初始化，但Rust的常量数组初始化会将每个元素都设置为该常量值，编译器会将此操作优化为memset清零（MaybeUninit::uninit()在常量上下文中的表现等价于零初始化）。
• 赋值整个SmallVec实例时，编译器会完整复制Inline变体的所有内存，包括整个数组，因此触发了大规模清零操作。

此外，你的实现缺少长度跟踪字段，这不仅会导致内存泄漏（无法正确销毁活跃元素），也让clear()无法区分数组中哪些元素是真正需要处理的。

要避免清零操作，核心思路是：

1. 添加长度字段跟踪活跃元素数量，无需关心未使用的内联数组内存。
2. 在clear()中仅切换枚举判别式并重置长度，不复制/初始化整个内联数组。
3. 使用unsafe代码直接创建未初始化的内联数组，跳过常量初始化带来的清零。

以下是修正后的实现：

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

const N: usize = 24;

pub struct SmallVec<T> {
    len: usize,
    storage: Storage<T>,
}

enum Storage<T> {
    Inline([MaybeUninit<T>; N]),
    Heap(*mut T, usize), // (指针, 容量)
}

impl<T> SmallVec<T> {
    /// 创建空的 SmallVec，内联数组完全未初始化
    pub fn new() -> Self {
        unsafe {
            SmallVec {
                len: 0,
                // 直接创建未初始化的内联数组，跳过任何初始化操作
                storage: Storage::Inline(MaybeUninit::uninit().assume_init()),
            }
        }
    }

    /// 清空 SmallVec，仅重置判别式和长度，不触碰未使用的内存
    pub fn clear(&mut self) {
        // 先销毁所有活跃元素
        self.drop_active_elements();

        // 切换到内联变体（如果当前是堆变体）
        if let Storage::Heap(ptr, cap) = &mut self.storage {
            // 释放堆内存（需匹配实际分配逻辑，此处假设用Vec分配）
            unsafe {
                Vec::from_raw_parts(*ptr, 0, *cap);
            }
            // 直接替换为未初始化的内联数组，不做内存清零
            unsafe {
                mem::replace(&mut self.storage, Storage::Inline(MaybeUninit::uninit().assume_init()));
            }
        }

        // 重置长度为0
        self.len = 0;
    }

    /// 销毁所有活跃元素
    fn drop_active_elements(&mut self) {
        match &mut self.storage {
            Storage::Inline(arr) => {
                for i in 0..self.len {
                    unsafe {
                        arr[i].assume_init_drop();
                    }
                }
            }
            Storage::Heap(ptr, _) => {
                for i in 0..self.len {
                    unsafe {
                        (*ptr.add(i)).drop_in_place();
                    }
                }
            }
        }
    }
}

/// 实现 Drop 以确保元素被正确销毁
impl<T> Drop for SmallVec<T> {
    fn drop(&mut self) {
        self.drop_active_elements();
        if let Storage::Heap(ptr, cap) = &mut self.storage {
            unsafe {
                Vec::from_raw_parts(*ptr, 0, *cap);
            }
        }
    }
}

1. 跳过内联数组初始化：用MaybeUninit::uninit().assume_init()直接创建未初始化的数组，编译器不会生成任何清零操作。
2. 仅修改必要状态：clear()仅销毁活跃元素、切换枚举判别式、重置长度，不复制或清零整个数组，最终编译后的代码只会修改枚举判别式和长度字段，无memset调用。
3. 正确的内存管理：添加Drop实现和元素销毁逻辑，避免内存泄漏，符合Rust的安全规范。

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