26.PhantomData幽灵数据.rs

柔光的暖阳◎ 2022-11-06 05:51 88阅读 0赞

/*
    它在标准库中的定义如下:
    #[lang = "phantom_data"]
    #[stable(feature = "rust1", since = "1.0.0")]
    pub struct PhantomData<T: ?Sized>;
    可以到它只是一个不占用任何空间的单元结构体，#[lang = "phantom_data"], 也表明了它是一个语言项，供 Rust 编译器本身使用。
    
    
    https://blog.csdn.net/wowotuo/article/details/93138295
    https://learnku.com/docs/nomicon/2018/310-phantom-data/4721
    https://www.yuque.com/zmant/blog/vi9k0p
    
    */
    
    use std::marker::PhantomData;
    use std::mem;
    
    // struct Slice<'a, T> {
    // 	start: *const T,
    //     end: *const T,
    // }
    
    struct Slice<'a, T: 'a> {
        start: *const T,
        end: *const T,
        phantom: PhantomData<&'a T>,
    }
    
    fn borrow_vec<'a, T>(vec: &'a Vec<T>) -> Slice<'a, T> {
        let ptr = vec.as_ptr();
        Slice {
            start: ptr,
            end: unsafe { ptr.add(vec.len()) },
            phantom: PhantomData,
        }
    }
    
    /*
    pub struct Context<'a> {
        waker: &'a Waker,
        _marker: PhantomData<fn(&'a ()) -> &'a ()>,
    }
    
    impl<'a> Context<'a> {
        /// Create a new `Context` from a `&Waker`.
        #[inline]
        pub fn from_waker(waker: &'a Waker) -> Self {
            Context {
                waker,
                _marker: PhantomData,
            }
        }
    }
    */
    
    // 还可用于对未使用的参数类型身上，比如下面的代码中就存在一个无界的类型参数，是编译不过的：
    // struct UnUsedSomeType<T, E> {
    //     value: T,
    // }
    
    //这种未使用的参数类型的情况可能在与其他语言交互的时候可能会遇到，正确做法同样是需要使用 PhantomData<E> 标记⼀下。
    struct UnUsedSomeType<T, E> {
        value: T,
        _mark: PhantomData<E>,
    }
    
    //---------------------------------------------------
    struct MyCell<T> {
        value: T,
    }
    
    impl<T: Copy> MyCell<T> {
        fn new(value: T) -> Self {
            MyCell { value }
        }
        fn get(&self) -> T {
            self.value
        }
        fn set(&self, value: T) {
            unsafe {
                std::ptr::write(&self.value as *const _ as *mut _, value);
            }
        }
    }
    
    fn main() {
        let val = String::from("hello");
        let cell = MyCell::new(&val);
        println!("cell value={}", cell.get());
        let val2 = String::from("world");
    
        println!("---------------------------------------------------------------");
    
        //但如果我们按下⾯的⽅式使⽤，代码还是可以正常编译，但是运⾏起来之后就发现结果是未定义的。
        let val = String::from("hello");  // 'a: line2 ~ line9
        let cell = MyCell::new( &val );   // 'b: line3 ~ line9
        {
            let val2 = String::from("hi"); // 'c: line5 ~ line7
            cell.set( &val2 );   // 这里期待 cell 的类型是 MyCell<&'c String>
        }
        println!("cell value={}", cell.get());
    }