arrays - 有没有办法不必两次初始化数组？

Question

我需要将数组的每个元素初始化为非常量表达式。我可以这样做而不必首先将数组的每个元素初始化为一些无意义的表达式吗？这是我希望能够执行的操作的示例:

fn foo(xs: &[i32; 1000]) {
    let mut ys: [i32; 1000];

    for (x, y) in xs.iter().zip(ys.iter_mut()) {
        *y = *x / 3;
    }
    // ...
}

此代码给出了编译时错误:

error[E0381]: borrow of possibly uninitialized variable: `ys`
 --> src/lib.rs:4:33
  |
4 |     for (x, y) in xs.iter().zip(ys.iter_mut()) {
  |                                 ^^ use of possibly uninitialized `ys`

要解决这个问题，我需要更改函数的第一行以使用一些虚拟值初始化 ys 的元素，如下所示:

let mut ys: [i32; 1000] = [0; 1000];

有什么办法可以省略额外的初始化吗？将所有内容包装在 unsafe block 中似乎没有任何区别。

Answer 1

在某些情况下，您可以使用 std::mem::MaybeUninit :

use std::mem::MaybeUninit;

fn main() {
    let mut ys: MaybeUninit<[i32; 1000]> = MaybeUninit::uninit();
}

通过 assume_init 删除 MaybeUninit 包装器|是不安全的，因为访问未初始化的值在 Rust 中是未定义的行为，编译器不能再保证 ys 的每个值在读取之前都会被初始化。

您的具体情况是 one of the examples在 MaybeUninit 文档中；阅读它以讨论有关此实现的安全性:

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

fn foo(xs: &[i32; 1000]) {
    // I copied this code from Stack Overflow without
    // reading why it is or is not safe.
    let ys: [i32; 1000] = {
        let mut ys: [MaybeUninit<i32>; 1000] = unsafe { MaybeUninit::uninit().assume_init() };

        let mut xs = xs.into_iter();

        for y in &mut ys[..] {
            if let Some(x) = xs.next().copied() {
                *y = MaybeUninit::new(x / 3);
            }
        }

        unsafe { mem::transmute(ys) }
    };
    // ...
}

---

你 cannot collect into an array ，但是如果你有一个 Vec，你可以这样做:

let ys: Vec<_> = xs.iter().map(|&x| x / 3).collect();

对于您的特定问题，您还可以克隆传入数组然后对其进行变异:

let mut ys = xs.clone();
for y in ys.iter_mut() { *y = *y / 3 }