Rust 如何高效地将 struct 向量中的字段收集到单独的数组中

发布于12月13日

我设法使其工作(参见下面的示例)，但这需要数组的多次迭代.

有没有办法让向量只迭代一次？

struct Vx {
    pub a: f32,
    pub b: f32,
}

fn main() {
    let mut varr = Vec::new();
    varr.push(Vx { a: 0., b: 0. });
    varr.push(Vx { a: 1., b: 1. });
    varr.push(Vx { a: 2., b: 2. });

    let a: Vec<f32> = varr.iter().map(|v| v.a).collect();
    let b: Vec<f32> = varr.iter().map(|v| v.b).collect();

    println!("a: {:?}", a);
    println!("b: {:?}", b);
}

推荐答案

map+unzip只适用于两个字段，但对于任意数量的字段，您始终可以使用更通用的fold并解压缩成任何类型的 struct :

struct Vx {
    pub a: f32,
    pub b: f32,
    pub c: f32,
}

fn main() {
    let mut varr = Vec::new();
    varr.push(Vx {
        a: 0.,
        b: 0.,
        c: 1.,
    });
    varr.push(Vx {
        a: 1.,
        b: 1.,
        c: 2.,
    });
    varr.push(Vx {
        a: 2.,
        b: 2.,
        c: 3.,
    });

    let len = varr.len();
    let (a, b, c) = varr.iter().fold(
        (
            Vec::with_capacity(len),
            Vec::with_capacity(len),
            Vec::with_capacity(len),
        ),
        |(mut a, mut b, mut c), v| {
            a.push(v.a);
            b.push(v.b);
            c.push(v.c);
            (a, b, c)
        },
    );

    println!("a: {:?}", a); // a: [0.0, 1.0, 2.0]
    println!("b: {:?}", b); // b: [0.0, 1.0, 2.0]
    println!("c: {:?}", c); // c: [1.0, 2.0, 3.0]
}