Loops Rust：迭代iter（）或向量本身

我在看一个关于生锈的讲座，看到了我在向量上迭代的两种方法。我可以迭代“向量本身”或“iter（）方法”。你能告诉我这里有什么不同吗

fn call(from: &mut Vec<i32>, to: &mut Vec<i32>) {
    for e in from.iter() {
        to.push(*e);
    }
    for e in from {
        to.push(*e);
    }
}

fn printvec(from: & Vec<i32>) {
    for e in from {
        print!("{} ", e);
    }
    println!("");
}

fn main() {
    let mut v1 = vec![1,2,3];
    let mut v2 = vec![1,2,3];
    call(&mut v1, &mut v2);
    printvec(&v1);
    printvec(&v2);
}

fn调用（从：&mut-Vec，到：&mut-Vec）{
对于e，从.iter（）开始{
to.push（*e）；
}
对于e从{
to.push（*e）；
}
}
fn printvec（发件人：&Vec）{
对于e从{
打印！（“{}”，e）；
}
println！（“”）；
}
fn main（）{
设mut v1=vec！[1,2,3]；
设mut v2=vec！[1,2,3]；
调用（&mut v1和&mut v2）；
printvec&v1；
printvec&v2；
}

来自：

标签：用于iter\U expr中的图案{ /*环体*/ } 相当于

{
让结果=匹配到迭代器：：到iter（iter\u expr）{
mut iter=>'标签：循环{
让我们下一步；
匹配迭代器：：下一步（&mut iter）{
选项：：Some（val）=>next=val，
选项：：无=>中断，
};
让模式=下一个；
let（）={/*循环体*/}；
},
};
后果
}

for循环之间的区别在于，在一个for循环中，

iter\u expr

是

from

，而在另一个for循环中，它是

from.iter（）

<对于向量引用，code>IntoIterator是这样实现的：

impl；
fn到iter（self）->切片：：iter来自：

标签：用于iter\U expr中的图案{
/*环体*/
}

相当于

{
让结果=匹配到迭代器：：到iter（iter\u expr）{
mut iter=>'标签：循环{
让我们下一步；
匹配迭代器：：下一步（&mut iter）{
选项：：Some（val）=>next=val，
选项：：无=>中断，
};
让模式=下一个；
let（）={/*循环体*/}；
},
};
后果
}

for循环之间的区别在于，在一个for循环中，

iter\u expr

是

from

，而在另一个for循环中，它是

from.iter（）

<对于向量引用，code>IntoIterator是这样实现的：

impl；
fn到iter（self）->切片：：iter
你能告诉我这里有什么不同吗

fn call(from: &mut Vec<i32>, to: &mut Vec<i32>) {
    for e in from.iter() {
        to.push(*e);
    }
    for e in from {
        to.push(*e);
    }
}

fn printvec(from: & Vec<i32>) {
    for e in from {
        print!("{} ", e);
    }
    println!("");
}

fn main() {
    let mut v1 = vec![1,2,3];
    let mut v2 = vec![1,2,3];
    call(&mut v1, &mut v2);
    printvec(&v1);
    printvec(&v2);
}

正如斯塔加图尔所说，这里没有什么不同。要知道发生了什么，只需遵循白兔特性实现：Rust的
for
loop“simply”调用“RHS”。现在如果我们下去

我们可以看到
它本身并没有被记录，但是，在这里我们确实确认了Stargateur是正确的，
&Vec
和
Vec:：iter
做了完全相同的事情

文档有点简洁，但它链接到的是“不可变切片迭代器”，其本身不一定非常有用，但trait实现非常清楚

impl{
类型项=&'T
}

因此
Vec:：iter
->
iter
->
迭代器
，这意味着当你
.iter（）
一个向量（或者你迭代一个
&Vec
）时，你就迭代了对项目的不可变引用。由于
iter
采用
&self
（而
&Vec
显然是一个参考），这也意味着迭代只借用了向量，因此一旦完成迭代，向量仍然保持不变

&mut-Vec
和
Vec:：iter\u-mut
虽然你没有提到这是第二个迭代器，但它与上面的迭代器相似，只是它产生了一个

impl{
类型项=&'a mut T T
}

因此，它不产生对项的不可变引用，而是产生可变引用，这意味着您可以就地修改项，例如，增加它们，非常酷

所以我们来讨论一下，如果你扩展定义，你会看到：

用于Vec的impl into迭代器{
类型项=T
输入IntoIter=IntoIter
将fn发布到（自身）->IntoIter

创建一个消耗迭代器，即将每个值移出向量（从开始到结束）。调用此迭代器后无法使用向量

这是不言自明的：如果你直接迭代

Vec

，它会消耗向量，这意味着你以后将无法使用它

然而，作为回报，它将向量项的所有权转移到迭代器中，这提供了更大的灵活性

你能告诉我这里有什么不同吗

fn call(from: &mut Vec<i32>, to: &mut Vec<i32>) {
    for e in from.iter() {
        to.push(*e);
    }
    for e in from {
        to.push(*e);
    }
}

fn printvec(from: & Vec<i32>) {
    for e in from {
        print!("{} ", e);
    }
    println!("");
}

fn main() {
    let mut v1 = vec![1,2,3];
    let mut v2 = vec![1,2,3];
    call(&mut v1, &mut v2);
    printvec(&v1);
    printvec(&v2);
}

正如Stargateur所指出的，这里没有什么不同。要知道发生了什么，你只需要遵循白兔特质实现：Rust的

for

loop“simply”调用“RHS”。现在如果我们往下看

我们可以看到 它本身并没有被记录，但是，在这里我们确实确认了Stargateur是正确的，

&Vec

和

Vec:：iter

做了完全相同的事情

文档有点简洁，但它链接到的是“不可变切片迭代器”，其本身不一定非常有用，但trait实现非常清楚

impl{
类型项=&'T
}

因此

Vec:：iter

->

iter

->

迭代器

，这意味着当你

.iter（）

一个向量（或者你迭代一个

&Vec

）时，你会迭代对项目的不可变引用。既然

iter

采用

&self

（而且

&Vec

显然是一个引用）这也意味着迭代只借用了向量，所以一旦迭代完成，向量仍然保持不变

&mut-Vec

和

Vec:：iter\u-mut

虽然你没有提到这是第二个迭代器，但它与上面的迭代器相似，只是它产生了一个

impl{
类型项=&'a mut T T
}

因此，它不产生对项的不可变引用，而是产生可变引用，这意味着您可以就地修改项，例如，增加它们，非常酷

所以我们来讨论这个，如果你扩展定义，你会看到埃森