rust智能指针

Box，Rc，RefCell都是不可变借用，只不过RefCell是运行时检查，Box和RefCell是可变的，Rc不可变但同一个数据可以有多个拥有者

Box<T>类型具有已知大小并指向在堆上分配的数据。该 Rc<T>类型跟踪堆上数据的引用次数，以便数据可以有多个所有者。具有内部可变性的RefCell<T>类型为我们提供了一种类型，当我们需要不可变类型但需要更改该类型的内部值时可以使用该类型；它还在运行时而不是在编译时强制执行借用规则

use std::ops::Deref;
use std::rc::Rc;
use std::cell::RefCell;

enum List {
    Cons(i32, Box<List>),
    Nil,
}

#[derive(Debug)]
enum RcList {
    RcCons(Rc<RefCell<i32>>, Rc<RcList>),
    RcNil,
}

use crate::RcList::{RcCons, RcNil};

use crate::List::{Cons, Nil};

struct MyBox<T>(T);

impl<T> MyBox<T> {
    fn new(x: T) -> MyBox<T> {
        MyBox(x)
    }
}

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

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

fn hello(name: &str) {
    println!("Hello, {}!", name);
}

struct CustomSmartPointer {
    data: String,
}

impl Drop for CustomSmartPointer {
    fn drop(&mut self) {
        println!("Dropping CustomSmartPointer with data `{}`!", self.data);
    }
}

fn main() {
    //普通智能指针
    let num = Box::new(10);
    println!("{}",num);
    let list = Cons(1, Box::new(Cons(2, Box::new(Cons(3, Box::new(Nil))))));

    let mut x = 5;
    let mut y = &x;
    println!("y：{}",*(y.deref()));
    let z = Box::new(x);
    //z = Box::new(11);
    //*y = 10;  //借用不能修改
    //x = 10;

    assert_eq!(5, x);
    assert_eq!(5, *y);

    let m = MyBox::new(String::from("Rust"));
    hello(&m);
    hello(&(*m)[..]);

    let c = CustomSmartPointer {
        data: String::from("my stuff"),
    };
    //c.drop(); //不能手动调用
    let d = CustomSmartPointer {
        data: String::from("other stuff"),
    };
    println!("CustomSmartPointers created.");

    let value = Rc::new(RefCell::new(5));
    let a = Rc::new(RcCons(Rc::clone(&value), Rc::new(RcNil)));
    let b = RcCons(Rc::new(RefCell::new(3)), Rc::clone(&a));
    let c = RcCons(Rc::new(RefCell::new(4)), Rc::clone(&a));

    *value.borrow_mut() += 10;
    println!("a after = {:?}", a); //这个时候a的值就变了
    println!("b after = {:?}", b);
    println!("c after = {:?}", c);

    let r = Rc::new(100);
    let r1 = r;
    let r2 = r1;
    println!("r:{}",Rc::strong_count(&r2));
}

10
y：5
Hello, Rust!
Hello, Rust!
CustomSmartPointers created.
a after = RcCons(RefCell { value: 15 }, RcNil)
b after = RcCons(RefCell { value: 3 }, RcCons(RefCell { value: 15 }, RcNil))
c after = RcCons(RefCell { value: 4 }, RcCons(RefCell { value: 15 }, RcNil))
Dropping CustomSmartPointer with data `other stuff`!
Dropping CustomSmartPointer with data `my stuff`!