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

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

- kmky

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文档中的one of the examples，请阅读它以了解该实现的安全性讨论。

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 }

- Dylan

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);

- Ariel