RawVec(RawVec)

我们实际上已经达到了一个有趣的情况:我们已经复制了用于指定缓冲区并在Vec和IntoIter中释放其内存的逻辑.现在我们已经实现了它并确定了 实际的(actual) 逻辑复制,现在是执行一些逻辑压缩的好时机.

我们将抽象出(ptr, cap)对并给它们分配,增长和释放的逻辑:

  1. struct RawVec<T> {
  2.     ptr: NonNull<T>,
  3.     cap: usize,
  4.     _marker: PhantomData<T>,
  5. }
  7. unsafe impl<T: Send> Send for RawVec<T> {}
  8. unsafe impl<T: Sync> Sync for RawVec<T> {}
  10. impl<T> RawVec<T> {
  11.     fn new() -> Self {
  12.         assert!(mem::size_of::<T>() != 0, "TODO: implement ZST support");
  13.         RawVec {
  14.             ptr: NonNull::dangling(),
  15.             cap: 0,
  16.             _marker: PhantomData,
  17.         }
  18.     }
  20.     fn grow(&mut self) {
  21.         let (new_cap, new_layout) = if self.cap == 0 {
  22.             (1, Layout::array::<T>(1).unwrap())
  23.         } else {
  24.             // This can't overflow because we ensure self.cap <= isize::MAX.
  25.             let new_cap = 2 * self.cap;
  26.             // Layout::array checks that the number of bytes is <= usize::MAX,
  27.             // but this is redundant since old_layout.size() <= isize::MAX,
  28.             // so the `unwrap` should never fail.
  29.             let new_layout = Layout::array::<T>(new_cap).unwrap();
  30.             (new_cap, new_layout)
  31.         };
  32.         // Ensure that the new allocation doesn't exceed `isize::MAX` bytes.
  33.         assert!(new_layout.size() <= isize::MAX as usize, "Allocation too large");
  34.         let new_ptr = if self.cap == 0 {
  35.             unsafe { alloc::alloc(new_layout) }
  36.         } else {
  37.             let old_layout = Layout::array::<T>(self.cap).unwrap();
  38.             let old_ptr = self.ptr.as_ptr() as *mut u8;
  39.             unsafe { alloc::realloc(old_ptr, old_layout, new_layout.size()) }
  40.         };
  41.         // If allocation fails, `new_ptr` will be null, in which case we abort.
  42.         self.ptr = match NonNull::new(new_ptr as *mut T) {
  43.             Some(p) => p,
  44.             None => alloc::handle_alloc_error(new_layout),
  45.         };
  46.         self.cap = new_cap;
  47.     }
  48. }
  51. impl<T> Drop for RawVec<T> {
  52.     fn drop(&mut self) {
  53.         if self.cap != 0 {
  54.             let layout = Layout::array::<T>(self.cap).unwrap();
  55.             unsafe {
  56.                 alloc::dealloc(self.ptr.as_ptr() as *mut u8, layout);
  57.             }
  58.         }
  59.     }
  60. }

并改变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 {
  8.         self.buf.ptr.as_ptr()
  9.     }
  11.     fn cap(&self) -> usize {
  12.         self.buf.cap
  13.     }
  14.     pub fn new() -> Self {
  15.         Vec {
  16.             buf: RawVec::new(),
  17.             len: 0,
  18.         }
  19.     }
  21.     // push/pop/insert/remove largely unchanged:
  22.     // * `self.ptr.as_ptr() -> self.ptr()`
  23.     // * `self.cap -> self.cap()`
  24.     // * `self.grow() -> self.buf.grow()`
  25. }
  27. impl<T> Drop for Vec<T> {
  28.     fn drop(&mut self) {
  29.         while let Some(_) = self.pop() {}
  30.         // deallocation is handled by RawVec
  31.     }
  32. }

最后我们可以真正简化IntoIter:

  1. pub struct IntoIter<T> {
  2.     _buf: RawVec<T>, // we don't actually care about this. Just need it to live.
  3.     start: *const T,
  4.     end: *const T,
  5. }
  7. // next and next_back literally unchanged since they never referred to the buf
  9. impl<T> Drop for IntoIter<T> {
  10.     fn drop(&mut self) {
  11.         // only need to ensure all our elements are read;
  12.         // buffer will clean itself up afterwards.
  13.         for _ in &mut *self {}
  14.     }
  15. }
  17. impl<T> Vec<T> {
  18.     pub fn into_iter(self) -> IntoIter<T> {
  19.         unsafe {
  20.             // need to use ptr::read to unsafely move the buf out since it's
  21.             // not Copy, and Vec implements Drop (so we can't destructure it).
  22.             let buf = ptr::read(&self.buf);
  23.             let len = self.len;
  24.             mem::forget(self);
  26.             IntoIter {
  27.                 start: buf.ptr.as_ptr(),
  28.                 end: buf.ptr..as_ptr().add(len),
  29.                 _buf: buf,
  30.             }
  31.         }
  32.     }
  33. }

好多了.