Compiler Explorer

Source code

use std::ops::Deref;

struct RefCountAndT<T> {
    ref_count: usize,
    obj: T,
}

struct Rc<T> {
    ref_count_and_t: *mut RefCountAndT<T>,
}

impl <T> Rc<T> {
    pub fn new(obj: T) -> Self {
        //Move 'obj' onto the heap into a new RefCountAndT instance. We can use Box for this, just temporarily! 
        let ref_count_and_t = Box::new(RefCountAndT {
            ref_count: 1,
            obj,
        });
        //Now we *leak* the box to obtain the raw pointer! Box::leak returns a mutable *borrow*...
        let leaked : &mut RefCountAndT<T> = Box::leak(ref_count_and_t);
        //...but we want a *pointer*. Luckily, we can cast one into the other. This does NOT require unsafe code,
        //only *using* the pointer is unsafe (because it can be null)!
        let leaked_ptr : *mut RefCountAndT<T> = leaked;
        Self {
            ref_count_and_t: leaked_ptr,
        }
    }

pub fn get(&self) -> &T {
        unsafe {
            &self.ref_count_and_t.as_ref().unwrap().obj
        }
    }
}

impl <T> Drop for Rc<T> {
    fn drop(&mut self) {
        unsafe {
            let ref_count_and_t = self.ref_count_and_t.as_mut().unwrap();
            ref_count_and_t.ref_count -= 1;
            if ref_count_and_t.ref_count == 0 {
                let _as_box = Box::from_raw(self.ref_count_and_t);
            }
        }
    }
}

impl <T> Deref for Rc<T> {
    type Target = T;

fn deref(&self) -> &Self::Target {
        self.get()
    }
}

struct Test {}

impl Test {
    pub fn foo(&self) {
        println!("Test -> foo");
    }
}

pub fn main() {
    let rc1 = Rc::new(Test{});
    rc1.foo();
}