Rust Pointer

struct Test(i64, i64);

fn main() {
    let mut p = Box::new(Test(1234, 5678));
    println!("size: {:?}", std::mem::size_of_val(&p));
    let pp = &p as *const _ as *const [i64; 1];
    unsafe {
        println!("box addr is {:?}", pp);
        println!("box value is 0x{:x}", (*pp)[0]);

        let p_heap = (*pp)[0] as *const [i64; 2];
        println!("heap value is {:?}", *p_heap);
    }
}

size: 8
box addr is 0x7ffddf26ba58
box value is 0x56b77c0bcb80
heap value is [1234, 5678]

Box 自身分配在栈上, 它只包含一个指向堆的地址 (String 除了地址还包括 size 和 capacity), payload 实际在堆上.

1. 递归定义的数据结构
2. 堆上分配

3. 单一 owner 可以搞定的问题, 例如单向链表 (双向链表和树, 图等可能难以用 Box 处理)

   let node = TreeNode::new(1);
   prev.next = node;
   // node 已经被 move 到 prev.next, 无法再赋值给 next.prev
   next.prev = node;
   

1. Box 的 clone 会复制所有数据, 包含堆上的数据

   #[derive(Clone)]
   struct Test(i64, i64);
   
   fn main() {
       let p = Box::new(Test(1234, 5678));
       println!("box size: {:?}", std::mem::size_of_val(&p));
       let pp = &p as *const _ as *const [i64; 1];
       unsafe {
           println!("box addr is {:?}", pp);
           println!("box value is 0x{:x}", (*pp)[0]);
   
           let p_heap = (*pp)[0] as *const [i64; 2];
           println!("heap value is {:?}", *p_heap);
       }
   
       let p_cloned = p.clone();
       println!("rc size: {:?}", std::mem::size_of_val(&p_cloned));
       let pp_cloned = &p_cloned as *const _ as *const [i64; 1];
       unsafe {
           println!("cloned box addr is {:?}", pp_cloned);
           println!("cloned box value is 0x{:x}", (*pp_cloned)[0]);
   
           let p_heap = (*pp_cloned)[0] as *const [i64; 2];
           println!("heap value is {:?}", *p_heap);
       }
   }
   
   

   box size: 8
   box addr is 0x7ffe6084c258
   box value is 0x56ac7639db80
   heap value is [1234, 5678]
   rc size: 8
   cloned box addr is 0x7ffe6084c3b8
   cloned box value is 0x56ac7639dba0
   heap value is [1234, 5678]
   

2. Rc 的 clone 只是 shadow copy

   #[derive(Clone)]
   struct Test(i64, i64);
   
   use std::rc::Rc;
   
   fn main() {
       let p = Rc::new(Test(1234, 5678));
   
       let pp = &p as *const _ as *const [i64; 2];
       unsafe {
           println!("rc addr is {:?}", pp);
           println!("rc value is 0x{:x}", (*pp)[0]);
   
           let p_heap = (*pp)[0] as *const [i64; 4];
           println!("heap value is {:?}", *p_heap);
       }
       println!("strong_count: {:?}", Rc::strong_count(&p));
   
       println!("");
       let p_cloned = p.clone();
       let pp_cloned = &p_cloned as *const _ as *const [i64; 1];
       unsafe {
           println!("cloned box addr is {:?}", pp_cloned);
           println!("cloned box value is 0x{:x}", (*pp_cloned)[0]);
   
           let p_heap = (*pp_cloned)[0] as *const [i64; 4];
           println!("heap value is {:?}", *p_heap);
       }
       println!("strong_count: {:?}", Rc::strong_count(&p));
       println!("{:?}", Rc::into_raw(p));
   }
   
   

   rc addr is 0x7ffc48b8eeb0
   rc value is 0x601c2a5e3ae0
   heap value is [1, 1, 1234, 5678]
   strong_count: 1
   
   cloned box addr is 0x7ffc48b8f040
   cloned box value is 0x601c2a5e3ae0
   heap value is [2, 1, 1234, 5678]
   strong_count: 2
   0x601c2a5e3af0
   

   Rc 不是 fat pointer, 它只包含一个堆上的地址, 真正的数据以及引用计数等放在堆上.

使用 Rc 实现链表并不比 Box 简单, 主要原因是, 在遍历 list 时, 可以这样:

let mut head = fake_root.clone();
while let Some(n) = head.next.clone() {
    head = n;
}
Rc::get_mut(&mut head).unwrap().next = Some(node);
self.root = fake_root.next.clone();

问题是 Rc 只有在存在一个 owner 时才可以通过 get_mut 来修改, 类似于读写锁的限制, 导致我们在遍历时实际上无法修改, 因为至少有两个 owner 存在.