初始化失败时，如何正确销毁部分初始化的MaybeUninit数组/向量？

问题背景 #

我需要实现使用MaybeUninit直接初始化数组或向量，且在初始化失败时正确销毁已初始化元素的逻辑。数组场景通过API示例容易处理，但向量的实现难度更高。

我编写了泛型函数try_new<T: TryFrom<()>, A: ArrayUninit<T>>(len: usize)，意图通过T实现的TryFrom::try_from(_:())可失败生成器创建T类型集合，用indices(len: usize)模拟异步场景下的随机初始化顺序，函数依赖ArrayUninit::try_uninit(len: usize)构建未初始化的数组/向量（Vec<Data>和[Data; N]均实现该trait）。

初始代码看似可行，但我不确定直接销毁未初始化数据的做法是否正确——当前失败时会销毁集合中所有地址的数据（包括已初始化和未初始化的）。想确认该方法的正确性，若不正确需遵循哪些规则？之后我更新了代码，通过ArrayUninit trait为数组和向量实现不同处理逻辑，仅在数组场景使用MaybeUninit。

核心安全规则 #

• 绝对不能对未初始化内存调用drop：Rust中只有完全初始化的T实例才能安全执行析构逻辑，未初始化内存直接触发销毁会导致未定义行为（UB）。
• 初始化失败时，仅需销毁已成功初始化的元素，未初始化的部分直接释放内存即可（无需调用析构）。

分场景实现方案 #

1. 固定大小数组的处理 #

对于[T; N]，必须用MaybeUninit<[T; N]>承载未初始化状态（数组内存连续且固定）。初始化时逐个元素写入，失败时遍历已初始化元素调用drop，再丢弃未初始化内存。

示例代码：

use std::mem::MaybeUninit;
use std::convert::TryFrom;
use rand;

struct Data;

impl TryFrom<()> for Data {
    type Error = &'static str;
    fn try_from(_: ()) -> Result<Self, Self::Error> {
        // 模拟随机初始化失败
        if rand::random() {
            Ok(Data)
        } else {
            Err("初始化失败")
        }
    }
}

fn try_new_array<const N: usize>() -> Result<[Data; N], &'static str> {
    let mut array = MaybeUninit::<[Data; N]>::uninit();
    let mut initialized_indices = Vec::new();

    // 模拟随机初始化顺序
    for idx in rand::seq::index::sample(&mut rand::thread_rng(), N, N).into_iter() {
        match Data::try_from(()) {
            Ok(val) => {
                unsafe {
                    (*array.as_mut_ptr())[idx] = val;
                }
                initialized_indices.push(idx);
            }
            Err(e) => {
                // 仅销毁已初始化的元素
                for &idx in &initialized_indices {
                    unsafe {
                        std::ptr::drop_in_place(&mut (*array.as_mut_ptr())[idx]);
                    }
                }
                return Err(e);
            }
        }
    }

    // 所有元素初始化完成，转换为已初始化数组
    unsafe { Ok(array.assume_init()) }
}

2. 动态大小向量的处理 #

对于Vec<T>，无需使用MaybeUninit<Vec<T>>，直接通过Vec::with_capacity预分配内存，用ptr::write写入未初始化区域即可。Vec内部会跟踪已初始化长度，失败时仅需销毁已写入的元素，剩余内存由Vec的drop逻辑自动释放。

示例代码：

fn try_new_vec(len: usize) -> Result<Vec<Data>, &'static str> {
    let mut vec = Vec::with_capacity(len);
    let mut initialized_indices = Vec::new();

    // 模拟随机初始化顺序
    for idx in rand::seq::index::sample(&mut rand::thread_rng(), len, len).into_iter() {
        match Data::try_from(()) {
            Ok(val) => {
                unsafe {
                    let ptr = vec.as_mut_ptr().add(idx);
                    std::ptr::write(ptr, val);
                }
                initialized_indices.push(idx);
            }
            Err(e) => {
                // 销毁已初始化元素
                for &idx in &initialized_indices {
                    unsafe {
                        std::ptr::drop_in_place(vec.as_mut_ptr().add(idx));
                    }
                }
                return Err(e);
            }
        }
    }

    // 所有元素初始化完成，设置Vec的实际长度
    unsafe {
        vec.set_len(len);
    }
    Ok(vec)
}

3. 泛型统一处理（基于ArrayUninit trait） #

通过自定义trait抽象数组和向量的初始化逻辑，让泛型函数可以统一调用，同时为不同类型实现安全处理逻辑：

use std::mem::MaybeUninit;
use std::convert::TryFrom;
use rand;

trait ArrayUninit<T> {
    type Output;
    fn try_uninit(len: usize) -> Self;
    fn write(&mut self, idx: usize, value: T);
    fn drop_initialized(&mut self, indices: &[usize]);
    fn assume_init(self) -> Self::Output;
}

// 固定大小数组的实现
impl<T, const N: usize> ArrayUninit<T> for MaybeUninit<[T; N]> {
    type Output = [T; N];

    fn try_uninit(_len: usize) -> Self {
        MaybeUninit::<[T; N]>::uninit()
    }

    fn write(&mut self, idx: usize, value: T) {
        unsafe {
            (*self.as_mut_ptr())[idx] = value;
        }
    }

    fn drop_initialized(&mut self, indices: &[usize]) {
        for &idx in indices {
            unsafe {
                std::ptr::drop_in_place(&mut (*self.as_mut_ptr())[idx]);
            }
        }
    }

    fn assume_init(self) -> Self::Output {
        unsafe { self.assume_init() }
    }
}

// Vec的实现
impl<T> ArrayUninit<T> for Vec<T> {
    type Output = Vec<T>;

    fn try_uninit(len: usize) -> Self {
        Vec::with_capacity(len)
    }

    fn write(&mut self, idx: usize, value: T) {
        unsafe {
            let ptr = self.as_mut_ptr().add(idx);
            std::ptr::write(ptr, value);
        }
    }

    fn drop_initialized(&mut self, indices: &[usize]) {
        for &idx in indices {
            unsafe {
                std::ptr::drop_in_place(self.as_mut_ptr().add(idx));
            }
        }
    }

    fn assume_init(mut self) -> Self::Output {
        let len = self.capacity();
        unsafe {
            self.set_len(len);
        }
        self
    }
}

fn try_new<T: TryFrom<()>, A: ArrayUninit<T>>(len: usize) -> Result<A::Output, T::Error>
where
    T::Error: 'static,
{
    let mut collection = A::try_uninit(len);
    let mut initialized_indices = Vec::new();

    // 模拟随机初始化顺序
    for idx in rand::seq::index::sample(&mut rand::thread_rng(), len, len).into_iter() {
        match T::try_from(()) {
            Ok(val) => {
                collection.write(idx, val);
                initialized_indices.push(idx);
            }
            Err(e) => {
                collection.drop_initialized(&initialized_indices);
                return Err(e);
            }
        }
    }

    Ok(collection.assume_init())
}

关键注意事项 #

• 准确跟踪已初始化索引：随机初始化场景下，必须记录所有成功写入的位置，失败时仅销毁这些位置的元素。
• 避免重复初始化：确保每个索引只被写入一次，否则会导致T的重复析构（UB）。
• Vec::set_len必须在所有元素初始化完成后调用，否则会让Vec误将未初始化内存视为已初始化，触发UB。
• 所有unsafe块必须严格遵循Rust内存安全规则，仅在内存确实已初始化时调用drop_in_place或assume_init。

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