使用向量的Vec::chunks()的替代方法

Question

我有以下函数，它接受一个向量作为参数，并返回它的元素对的向量：

fn to_pairs(flat: Vec<u64>) -> Vec<(u64, u64)> {
    assert!(flat.len() % 2 == 0);
    let mut pairs = Vec::new();
    pairs.reserve(flat.len() / 2);
    for pair in flat.chunks(2) {
        assert!(pair.len() == 2);
        pairs.push((pair.get(0).unwrap().clone(), pair.get(1).unwrap().clone()));
    }
    pairs
}

我想使用向量flat，这样在构造对时就不必克隆它的元素了。有没有可能在不重新实现Vec::chunks()变体的情况下做到这一点？

Answer 1

我想使用向量flat，这样在构造对的时候就不必克隆它的元素了。

将输入的Vec转换为迭代器，然后一次从迭代器中获取两样东西。从本质上讲，您希望实现与processing a Range (an iterator) in chunks相同的功能

fn to_pairs<T>(flat: Vec<T>) -> Vec<(T, T)> {
    let len = flat.len();

    assert!(len % 2 == 0);
    let mut pairs = Vec::with_capacity(len / 2);

    let mut input = flat.into_iter().peekable();

    while input.peek().is_some() {
        match (input.next(), input.next()) {
            (Some(a), Some(b)) => pairs.push((a, b)),
            _ => unreachable!("Cannot have an odd number of values"),
        }
    }

    pairs
}

fn main() {
    assert_eq!(vec![(1,2), (3,4)], to_pairs(vec![1,2,3,4]));
    assert_eq!(vec![(true,true), (false,false)], to_pairs(vec![true,true,false,false]));
}

assert!(len % 2 == 0);在这里非常重要，因为Iterator不能保证在之后next第一次返回None时会发生什么。因为我们在没有检查第一个值的情况下调用next两次，所以我们可能会触发这种情况。在其他情况下，您可能希望使用fuse。

作为pointed out by Kha，您可以稍微简化一下while循环：

let mut input = flat.into_iter();

while let (Some(a), Some(b)) = (input.next(), input.next()) {
    pairs.push((a, b));
}