使用常量泛型将可变指针数组转换为可变引用

Question

假设我保证（通过未指定的方式）我有一个[*mut；N]类型的数组，其中包含N有效且不相交的可变指针，所有指针都具有生存期'a。如何将其转换为可变引用数组[

换句话说，我如何实现这个功能？

unsafe fn ptrs_to_refs<'a, T, const N: usize>(ptrs: [*mut T; N]) -> [&'a mut T; N] {
    // What goes here?
}

我不是特别寻找使用分配步骤的实现（例如使用Vec）。

因为min_const_generics被设置为在Rust 1.51中稳定，所以这个问题针对的是一个假设的稳定Rust，它也具有min_const_generics。我正在寻找与这些要求兼容的答案，不使用其他不稳定的功能。

例如，使用功能array\u map

unsafe fn ptrs_to_refs<'a, T, const N: usize>(ptrs: [*mut T; N]) -> [&'a mut T; N] {
   arr.map(|ptr| unsafe { &mut *ptr })
}

但由于这并没有稳定到1.51（据我所知），我不希望使用它。




Answer 1

改编maybeuniit文档中的一个示例：

unsafe fn ptrs_to_refs<'a, T, const N: usize>(ptrs: [*mut T; N]) -> [&'a mut T; N] {
    // Create an uninitialized array of `MaybeUninit`. The `assume_init` is
    // safe because the type we are claiming to have initialized here is a
    // bunch of `MaybeUninit`s, which do not require initialization.
    let mut refs: [MaybeUninit<&'a mut T>; N] = MaybeUninit::uninit().assume_init();
    
    // Dropping a `MaybeUninit` does nothing. Thus using raw pointer
    // assignment instead of `ptr::write` does not cause the old
    // uninitialized value to be dropped.
    for i in 0..N {
        refs[i] = MaybeUninit::new(&mut *ptrs[i]);
    }
    
    std::mem::transmute_copy::<_, [&'a mut T; N]>(&refs)
}

这个答案并不依赖于将[*mut T； N]转换为[是否安全

Answer 2

std::mem::transmute是我首先到达的地方，但目前不起作用；有关完整详细信息，请参阅Const泛型：泛型数组transmute不起作用#61956。

同时，可以使用联合作为解决方案，因为指针和引用具有相同的布局：

use core::mem::ManuallyDrop;

unsafe fn ptrs_to_refs<'a, T, const N: usize>(ptrs: [*mut T; N]) -> [&'a mut T; N] {
    union X<'a, T, const N: usize> {
        a_raw: ManuallyDrop<[*mut T; N]>,
        a_ref: ManuallyDrop<[&'a mut T; N]>,
    }

    let a_raw = ManuallyDrop::new(ptrs);
    let x = X { a_raw };
    ManuallyDrop::into_inner(x.a_ref)
}

您还应该能够使用transmute_copy达到相同的效果：

unsafe fn ptrs_to_refs<'a, T, const N: usize>(ptrs: [*mut T; N]) -> [&'a mut T; N] {
    std::mem::transmute_copy(&ptrs)
}

Answer 3

理想情况下，您可以在此处使用std::mem::transmute，因为引用和指针具有相同的内存布局。不幸的是，std::mem::transmute不适用于通用数组，即使两种类型具有相同的布局。但是，您可以使用Union来解决这个问题，因为使用#[repr（C）]联合类似于transmute：

#[repr(C)]
union Transmute<'a, T, const N: usize> {
    ptr_arr: ManuallyDrop<[*mut T; N]>,
    ref_arr: ManuallyDrop<[&'a mut T; N]>,
}

unsafe fn ptrs_to_refs<'a, T, const N: usize>(ptrs: [*mut T; N]) -> [&'a mut T; N] {
    let u = Transmute::<'a, T, N> { ptr_arr: ManuallyDrop::new(ptrs) };
    ManuallyDrop::into_inner(u.ref_arr)
}

您还可以使用std:：mem:：transmute_copy，它在这里有效地执行相同的操作：

unsafe fn ptrs_to_refs<'a, T, const N: usize>(ptrs: [*mut T; N]) -> [&'a mut T; N] {
    std::mem::transmute_copy(&ptrs)
}