小编luc*_*trv的帖子

我正在编写一个库，它采用一种Vec<Vec<T>>类型以列主顺序存储数据（每个内部Vec代表一列）。用户可以创建Vec<Vec<T>>具有任意行和列长度的行和列，但所有列都被限制为相同的长度。

有时我需要有效地逐行迭代Vec<Vec<T>>。我不想更改数组类型，因为大多数时候我需要“按列向量”迭代（一次一个完整的列向量）。

除非我错过了一些东西，否则Iterator::zip不是一个选择，因为我事先不知道列向量的数量。Itertools::izip并且Itertools::multizip也不可行。

这是我的示例代码：

let array = vec![vec![1, 2, 3], vec![4, 5, 6], vec![7, 8, 9]];
let mut iterators: Vec<_> = array.iter().map(|x| x.iter()).collect();
for _ in 0..array[0].len() {
    let values: Vec<_> = iterators.iter_mut().map(|x| x.next().unwrap()).collect();
    dbg!(values);
}

我应该values在开始迭代之前定义一个可变向量以避免每个周期的分配，还是编译器会处理这种优化？自己找到它的最简单方法是什么？

有更有效/惯用的解决方案吗？

这是我的代码的简化示例：

#[derive(Debug, Clone, Copy)]
enum Data<'a> {
    I32(&'a [i32]),
    F64(&'a [f64]),
}

impl<'a> From<&'a [i32]> for Data<'a> {
    fn from(v: &'a [i32]) -> Data<'a> {
        Data::I32(v)
    }
}

impl<'a> From<&'a [f64]> for Data<'a> {
    fn from(v: &'a [f64]) -> Data<'a> {
        Data::F64(v)
    }
}

#[derive(Debug, Clone, Copy)]
struct DataVar<'a> {
    name: &'a str,
    data: Data<'a>,
}

impl<'a> DataVar<'a> {
    fn new<T>(name: &'a str, data: T) -> Self
    where
        T: Into<Data<'a>>,
    {
        Self {
            name,
            data: data.into(),
        }
    }
}

首先，考虑到我需要将不同的 …