Iterator 共享、借用Vec上的iter（）和into_iter（）之间的差异？

我正在阅读，作者以传递给函数的

Vec

对象为例讨论共享借用。下面是对本教程所教内容的稍加修改的MWE。有趣的部分是

vec\u min

中的

v.iter（）。作者写道：

这一次，我们显式地为向量
v
请求一个迭代器。方法
iter
借用它所处理的向量，并提供元素的共享借用

但是如果我使用
来。。。在…
中对共享的对象进行构造？根据，这个隐式for循环使用
进入iter（）
，获得
v
的所有权。但它不能真正拥有该函数中的
v
，因为它只是从一开始就借用了它，对吗

谁能给我解释一下
into_iter（）
和
iter（）
应用于借来的对象之间的区别吗

enum NumberOrNothing {
    Number(i32),
    Nothing,
}
use self::NumberOrNothing::{Number,Nothing};

impl NumberOrNothing {
    fn print(self) {
        match self {
            Nothing => println!("The number is: <nothing>"),
            Number(n) => println!("The number is: {}", n),
        };
    }
}

fn vec_min(v: &Vec<i32>) -> NumberOrNothing {
    fn min_i32(a: i32, b: i32) -> i32 {
        if a < b {a} else {b}
    }

    let mut min = Nothing;
    for e in v.iter() {
    //Alternatively implicitly and with *e replaced by e:
    //for e in v {
        min = Number(match min {
            Nothing => *e,
            Number(n) => min_i32(n, *e),
        });
    }
    min
}

pub fn main() {
    let vec = vec![18,5,7,2,9,27];
    let foo = Nothing;
    let min = vec_min(&vec);
    let min = vec_min(&vec);
    min.print();
}

enum NumberOrNothing{
编号（i32），
没有什么，
}
使用self:：numbernothing:：{Number，Nothing}；
无意义{
fn打印（自我）{
匹配自我{
Nothing=>println！（“数字为：”），
数字（n）=>println！（“数字为：{}”，n），
};
}
}
fn vec_min（v:&vec）->编号或无{
fn min_i32（a:i32，b:i32）->i32{
如果a*e，
数字（n）=>最小值i32（n，*e），
});
}
闵
}
pub fn main（）{
设vec=vec！[18,5,7,2,9,27]；
让foo=Nothing；
设min=vec_min（&vec）；
设min=vec_min（&vec）；
最小打印（）；
}

但它不能真正拥有该函数中的v，因为它只是从一开始就借用了它

它绝对可以拥有
v
，因为这是一个
&Vec
。注意这里的精确语义-您拥有的是引用，而不是引用的项

如果您查看，您可以找到：

impl<'a, T> IntoIterator for &'a Vec<T>

impl slice:：IterRight，这太棒了，非常感谢！我还对
into_iter（）感到困惑。
可以同时在
&Vec
和
Vec
上工作，但您参考的源代码解释了这一点：
Vec
以及
&a Vec
和
&a mut-Vec
都有一个实现程序。非常酷的东西！）
impl<'a, T> IntoIterator for &'a Vec<T> {
    fn into_iter(self) -> slice::Iter<'a, T> {
        self.iter()
    }
}