Rust 借来的时候临时价值下降了，但我不'；I don’我不想做出租汽车

我在做这样的事情：

fn main() {
    //[1, 0, 0, 0, 99]; // return [2, 0, 0, 0, 99]
    //[2, 3, 0, 3, 99]; // return [2,3,0,6,99]
    //[2, 4, 4, 5, 99, 0]; // return [2,4,4,5,99,9801]
    //[1, 1, 1, 4, 99, 5, 6, 0, 99]; // return [30,1,1,4,2,5,6,0,99]

    let map: Vec<(&mut [usize], &[usize])> = vec![(&mut [1, 0, 0, 0, 99], &[2, 0, 0, 0, 99])];

    for (x, y) in map {
        execute_program(x);
        assert_eq!(x, y);
    }
}

pub fn execute_program(vec: &mut [usize]) {
    //do something inside vec
}

fn main（）{
//[1,0,0,0,99]；//返回[2,0,0,0,99]
//[2,3,0,3,99]；//返回[2,3,0,6,99]
//[2,4,4,5,99,0]；//返回[2,4,4,5,999801]
//[1,1,1,4,99,5,6,0,99]；//返回[30,1,1,4,2,5,6,0,99]
让map:Vec=Vec！[（&mut[1,0,0,99]，&[2,0,0,0,99]）；
对于地图中的（x，y）{
执行_程序（x）；
断言（x，y）；
}
}
发布fn执行程序（vec:&mut[usize]）{
//在vec内部做点什么
}

问题是我没有在元组中的第一个元素上使用let，我想借用它来执行_程序：

错误[E0716]：借用时丢弃的临时值
-->src/main.rs:2:57
|
2 |让map:Vec=Vec！[（&mut[1,0,0,99]，&[2,0,0,0,99]）；
|^^^^^^^^^^^^^^^^^^-此语句末尾将释放临时值
|                                                         |
|创建在仍在使用时释放的临时文件
3 | 
图中（x，y）的4 |{
|---借来以后用在这里
|
=注意：考虑使用一个“让”绑定来创建一个较长的生命值

但我所做的是重构，因为我不想对我想测试的每个片段都执行

let

let

真的需要吗？

好吧，有些东西必须拥有这些数组中的每一个，因为引用不能拥有任何东西。数组大小不同，所以所有者必须是指针。最常见的数组，如拥有指针是

Vec

：

let map: Vec<(Vec<usize>, &[usize])> = vec![
    (vec![1, 0, 0, 0, 99], &[2, 0, 0, 0, 99]),
    (vec![2, 3, 0, 3, 99], &[2, 3, 0, 6, 99]),
    (vec![2, 4, 4, 5, 99, 0], &[2, 4, 4, 5, 99, 9801]),
    (vec![1, 1, 1, 4, 99, 5, 6, 0, 99], &[30, 1, 1, 4, 2, 5, 6, 0, 99]),
];

for (mut x, y) in map {
    execute_program(&mut x);
    assert_eq!(x, y);
}

let map:Vec=Vec[
（vec！[1,0,0,99]，&[2,0,0,0,99]），
（vec！[2,3,0,3,99]，&[2,3,0,6,99]），
（vec！[2,4,4,5,99,0]，&[2,4,4,5,999801]），
（向量！[1,1,1,4,99,5,6,0,99]，&[30,1,1,4,2,5,6,0,99]），
];
对于地图中的（mut x，y）{
执行_程序（&mut x）；
断言（x，y）；
}

因此，数组归

map

所有，并在必要时借用，正如loganfsmyth在问题注释中所建议的那样

您可能会担心进行不必要分配的性能成本。这是使用单个

let

的成本；因为数组的大小不尽相同，如果希望它们在堆栈上，实际上没有办法用不同的

let

来声明它们。但是，您可以编写一个宏来删除boile拉特

等等，为什么它适用于

y

？

---

你可能想知道为什么我把

x

变成了一个向量，而把

y

保持原样。答案是因为

y

是一个共享引用，所以这些数组都要服从，所以

&[2,0,0,0,99]

实际上是

&'static[usize；5]

类型，可以强制为

&'static[usize]

&mut

引用不会触发静态升级，因为在没有某种同步的情况下改变静态值是不安全的。

为什么要在那里而不是以后借用？