030 Rust死灵书之让Vec支持slice

介绍

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

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

详细内容

支持slice功能，我们实际上可以看成是对数据进行引用，因此我们只要实现Deref<Target=[T]>即可。

#![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;

pub struct MyVec<T> {
    ptr: Unique<T>,
    cap: usize,
    len: usize,
}

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

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

		//关键点在于要直接覆盖，因为不知道内存之前是否有东西
    	unsafe {
    	    ptr::write(self.ptr.as_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.as_ptr().offset(self.len as isize)))
    	    }
    	}
	}
}

impl<T> Drop for MyVec<T> {
	fn drop(&mut self) {
		if self.cap != 0 {
			while let Some(_) = self.pop() {}
			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!");
		}
	}
}

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

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 mut s = &mut vec[1..];
		s[0] = 10;
		println!("s[0] == {}", s[0]);
	}

    println!("Hello, world!");
}

上面实现了可变引用和不可变应用