Question

我有一个传递给函数的3x3矩阵（2D数组）：

Dim aCount = Aggregate cc In aList Where cc.Con = "A" Into Sum(cc.Len)

该功能目前已硬接线以接受3x3矩阵：

let matrix: [[i32; 3]; 3] = [
    [0, 0, 0],
    [0, 1, 0],
    [0, 0, 0]
];

filter::convolve(&mut image, matrix, 1).unwrap();

如何将3x3,5x5或任意大小的矩阵传递给同一个函数？

Answer 1

数组具有固定大小，在编译时确定。 Slices具有固定大小，在运行时确定。

最简单的方法是接受一片切片：

fn convolve(matrix: &[&[i32]]) {
    println!("{:?}", matrix);
}

fn main() {
    let matrix = &[
        &[0, 0, 0][..],
        &[0, 1, 0][..],
        &[0, 0, 0][..],
    ];
    convolve(matrix);
}

这有点烦人，因为你必须使用切片语法（&foo[..]）将文字数组转换为切片。您也可以接受一个泛型，它允许您接受上述内容，但也可以接受任何可以转换为切片的内容：

fn convolve<T, I>(matrix: &[T])
where
    T: AsRef<[I]>,
    I: std::fmt::Debug,
{
    for part in matrix {
        println!("{:?}", part.as_ref());
    }
}

fn main() {
    let matrix = &[
        [0, 0, 0],
        [0, 1, 0],
        [0, 0, 0],
    ];
    convolve(matrix);
}

作为kosinix points out，无法保证&[&[i32]]具有相等长度的行;它可能有一个参差不齐的数组。

对此的运行时解决方案是迭代所有行并确保所有长度都相同。如果为已经验证的矩阵创建 newtype ，这可以简化为仅检查一次：

struct Matrix<'a, T: 'a>(&'a [&'a [T]]);

impl<'a, T> Matrix<'a, T> {
    fn new(slice: &'a [&'a [T]]) -> Result<Self, ()> {
        if slice.is_empty() {
            return Ok(Matrix(slice));
        }

        let (head, tail) = slice.split_at(1);
        let expected = head[0].len();

        if tail.iter().map(|row| row.len()).all(|l| l == expected) {
            Ok(Matrix(slice))
        } else {
            Err(()) // return a real error here
        }
    }
}

现在，只要有Matrix，就可以确定行的长度都相同。

编译时解决方案......尚不存在。这些被称为const generics。 提议的语法将是

fn convolve<const N: usize>(matrix: [[i32; N]; N])

有稳定的解决方法（例如generic-array），但这些可能会以某种方式受到限制。

如何将任意大小的矩阵传递给Rust中的函数？

1 个答案: