Why is iterating over a collection via `for` loop considered a “move” in Rust?

问题

I have the below Rust program.

fn main() {
    let v = vec![100, 32, 57];
    for i in v {
        println!("{}", i);
    }

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

When I run it, I get:

error[E0382]: borrow of moved value: `v`
 --> src\main.rs:7:22
  |
2 |     let v = vec![100, 32, 57];
  |         - move occurs because `v` has type `std::vec::Vec<i32>`, which does not implement the `Copy` trait
3 |     for i in v {
  |              -
  |              |
  |              value moved here
  |              help: consider borrowing to avoid moving into the for loop: `&v`
...
7 |     println!("{:?}", v);
  |                      ^ value borrowed here after move

The error states that there is a move happened at for i in v. But I'm just using the same variable v defined by let v = vec![100, 32, 57]. It's not something like let v2 = v; for i in v2 ..., which moved the value from v to v2. Could anyone help to explain a little bit?

回答1:

As https://doc.rust-lang.org/reference/expressions/loop-expr.html#iterator-loops says,

A for expression is a syntactic construct for looping over elements provided by an implementation of std::iter::IntoIterator.

Vec implements IntoIterator, allowing you to own a Vec instance’s elements by consuming it:

Creates a consuming iterator, that is, one that moves each value out of the vector (from start to end). The vector cannot be used after calling this.

(As the error message notes, the way to fix this is to loop over &v instead of v, borrowing its elements instead of owning them. You can loop for &i in &v to maintain the type of i.)

It might seem unnecessary at a high level for you to own the elements of v, since they’re copyable, but there’s no special implementation allowing for that. IntoIterator.into_iter() takes self, meaning a for loop always consumes the value being iterated over.

来源：https://stackoverflow.com/questions/59123462/why-is-iterating-over-a-collection-via-for-loop-considered-a-move-in-rust

标签

rust

move

borrowing