将向量解构为变量并放弃所有权？

Question

我有一个结构

struct Foo {
    foo1: String,
    foo2: String,
    foo3: String,
    foo4: String,
    // ...
}

我想从一个向量创建一个Foo 的实例。

let x = vec!["a".to_string(), "b".to_string(), "c".to_string(), "d".to_string()];
match x.as_slice() {
    &[ref a, ref b, ref c, ref d] => {
        let foo = Foo {
            foo1: a.to_string(),
            foo2: b.to_string(),
            foo3: c.to_string(),
            foo4: d.to_string(),
        };

    },
    _ => unreachable!(),
}

我必须复制字符串吗？有没有更好的方法将向量解构为a、b、c、d 以及转移所有权？

其实我不介意x在解构后被完全销毁。所以我希望除了切片之外的向量也有模式匹配。目前看来我们只能解构切片。

Answer 1

我必须复制字符串吗？

如果您愿意放弃解构，则不会。我是 itertools 的忠实粉丝：

use itertools::Itertools; // 0.8.2

fn main() {
    let x = vec![
        "a".to_string(),
        "b".to_string(),
        "c".to_string(),
        "d".to_string(),
    ];

    if let Some((foo1, foo2, foo3, foo4)) = x.into_iter().tuples().next() {
        let foo = Foo {
            foo1,
            foo2,
            foo3,
            foo4,
        };
    }
}

这会将向量（以及成员）的所有权转移给迭代器，然后tuples 适配器将值分块到一个元组中。我们取其中的第一个并构造值。

如果您不想放弃整个向量的所有权，也可以使用drain：

if let Some((foo1, foo2, foo3, foo4)) = x.drain(..4).tuples().next() {

有没有更好的方法将向量解构为a、b、c、d 以及转移所有权？

不，除了迭代器之外，没有任何机制可以在不创建另一个 Vec（或具有相同限制的其他类型）的情况下获取 Vec 的一部分的所有权。

Answer 2

解构切片并不稳定，你不能移出切片，因为它只是一个借用——如果你移出，Vec 的析构函数会做什么？

变异向量是这里的方法：

let mut x = vec!["a".to_string(), "b".to_string(), "c".to_string(), "d".to_string()];
let foo = Foo {
    foo4: x.pop().unwrap(),
    foo3: x.pop().unwrap(),
    foo2: x.pop().unwrap(),
    foo1: x.pop().unwrap(),
};

println!("{:?}", foo);

playground