有没有办法不必两次初始化数组？答案

【问题标题】：Is there a way to not have to initialize arrays twice?有没有办法不必两次初始化数组？
【发布时间】：2014-11-28 21:44:20
【问题描述】：

我需要将数组的每个元素初始化为非常量表达式。我可以这样做而不必先将数组的每个元素初始化为一些无意义的表达式吗？这是我想做的一个例子：

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

【问题讨论】：

标签： arrays initialization rust array-initialization

【解决方案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 }

【讨论】：