rust - 我应该为二维数组使用什么类型？

Question

这里a的类型有什么问题？

fn foo(a: &[&[f64]], x: &[f64]) {
    for i in 0..3 {
        for j in 0..4 {
            println!("{}", a[i][j]);
        }
    }
}

fn main() {
    let A: [[f64; 4]; 3] = [
        [1.1, -0.2, 0.1, 1.6],
        [0.1, -1.2, -0.2, 2.3],
        [0.2, -0.1, 1.1, 1.5],
    ];
    let mut X: [f64; 3] = [0.0; 3];

    foo(&A, &X);
}

编译失败:

error[E0308]: mismatched types
  --> src/main.rs:17:9
   |
17 |     foo(&A, &X);
   |         ^^ expected slice, found array of 3 elements
   |
   = note: expected type `&[&[f64]]`
              found type `&[[f64; 4]; 3]`

Answer 1

数组 是不同于切片 的类型。值得注意的是，数组具有固定大小，在编译时已知。切片具有固定大小，但仅在运行时已知。

我在这里看到两个直接的选择(参见 Levans answer for another )。第一个是将您的函数更改为仅接受对数组的引用(或整个数组，如果您可以复制它或不介意放弃所有权):

fn foo(a: &[[f64; 4]; 3], x: &[f64; 3]) {
    for i in 0..3 {
        for j in 0..4 {
            println!("{}", a[i][j]);
        }
    }
}

fn main() {
    let a = [
        [1.1, -0.2, 0.1, 1.6],
        [0.1, -1.2, -0.2, 2.3],
        [0.2, -0.1, 1.1, 1.5],
    ];

    let x = [0.0; 3];

    foo(&a, &x);
}

另一个简单的改变是将你的声明变成引用:

fn foo(a: &[&[f64]], x: &[f64]) {
    for i in 0..3 {
        for j in 0..4 {
            println!("{}", a[i][j]);
        }
    }
}

fn main() {
    let a = [
        &[1.1, -0.2, 0.1, 1.6][..],
        &[0.1, -1.2, -0.2, 2.3][..],
        &[0.2, -0.1, 1.1, 1.5][..],
    ];

    let x = [0.0; 3];

    foo(&a, &x);
}

请注意，在第二个示例中，当我们只传入 &a 和 &x 时，我们可以使用对数组的引用的隐式强制转换为切片。但是，对于 a 中的嵌套数据，我们不能依赖它。 a 已经被定义为数组的数组，我们不能改变元素类型。

还有一个警告 - 你真的应该在你的范围内使用切片的长度方法，否则你很容易 panic !如果你走到尽头。

fn foo(a: &[&[f64]], x: &[f64]) {
    for i in 0..a.len() {
        let z = &a[i];
        for j in 0..z.len() {
            println!("{}", z[j]);
        }
    }
}

我为满足 Rust 风格所做的其他风格更改:

1. 变量是snake_case
2. 后的空格:
3. 后面的空格；
4. 周围的空间=
5. 后面的空格，