借来的时候临时价值下降了，但我不想做 let

Question

我正在做这样的事情：

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
}

Here the playground

问题是我没有在元组的第一个元素上使用 let，我想借给 execute_program:

error[E0716]: temporary value dropped while borrowed
 --> src/main.rs:2:57
  |
2 |     let map: Vec<(&mut [usize], &[usize])> = vec![(&mut [1, 0, 0, 0, 99], &[2, 0, 0, 0, 99])];
  |                                                         ^^^^^^^^^^^^^^^^                     - temporary value is freed at the end of this statement
  |                                                         |
  |                                                         creates a temporary which is freed while still in use
3 | 
4 |     for (x, y) in map {
  |                   --- borrow later used here
  |
  = note: consider using a `let` binding to create a longer lived value

但我所做的正是重构，因为我不想对每个要测试的切片都进行 let！

真的需要let吗？

Answer 1

好吧，一些东西必须拥有这些数组中的每一个，因为引用不能拥有东西。并且数组大小不同，所以所有者必须是指针。最常见的类数组拥有指针是 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);
}

因此，数组由 map 拥有，并在必要时借用，正如 loganfsmyth 在问题评论中所建议的那样。

您可能担心进行不必要分配的性能成本。这是使用单个let的成本；由于数组的大小不尽相同，如果您希望将它们放在堆栈上，则确实没有办法用不同的 let 声明它们。但是，您可以编写一个删除样板文件的宏。

等等，为什么它对 `y` 有效？

你可能想知道为什么我把 x 变成了一个矢量，而 y 却保持原样。答案是因为 y 是一个共享引用，这些数组受制于，所以 &[2, 0, 0, 0, 99] 实际上是 &'static [usize; 5] 类型，可以强制转换为 [=21] =]. &mut 引用不会触发静态提升，因为在没有某种同步的情况下改变静态值是不安全的。

借来的时候临时价值下降了，但我不想做 let

Temporary value dropped while borrowed, but I don't want to do a let

rust

borrowing

等等，为什么它对 `y` 有效？

借来的时候临时价值下降了，但我不想做 let

Temporary value dropped while borrowed, but I don't want to do a let

rust

borrowing

等等，为什么它对 y 有效？

等等，为什么它对 `y` 有效？