034 Rust死灵书之为Vec实现Drain

介绍

本系列录制的视频主要放在B站上Rust死灵书学习视频

Rust 死灵书相关的源码资料在https://github.com/anonymousGiga/Rustonomicon-Source

详细内容

drain 是一个集合 API，它将容器内的数据所有权移出，却不占有容器本身。我们可以声明一个 Vec 所有内容的所有权，然后复用分配给它的空间。它产生一个迭代器（Drain），以返回 Vec 的所有值。

代码如下：

#![feature(ptr_internals)]
use std::mem;
use std::alloc::{alloc, realloc, dealloc, Layout, handle_alloc_error};
use std::ptr::{Unique, self};
use std::ops::{Deref, DerefMut};
use std::slice;

#[derive(Debug)]
struct RawVec<T> {
    ptr: Unique<T>,
    cap: usize,
}

impl<T> RawVec<T> {
    fn new() -> Self {
        assert!(mem::size_of::<T>() != 0, "还没准备好处理零尺寸类型");
        RawVec { ptr: Unique::dangling(), cap: 0 }
    }

	fn grow(&mut self) {
	    unsafe {
	        let align = mem::align_of::<T>();
	        let elem_size = mem::size_of::<T>();
			let layout: Layout;
	
	        let (new_cap, ptr) = if self.cap == 0 {
				layout = Layout::from_size_align_unchecked(elem_size, align);
        		let ptr = alloc(layout);
	            (1, ptr)
	        } else {
	            let new_cap = self.cap * 2;
	            let old_num_bytes = self.cap * elem_size;

	            assert!(old_num_bytes <= (isize::MAX as usize) / 2,
	                    "capacity overflow");
	
	            let new_num_bytes = old_num_bytes * 2;
				layout = Layout::from_size_align_unchecked(new_num_bytes, align);
	            let ptr = realloc(self.ptr.as_ptr() as *mut _,
	                              	layout,
	                                new_num_bytes);
	            (new_cap, ptr)
	        };
	
	        if ptr.is_null() { handle_alloc_error(layout); }
	
			if let Some(ptr) = Unique::new(ptr as *mut _) {
	        	self.ptr = ptr;
			} else {
				panic!("error!");
			}
	        self.cap = new_cap;
	    }
	}
}

impl<T> Drop for RawVec<T> {
	fn drop(&mut self) {
		if self.cap != 0 {
			let align = mem::align_of::<T>();
			let elem_size = mem::size_of::<T>();
			let num_bytes = elem_size * self.cap;
			
			unsafe {
				let layout: Layout = Layout::from_size_align_unchecked(num_bytes, align);
				dealloc(self.ptr.as_ptr() as *mut _, layout)
			}

			println!("release memory in drop function!");
		}
	}
}

struct IntoIter<T> {
 	_buf: RawVec<T>, 
	iter: RawValIter<T>,
}

impl<T> Drop for IntoIter<T> {
	fn drop(&mut self) {
		for _ in &mut *self {}
	}
}

#[derive(Debug)]
pub struct MyVec<T> {
	buf: RawVec<T>,
    len: usize,
}

impl<T> MyVec<T> {
	fn ptr(&self) -> *mut T { 
		self.buf.ptr.as_ptr() 
	}

    fn cap(&self) -> usize { 
		self.buf.cap 
	}

    pub fn new() -> Self {
        MyVec { buf: RawVec::new(), len: 0 }
    }

	fn push(&mut self, elem: T) {
    	if self.len == self.cap() { 
			self.buf.grow(); 
		}

		//关键点在于要直接覆盖，因为不知道内存之前是否有东西
    	unsafe {
    	    ptr::write(self.ptr().offset(self.len as isize), elem);
    	}

    	self.len += 1;
	}

	fn pop(&mut self) -> Option<T> {
    	if self.len == 0 {
    	    None
    	} else {
    	    self.len -= 1;
    	    unsafe {
    	        Some(ptr::read(self.ptr().offset(self.len as isize)))
    	    }
    	}
	}
	
	fn insert(&mut self, index: usize, elem: T) {
		assert!(index <= self.len, "越界");
    	if self.cap() == self.len { 
			self.buf.grow(); 
		}

		unsafe {
			if index < self.len {
				ptr::copy(self.ptr().offset(index as isize),
						self.ptr().offset((index as isize) + 1),
						self.len - index);
			}
			ptr::write(self.ptr().offset(index as isize), elem);
			self.len += 1;
		}
	}

	fn remove(&mut self, index: usize) -> T {
		assert!(index < self.len, "越界");
		unsafe {
			self.len -= 1;
			let result = ptr::read(self.ptr().offset(index as isize));
			ptr::copy(self.ptr().offset(index as isize + 1), 
					self.ptr().offset(index as isize),
					self.len - index);
			result
		}
	}

	fn into_iter(self) -> IntoIter<T> {
        unsafe {
			let iter = RawValIter::new(&self);
            let buf = ptr::read(&self.buf);
            mem::forget(self);

            IntoIter {
                iter: iter,
                _buf: buf,
            }
        }
	}
}

impl<T> Drop for MyVec<T> {
    fn drop(&mut self) {
        while let Some(_) = self.pop() {}
    }
}

impl<T> Deref for MyVec<T> {
	type Target = [T];
	fn deref(&self) -> &[T] {
		unsafe {
			slice::from_raw_parts(self.buf.ptr.as_ptr(), self.len)
		}
	}
}

impl<T> DerefMut for MyVec<T> {
	fn deref_mut(&mut self) -> &mut [T] {
		unsafe {
			slice::from_raw_parts_mut(self.buf.ptr.as_ptr(), self.len)
		}
	}
}

//为IntoIter实现迭代器
impl<T> Iterator for IntoIter<T> {
	type Item = T;
	fn next(&mut self) -> Option<T> {
		self.iter.next()
	}

	fn size_hint(&self) -> (usize, Option<usize>) {
		self.iter.size_hint()
	}
}

impl<T> DoubleEndedIterator for IntoIter<T> {
	fn next_back(&mut self) -> Option<T> {
		self.iter.next_back()
	}
}

struct RawValIter<T> {
    start: *const T,
    end: *const T,
}

impl<T> RawValIter<T> {
	unsafe fn new(slice: &[T]) -> Self {
		RawValIter {
			start: slice.as_ptr(),
			end: if slice.len() == 0 {
				slice.as_ptr()
			} else {
				slice.as_ptr().offset(slice.len() as isize)
			}
		}
	}
}

impl<T> Iterator for RawValIter<T> {
	type Item = T;
	fn next(&mut self) -> Option<T> {
		if self.start == self.end {
			None
		} else {
			unsafe {
				let result = ptr::read(self.start);
				self.start = self.start.offset(1);
				Some(result)
			}
		}
	}

	fn size_hint(&self) -> (usize, Option<usize>) {
		let len = (self.end as usize - self.start as usize) 
				/ mem::size_of::<T>();
		(len, Some(len))
	}
}


impl<T> DoubleEndedIterator for RawValIter<T> {
	fn next_back(&mut self) -> Option<T> {
		if self.start == self.end {
			None
		} else {
			unsafe {
				self.end = self.end.offset(-1);
				Some(ptr::read(self.end))
			}
		}
	}
}
	
use std::marker::PhantomData;
//Drain是一个API集合，将容器内数据的所有权移出，却不占有容器本身
struct Drain<'a, T: 'a> {
	vec: PhantomData<&'a mut MyVec<T>>,
	iter: RawValIter<T>,
}

impl<'a, T> Iterator for Drain<'a, T> {
	type Item = T;
	fn next(&mut self) -> Option<T> { 
		self.iter.next() 
	}
	
	fn size_hint(&self) -> (usize, Option<usize>) {
		self.iter.size_hint()
	}
}

impl<'a, T> DoubleEndedIterator for Drain<'a, T> {
    fn next_back(&mut self) -> Option<T> { self.iter.next_back() }
}

impl<'a, T> Drop for Drain<'a, T> {
	fn drop(&mut self) {
		for _ in &mut self.iter {}
	}
}

impl<T> MyVec<T> {
	fn drain(&mut self) -> Drain<T> {
		unsafe {
			let iter = RawValIter::new(&self);
			self.len = 0;
			Drain {
				iter: iter,
				vec: PhantomData,
			}
		}
	}
}


fn main() {
	{
		let mut vec: MyVec<i32> = MyVec::new();
		vec.push(8);
		vec.push(7);
		vec.push(6);
		
		while let Some(v) = vec.pop() {
			println!("v == {}", v);
		}

		vec.push(8);
		vec.push(7);
		vec.push(6);
		
		let s = &vec[1..];
		println!("s[0] == {}", s[0]);

		let s = &mut vec[1..];
		s[0] = 10;
		println!("s[0] == {}", s[0]);

		println!("-------------------------------");
		let mut vec2: MyVec<i32> = MyVec::new();
		vec2.push(1);
		vec2.push(2);
		vec2.push(3);
		//打印
		//while let Some(v) = vec2.pop() {
		//	println!("v == {}", v);
		//}

		vec2.insert(1, 11);
		let ret = vec2.remove(2);
		println!("remove elem: {}", ret);
		//打印
		while let Some(v) = vec2.pop() {
			println!("v == {}", v);
		}

		
		println!("-------------------------------");
		let mut vec3: MyVec<i32> = MyVec::new();
		vec3.push(1);
		vec3.push(2);
		vec3.push(3);
		vec3.push(4);
		let iter = vec3.iter();

		for val in iter {
		    println!("Got: {}", val);
		}

		println!("-------------------------------");
		let iter3: IntoIter<i32> = vec3.into_iter();
		for mut val in iter3 {
		    println!("Got: {}", val);
			val = 111;
		    println!("Got: {}", val);
		}

		println!("-------------------------------");
		let mut vec4: MyVec<i32> = MyVec::new();
		vec4.push(1);
		vec4.push(2);
		let mut iter4: IntoIter<i32> = vec4.into_iter();
		while let Some(val) = iter4.next_back() {
		    println!("Got: {}", val);
		}


		println!("-------------------------------");
		let mut vec5: MyVec<i32> = MyVec::new();
		vec5.push(11);
		vec5.push(12);
		vec5.push(13);
		vec5.push(14);
		let mut drain = vec5.drain();
		let a = drain.next().unwrap();
		println!("drain: {}", a);
		//从下面的打印可以看出已经借用了第一个元素
		while let Some(val) = drain.next_back() {
		    println!("Got: {}", val);
		}
		
	}
	
    println!("Hello, world!");
}