55

如何在 Rust 中创建一个空的可变二维数组？

这是我到目前为止所尝试的：

let mut state[[u8 * 4] * 4];

这会产生错误

error: expected one of `:`, `;`, `=`, or `@`, found `[`
 --> src/main.rs:2:18
  |
2 |     let mut state[[u8 * 4] * 4];
  |                  ^ expected one of `:`, `;`, `=`, or `@` here
4

10 回答 10

68

在 Rust 1.0 中，以下工作：

let mut state = [[0u8; 4]; 6];
state[0][1] = 42;

请注意，内部段的长度是类型的组成部分。例如，您可以state按如下方式引用（并通过）：

let a: &[[u8; 4]] = &state;

但并非没有指定子数组的固定长度。如果您需要可变长度子数组，您可能需要执行以下操作：

let x: [Box<[u8]>; 3] = [
    Box::new([1, 2, 3]),
    Box::new([4]), 
    Box::new([5, 6])
];
let y: &[Box<[u8]>] = &x;
于 2015-01-16T13:02:17.843 回答
23

编者注：这个答案早于 Rust 1.0，并且一些概念和语法已经改变。其他答案适用于 Rust 1.0。

您希望数组的内容是可变的还是包含它的变量？如果你想要可变内容，这对你有用吗？

let mut state = [[0u8; 4]; 4];

如果您希望变量可变但内容不可变，请尝试以下操作：

let mut state = [[0u8; 4]; 4];

这有帮助吗？我实际上并没有编译它，所以语法可能略有偏差。

于 2012-11-05T15:39:08.730 回答
20

您可以像这样创建一个动态大小的 2D 矢量：

fn example(width: usize, height: usize) {
    // Base 1d array
    let mut grid_raw = vec![0; width * height];

    // Vector of 'width' elements slices
    let mut grid_base: Vec<_> = grid_raw.as_mut_slice().chunks_mut(width).collect();

    // Final 2d array `&mut [&mut [_]]`
    let grid = grid_base.as_mut_slice();

    // Accessing data
    grid[0][0] = 4;
}
于 2016-04-02T17:30:06.440 回答
15

Vec如果您在编译时没有已知的大小，您也可以像这样（使用）创建一个二维数组：

let width = 4;
let height = 4;

let mut array = vec![vec![0; width]; height];

像这样使用它：

array[2][2] = 5;

println!("{:?}", array);

输出：

0 0 0 0
0 0 0 0
0 0 5 0
0 0 0 0

自 rust 1.0.0 起可用https://doc.rust-lang.org/std/vec/struct.Vec.html

于 2019-11-26T03:00:29.997 回答
10

初始化：
2D Array 初始化有几种方法：

  1. 对 M（行）和 N（列）使用常量

    const M: usize = 2;
const N: usize = 4;

let mut grid = [[0 as u8; N] ; M];

  2. 带有类型注释的显式声明

    let mut grid: [[u8; 4]; 2] = [[0; 4]; 2];

遍历：
只读遍历很简单：

for (i, row) in grid.iter().enumerate() {
    for (j, col) in row.iter().enumerate() {
        print!("{}", col);
    }
    println!()
}

或者

for el in grid.iter().flat_map(|r| r.iter()) {
    println!("{}", el);
}

更新元素：

for (i, row) in grid.iter_mut().enumerate() {
    for (j, col) in row.iter_mut().enumerate() {
        col = 1;
    }
}
于 2018-12-26T10:17:46.133 回答
5

如果您愿意安装板条箱，它ndarray可以优雅地为您完成。

use ndarray::Array2;
let mut array = Array2::zeros((4, 3));
array[[1, 1]] = 7;

对于一些已经存在的答案，不可能使用非常量维度创建数组。没有这样的问题ndarray。您还可以轻松创建多于两个维度的维度。

您可以在此处和此处找到更多详细信息。

于 2020-04-19T19:32:41.660 回答
3

好吧，如何创建向量的问题在上面得到了适当的解决。下面是创建一个二维向量然后用用户输入填充它的代码片段：

use std::io;

fn main(){
    let width = 4;
    let height = 4;

    let mut array = vec![vec![0; width]; height];

    for i in 0..4 {
        let mut xstr = String::from("");
        io::stdin().read_line(&mut xstr).ok().expect("read error");
        array[i] = xstr
            .split_whitespace()
            .map(|s| s.parse().expect("parse error"))
            .collect();
    }

    println!("{:?}", array)
}
于 2020-06-29T10:59:19.523 回答
2

显式初始化

let directions: [[i32; 2]; 4] = [[-1, 0], [0, 1], [0, 1], [1, 0]]

具有相同的价值

let directions: [[i32; 2]; 4] = [[0; 2]; 4];
于 2021-02-08T00:50:42.730 回答
2

惯用的 C 二维数组使用与访问数组时相同的数组大小顺序声明：

// Declaration
int array_2d[8][16]; // An 8 by 16 2D array
...
// Access
array_2d[0][1] = 5;

在 Rust 中，声明大小是翻转的；要创建一个 8 x 16 二维数组，语法是：

// Declaration
let mut array_2d: [[i32; 16]; 8];
...
// Access (same as idiomatic C. types for added explicitness)
array_2d[0_usize][1_usize] = 5;
于 2018-02-15T17:23:38.933 回答
2

另一个二维字符串数组的例子：

fn main() {
    let width = 2;
    let height = 3;

    let mut a: Vec<Vec<String>> = vec![vec![String::from(""); width]; height];

    for i in 0..height {
        for j in 0..width {
            let s = format!("{}:{}", i + 1, j + 1);
            a[i][j] = s;
        }
    }
    println!("{:?}", a);
}

输出：

[
  ["1:1", "1:2"],
  ["2:1", "2:2"],
  ["3:1", "3:2"]
]

但我不确定为什么我们不能使用这种形式：a = [[String::from(""), 2], 3]. 我不明白 和 之间的vec![]区别[]。

于 2020-10-11T14:03:23.610 回答