本系列錄製的影片主要放在B站上Rust死靈書學習影片
Rust 死靈書相關的原始碼資料在github.com/anonymousGiga/Rustonomi...
在本節中，抽取出來一個RawVec對之前的程式碼進行重構，如下（重建一個工程）：
#![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>,
start: *const T,
end: *const 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 buf = ptr::read(&self.buf);
let len = self.len;
mem::forget(self);
IntoIter {
start: buf.ptr.as_ptr(),
end: buf.ptr.as_ptr().offset(len as isize),
_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> {
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 IntoIter<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))
}
}
}
}
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!("Hello, world!");
}本作品採用《CC 協議》，轉載必須註明作者和本文連結