有没有一种方法不必初始化数组两次

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块中似乎没有任何区别。

Answer 1

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

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

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

您的具体案例是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) }
    };
    // ...
}

---

你不能收集到一个数组中，但如果你有一个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 }

Answer 2

您可以使用https://doc.rust-lang.org/stable/std/array/fn.from_fn.html

fn foo(xs: &[i32; 1000]) {
    let ys: [i32; 1000] = array::from_fn(|i| (xs[i] / 3) as i32);