vector - 为什么迭代 i32 的向量会引用 i32 (&i32)？

Question

以下程序尝试对学生的分数进行评分:

use std::io;

fn main() {
    let mut in0 = String::new();
    io::stdin().read_line(&mut in0).expect("stdin err");
    let n: i32 = in0.trim().parse().expect("parse err");
    println!("{}", n);
    let mut v: Vec<i32> = Vec::new();
    for _ in 0..n {
        let mut inp = String::new();
        io::stdin().read_line(&mut inp).expect("stdin err");
        let num: i32 = inp.trim().parse().unwrap();
        v.push(num);
    }
    let out: Vec<_> = v
        .iter()
        .map(|x| {
            if x < 38 {
                x
            } else if x % 5 > 3 {
                x + x % 5
            } else {
                x
            }
        })
        .collect();
    println!("{:?}", v);
}

编译时出现如下错误。

error[E0308]: mismatched types
  --> src/main.rs:19:20
   |
19 |             if x < 38 {
   |                    ^^
   |                    |
   |                    expected `&i32`, found integer
   |                    help: consider borrowing here: `&38`

error[E0308]: `if` and `else` have incompatible types
  --> src/main.rs:24:17
   |
21 |               } else if x % 5 > 3 {
   |  ____________________-
22 | |                 x + x % 5
   | |                 --------- expected because of this
23 | |             } else {
24 | |                 x
   | |                 ^ expected `i32`, found `&i32`
25 | |             }
   | |_____________- `if` and `else` have incompatible types
   |
help: consider dereferencing the borrow
   |
23 |             } else *{
24 |                 x
25 |             }

x 变量如何是 &i32 类型而不是 i32 类型？

Answer 1

调用 .iter()向量上的方法返回引用向量元素的迭代器。否则，它必须将元素移动或复制出向量，这在一般情况下是不可取的 ^[1]。在文档中，这在声明中不是很明显:

pub fn iter(&self) -> Iter<T>  // Return type does not look like a reference

但是，示例显示您获得了引用:

assert_eq!(iterator.next(), Some(&1));  // note the `&1` instead of just `1`

可以指示闭包取消引用参数:

v.iter().map(|&x| { /* do something */ })

如果向量包含 Copyable 类型，如 i32，这很好。否则这将导致无法移出借用的内容错误。在这种情况下，您可能还是希望使用引用。

如果您在迭代后不再需要向量，您可以使用 .into_iter()，它使用向量并迭代拥有的项目而不是引用。

_{[1] 移动会清除 .drain() 覆盖的矢量方法，并且复制不可能在所有类型上都有效。}