原文链接：https://doc.rust-lang.org/nomicon/vec-drain.html

Drain

我们接着看看Drain。Drain和IntoIter基本相同，只不过它并不获取Vec的值，而是借用Vec并且不改变它的分配空间。现在我们只是先最“基本”的全范围(full-range)的版本。

  1. use std::marker::PhantomData;
  3. struct Drain<'a, T: 'a> {
  4.     // 这里需要限制生命周期。我们使用&'a mut Vec<T>，因为这就是语义上我们包含的东西。
  5.     // 我们只调用pop()和remove(0)
  6.     vec: PhantomData<&'a mut Vec<T>>,
  7.     start: *const T,
  8.     end: *const T,
  9. }
  11. impl<'a, T> Iterator for Drain<'a, T> {
  12.     type Item = T;
  13.     fn next(&mut self) -> Option<T> {
  14.         if self.start == self.end {
  15.             None

——等一下，这个看着有点眼熟。我们需要做进一步的压缩。IntoIter和Drain有着完全一样的结构，我们把它提取出来。

  1. struct RawValIter<T> {
  2.     start: *const T,
  3.     end: *const T,
  4. }
  6. impl<T> RawValIter<T> {
  7.     // 构建它是非安全的，因为它没有关联的生命周期。
  8.     unsafe fn new(slice: &[T]) -> Self {
  9.         RawValIter {
  10.             start: slice.as_ptr(),
  11.             end: if slice.len() == 0 {
  12.                 // 如果len == 0，说明没有真的分配内存。这时需要避免offset，
  13.                 // 因为那会给LLVM的GEP提供错误的信息
  14.                 slice.as_ptr()
  15.             } else {
  16.                 slice.as_ptr().offset(slice.len() as isize)
  17.             }
  18.         }
  19.     }
  20. }
  22. // Iterator和DoubleEndedIterator的实现与IntoIter完全一样。

IntoIter变成了这样：

  1. pub struct IntoIter<T> {
  2.     _buf: RawVec<T>, // 我们并不关心这个，只是需要它们保持分配空间不被销毁
  3.     iter: RawValIter<T>,
  4. }
  6. impl<T> Iterator for IntoIter<T> {
  7.     type Item = T;
  8.     fn next(&mut self) -> Option<T> { self.iter.next() }
  9.     fn size_hint(&self) -> (usize, Option<usize>) { self.iter.size_hint() }
  10. }
  12. impl<T> DoubleEndedIterator for IntoIter<T> {
  13.     fn next_back(&mut self) -> Option<T> { self.iter.next_back() }
  14. }
  16. impl<T> Drop for IntoIter<T> {
  17.     fn drop(&mut self) {
  18.         for _ in &mut self.iter {}
  19.     }
  20. }
  22. impl<T> Vec<T> {
  23.     pub fn into_iter(self) -> IntoIter<T> {
  24.         unsafe {
  25.             let iter = RawValIter::new(&self);
  27.             let buf = ptr::read(&self.buf);
  28.             mem::forget(self);
  30.             IntoIter {
  31.                 iter: iter,
  32.                 _buf: buf,
  33.             }
  34.         }
  35.     }
  36. }

注意，我在设计中留下了一些小后门，以便更简单地将Drain升级为可访问任意子范围的版本。特别是，我们可以在drop中让RawValIter遍历它自己。但是这种设计不适用于更复杂的Drain。我们还使用一个slice简化Drain的初始化。

好了，现在Drain变得很简单：

  1. use std::marker::PhantomData;
  3. pub struct Drain<'a, T: 'a> {
  4.     vec: PhantomData<&'a mut Vec<T>>,
  5.     iter: RawValIter<T>,
  6. }
  8. impl<'a, T> Iterator for Drain<'a, T> {
  9.     type Item = T;
  10.     fn next(&mut self) -> Option<T> { self.iter.next() }
  11.     fn size_hint(&self) -> (usize, Option<usize>) { self.iter.size_hint() }
  12. }
  14. impl<'a, T> DoubleEndedIterator for Drain<'a, T> {
  15.     fn next_back(&mut self) -> Option<T> { self.iter.next_back() }
  16. }
  18. impl<'a, T> Drop for Drain<'a, T> {
  19.     fn drop(&mut self) {
  20.         for _ in &mut self.iter {}
  21.     }
  22. }
  24. impl<T> Vec<T> {
  25.     pub fn drain(&mut self) -> Drain<T> {
  26.         unsafe {
  27.             let iter = RawValIter::new(&self);
  29.             // 这一步是为了mem::forget的安全。如果Drain被forget，我们会泄露整个Vec的内容
  30.             // 同时，既然我们无论如何都会做这一步，为什么不现在做呢？
  31.             self.len = 0;
  33.             Drain {
  34.                 iter: iter,
  35.                 vec: PhantomData,
  36.             }
  37.         }
  38.     }
  39. }

关于更多的mem::forget的问题，请见关于泄露的章节。