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

RawVec

我们遇到了一个很有意思的情况：我们把初始化缓存和释放内存的逻辑在Vec和IntoIter里面一模一样地写了两次。现在我们已经实现了功能，而且发现了逻辑的重复，是时候对代码做一些压缩了。

我们要抽象出(ptr, cap)，并赋予它们分配、扩容和释放的逻辑：

  1. struct RawVec<T> {
  2.     ptr: Unique<T>,
  3.     cap: usize,
  4. }
  6. impl<T> RawVec<T> {
  7.     fn new() -> Self {
  8.         assert!(mem::size_of::<T>() != 0, "TODO:实现零尺寸类型的支持");
  9.         RawVec { ptr: Unique::empty(), cap: 0 }
  10.     }
  12.     // 与Vec一样
  13.     fn grow(&mut self) {
  14.         unsafe {
  15.             let align = mem::align_of::<T>();
  16.             let elem_size = mem::size_of::<T>();
  18.             let (new_cap, ptr) = if self.cap == 0 {
  19.                 let ptr = heap::allocate(elem_size, align);
  20.                 (1, ptr)
  21.             } else {
  22.                 let new_cap = 2 * self.cap;
  23.                 let ptr = heap::reallocate(self.ptr.as_ptr() as *mut _,
  24.                                             self.cap * elem_size,
  25.                                             new_cap * elem_size,
  26.                                             align);
  27.                 (new_cap, ptr)
  28.             };
  30.             // 如果分配或再分配失败，我们会得到null
  31.             if ptr.is_null() { oom() }
  33.             self.ptr = Unique::new(ptr as *mut _);
  34.             self.cap = new_cap;
  35.         }
  36.     }
  37. }
  40. impl<T> Drop for RawVec<T> {
  41.     fn drop(&mut self) {
  42.         if self.cap != 0 {
  43.             let align = mem::align_of::<T>();
  44.             let elem_size = mem::size_of::<T>();
  45.             let num_bytes = elem_size * self.cap;
  46.             unsafe {
  47.                 heap::deallocate(self.ptr.as_mut() as *mut _, num_bytes, align);
  48.             }
  49.         }
  50.     }
  51. }

然后像下面这样改写Vec：

  1. pub struct Vec<T> {
  2.     buf: RawVec<T>,
  3.     len: usize,
  4. }
  6. impl<T> Vec<T> {
  7.     fn ptr(&self) -> *mut T { self.buf.ptr.as_ptr() }
  9.     fn cap(&self) -> usize { self.buf.cap }
  11.     pub fn new() -> Self {
  12.         Vec { buf: RawVec::new(), len: 0 }
  13.     }
  15.     // push/pop/insert/remove基本没变，只改变了:
  16.     // self.ptr -> self.ptr()
  17.     // self.cap -> self.cap()
  18.     // self.grow -> self.buf.grow()
  19. }
  21. impl<T> Drop for Vec<T> {
  22.     fn drop(&mut self) {
  23.         while let Some(_) = self.pop() {}
  24.         // 释放空间由RawVec负责
  25.     }
  26. }

最后我们可以简化IntoIter：

  1. struct IntoIter<T> {
  2.     _buf: RawVec<T>, // 我们并不关心这个，只是需要它们保持分配空间不被销毁
  3.     start: *const T,
  4.     end: *const T,
  5. }
  7. // next和next_back保持不变，因为它们并没有用到buf
  9. impl<T> Drop for IntoIter<T> {
  10.     fn drop(&mut self) {
  11.         // 只需要保证所有的元素都被读到了
  12.         // 缓存会在随后自己清理自己
  13.         for _ in &mut *self {}
  14.     }
  15. }
  17. impl<T> Vec<T> {
  18.     pub fn into_iter(self) -> IntoIter<T> {
  19.         unsafe {
  20.             // 需要使用ptr::read非安全地把buf移出，因为它不是Copy，
  21.             // 而且Vec实现了Drop（所以我们不能销毁它）
  22.             let buf = ptr::read(&self.buf);
  23.             let len = self.len;
  24.             mem::forget(self);
  26.             IntoIter {
  27.                 start: *buf.ptr,
  28.                 end: buf.ptr.offset(len as isize),
  29.                 _buf: buf,
  30.             }
  31.         }
  32.     }
  33. }

现在看起来好多了。