为什么在向量上有两种迭代方式，IntoIterator和Iter？

我举了一个例子：

struct Foo { data: Vec<u32> }
impl Foo {
    fn get_list(&self) -> &Vec<u32> {
        &self.data
    }
}

fn main() {
    let foo = Foo { data: vec![1, 2, 3] };

    // 1
    for it in foo.get_list() {
        println!("IntoIter {}", *it);
    }

    // 2
    for it in foo.get_list().iter() {
        println!("Iter {}", *it);
    }
}

struct Foo{data:Vec}
impl-Foo{
fn获取列表（&self）->&Vec{
&自我数据
}
}
fn main（）{
设foo=foo{data:vec！[1,2,3]}；
// 1
对于foo.get_list（）中的它{
println！（“IntoIter{}，*it）；
}
// 2
对于foo.get_list（）.iter（）中的它{
println！（“Iter{}，*it）；
}
}

据我所知，在（1）

&Vec

转换为

到迭代器的情况下，
在案例（2）中，我们只使用
Iter

这些情况在潜在性能方面是否相同（编译器在优化模式下可以做什么）

如果情况相同，为什么要引入迭代器？只是为了避免写
.iter（）

在这种情况下，它们是等价的，因为
get\u list
返回一个引用，所以
IntoIterator
和
iter
都引用向量并返回对项的引用

如果向量是拥有的，它将被移动到迭代器中（因此命名），并从向量返回拥有的项<另一方面，代码>iter

总是获取引用并返回对项目的引用

---

另请参见。

在本例中，它们是等效的，因为

get\u list

返回一个引用，因此

IntoIterator

和

iter

都引用向量并返回对项的引用

如果向量是拥有的，它将被移动到迭代器中（因此命名），并从向量返回拥有的项<另一方面，代码>iter总是获取引用并返回对项目的引用

另请参见。

1）就潜在性能而言，情况是否相同（编译器在优化模式下可以做什么）？=>不，它不是，它使用引用

2） 如果情况相同，为什么引入IntoIterator，只是为了不写.iter（）？=>它引用了self.data，而vector不是迭代器。

1）在潜在性能方面（编译器在优化模式下可以做什么）是相同的情况吗？=>不，它不是，它使用引用

2） 如果情况相同，为什么引入IntoIterator，只是为了不写.iter（）？=>它引用self.data，vector不是迭代器