是否可以在不进行额外分配的情况下移动和修改向量？

考虑以下代码：

let u: Vec<u8> = (64..74).collect();
let v: Vec<u8> = u.iter().map(|i| i + 1).collect();

u没有被移动，因此v不可避免地被重新分配。

但如果我执行以下操作：

let w: Vec<u8> = u.into_iter().map(|i| i + 1).collect();

u被感动了并且w是其转换的名称。这是一些代表我的意思的伪代码：

mark u as "moved"
for i = 0..10:
    u[i] += 1
w = u

（在我看来）不需要新的分配，因为我们将类型映射到自身。对于此代码，情况并非如此：

let t: Vec<u8> = (64..74).collect();
let s: String = t.into_iter().map(|i| i as char).collect();

总结我的问题

有没有新的分配Vec当我们转换一个Vec到一个迭代器中，然后将该迭代器映射到另一个迭代器在相同类型的元素上然后将结果收集到Vec?

如果确实有分配，为什么？

我尝试过了--emit=mir，但我无法找到答案。我每晚都使用 rustc 1.20（如果这很重要的话）。

如果您想玩代码：在线尝试！ https://tio.run/##jZDNCsIwEITvPsXaU4oa/4qW@HfyCQQvIhpq1ECaSLKpB/XZa06iWLF73dn5ZtZ6h2V51JBzqUkMtwaEUQLBs7XIpj6dwwzIKKF0nMQ0M0qJDEk8eemKN52nEoUlMc35hdzlXbb6XzcXKzUq3STRjS0eURv8r0XxRrl@UjSa3X9Ut1tJg2mnA8JaYzfL3jAdbBl4J8AcITeFOEDBlRcM9n5fnesa7F/BsOabHFthMDoFGVbmB@4gO3NbqwXWb4E/Wrhg/yjLJw

让我们来看看来源 https://doc.rust-lang.org/stable/src/collections/vec.rs.html#1715-1734的实施情况into_iter() for Vec<T>:

fn into_iter(mut self) -> IntoIter<T> {
    unsafe {
        let begin = self.as_mut_ptr();
        assume(!begin.is_null());
        let end = if mem::size_of::<T>() == 0 {
            arith_offset(begin as *const i8, self.len() as isize) as *const T
        } else {
            begin.offset(self.len() as isize) as *const T
        };
        let cap = self.buf.cap();
        mem::forget(self);
        IntoIter {
            buf: Shared::new(begin),
            cap: cap,
            ptr: begin,
            end: end,
        }
    }
}

创建IntoIter迭代器会产生多次额外的分配，但不会针对向量的元素进行分配；相反，向量的底层内存详细信息被注册。怎么样the code https://doc.rust-lang.org/stable/src/core/iter/iterator.rs.html#479-483 behind map()?

fn map<B, F>(self, f: F) -> Map<Self, F> where
    Self: Sized, F: FnMut(Self::Item) -> B,
{
    Map{iter: self, f: f}
}

这里也没有分配额外的向量。最后一块拼图是collect() https://doc.rust-lang.org/stable/src/core/iter/iterator.rs.html#1255-1257:

fn collect<B: FromIterator<Self::Item>>(self) -> B where Self: Sized {
    FromIterator::from_iter(self)
}

这里没有答案；关于什么实施 https://doc.rust-lang.org/stable/src/collections/vec.rs.html#1689-1694 of from_iter() for Vec<T>?

impl<T> FromIterator<T> for Vec<T> {
    #[inline]
    fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Vec<T> {
        <Self as SpecExtend<T, I::IntoIter>>::from_iter(iter.into_iter())
    }
}

这开始看起来像魔法，但也许相关规范扩展代码 https://doc.rust-lang.org/stable/src/collections/vec.rs.html?search=#1773-1798将揭示我们正在寻找的内容：

impl<T, I> SpecExtend<T, I> for Vec<T>
    where I: Iterator<Item=T>,
{
    default fn from_iter(mut iterator: I) -> Self {
        // Unroll the first iteration, as the vector is going to be
        // expanded on this iteration in every case when the iterable is not
        // empty, but the loop in extend_desugared() is not going to see the
        // vector being full in the few subsequent loop iterations.
        // So we get better branch prediction.
        let mut vector = match iterator.next() {
            None => return Vec::new(),
            Some(element) => {
                let (lower, _) = iterator.size_hint();
                let mut vector = Vec::with_capacity(lower.saturating_add(1));
                unsafe {
                    ptr::write(vector.get_unchecked_mut(0), element);
                    vector.set_len(1);
                }
                vector
            }
        };
        <Vec<T> as SpecExtend<T, I>>::spec_extend(&mut vector, iterator);
        vector
    }

    default fn spec_extend(&mut self, iter: I) {
        self.extend_desugared(iter)
    }
}

在这段代码中我们终于可以看到Vec::new and Vec::with_capacity调用的方法为结果向量分配新的空间。

TL;DR: 不，不能移动and修改向量而不需要额外的分配。