介绍

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

Rust 死灵书相关的源码资料在github.com/anonymousGiga/Rustonomi...

详细内容

在我们之前的MyVec的实现中，一直没有考虑零尺寸类型，本节我们来完善。

在处理零尺寸类型时，我们需要注意以下几点：

• 当分配器API传递分配尺寸为0时，会导致未定义行为；
• 对零尺寸类型的裸指针做offset是一个no-op，这会破坏我们的C-style指针迭代器。

支持零尺寸类型的代码如下：

复制
#![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, "还没准备好处理零尺寸类型");let cap = if mem::size_of::<T>() == 0 { !0 } else { 0 };
        RawVec { ptr: Unique::dangling(), cap: cap }}
 
    fn grow(&mut self) {
        unsafe {let align = mem::align_of::<T>();let elem_size = mem::size_of::<T>();
            assert!(elem_size != 0, "capacity overflow");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) {let elem_size = mem::size_of::<T>();
 
        if self.cap != 0 && elem_size != 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 mem::size_of::<T>() == 0 {((slice.as_ptr() as usize) + slice.len()) as *const _
            } else 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 = if mem::size_of::<T>() == 0 {(self.start as usize + 1) as *const _
                } else {
                    self.start.offset(1)};Some(result)}}}
 
    fn size_hint(&self) -> (usize, Option<usize>) {let elem_size = mem::size_of::<T>();let len = (self.end as usize - self.start as usize) 
                / if elem_size == 0 { 0 } else { elem_size };(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 = if mem::size_of::<T>() == 0 {(self.end as usize - 1) as *const _
                } else {
                    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!");
}