fn run(s: &str){}

run(&String::from("123"));
Copy

fn main() {
    let s = Box::new(String::from("hello, world"));
    // &s本来是&Box<String>，但是显示的声明可以自动解引用
    let s1: &String = &s; // 自动解一次
    let s1: &str = &s;    // 自动解两次

    // 智能指针上调用解引用之后才有的方法，也可以自动解
    let s2: String = s.to_string();
}
Copy

#![allow(unused)]
fn main() {
    struct Foo;

    impl Foo {
        fn foo(&self) { println!("Foo"); }
    }

    let f = &&Foo;

    f.foo();
    (&f).foo();
    (&&f).foo();
    (&&&&&&&&f).foo();
}
Copy

use std::rc::Rc;
fn main() {
    // Rc::new是创建一个Rc变量，与Box类似，同时这段堆内存引用计数为1
    let a = Rc::new(String::from("hello, world"));
    {
      // Rc::clone(&Rc)则是clone一份，并且计数+1
      let b = Rc::clone(&a);
      println!("{}, {}",  // 2, 2 a其实和b一样了
        Rc::strong_count(&a), 
        Rc::strong_count(&b));
    }
    println!("{}",  // 1 b被清理，引用-1，因为Rc的drop是引用-1，而不一定清理数据(0的时候清理)
        Rc::strong_count(&a));
}
Copy

struct ListNode<T: Debug> {
    val: T,
    next: Option<Rc<ListNode<T>>>,
}

fn main() {
    let mut l1 = ListNode{val: "1", next: None};
    let mut l2 = ListNode{val: "2", next: None};
    let mut l3 = ListNode{val: "3", next: None};
    // 因为Rc::new完了，所有权就交给Rc内部了，所以下面两行不能互换，互换后，l2.next其实已经无法访问到数据了，l2已不再持有所有权。
    l2.next = Option::from(Rc::new(l3));
    l1.next = Option::from(Rc::new(l2));

    print_list(&l1);
}

fn print_list<T: Debug>(root: &ListNode<T>) {
    println!("{:?}", root.val);

    // 注意这里不能用into_iter，因为iter，遍历的是&Rc类型而into则是Rc类型，后者有所有权的，如果直接在for中使用，会影响引用计数的，所以不允许。报错·cannot move out of `root.next` which is behind a shared reference·
    for ele in root.next.iter() {
        print_list(ele);
    }
}
Copy

let s = Rc::new(1);
for _ in 0..10 {
  let s = Rc::clone(&s);
  let handle = thread::spawn(move || {
    println!("{}", s)
  });
}
Copy

193 |           let handle = thread::spawn(move || {
    |  ______________________^^^^^^^^^^^^^_-
    | |                      |
    | |                      `Rc<i32>` cannot be sent between threads safely
Copy

let mut l3 = l1.next.as_ref().unwrap().next.as_mut().unwrap();
l3.val = "333";
Copy

error[E0596]: cannot borrow data in an `Rc` as mutable
   --> src\main.rs:288:18
    |
288 |     let mut l3 = l1.next.as_ref().unwrap().next.as_mut().unwrap();
    |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ cannot borrow as mutable
    |
    = help: trait `DerefMut` is required to modify through a dereference, but it is not implemented for `std::rc::Rc<ListNode<&str>>`

error[E0594]: cannot assign to data in an `Rc`
   --> src\main.rs:289:5
    |
289 |     l3.val = "333";
    |     ^^^^^^^^^^^^^^ cannot assign
Copy

struct ListNode<T: Debug> {
    val: T,
    next: Option<Rc<RefCell<ListNode<T>>>>,
}
// 嵌套很多层： Option是为了表示Null节点，Rc是为了固定大小且多个节点可以对数据有所有权，RefCell是使Rc内容是具有动态可变性(其实就是可以改Rc内的值)，ListNode就是下一个节点的真正内容。

fn main(){
    let mut l1 = ListNode{val: "1", next: None};
    let mut l2 = ListNode{val: "2", next: None};
    let mut l3 = ListNode{val: "3", next: None};
    l2.next = Option::from(Rc::new(RefCell::new(l3)));
    l1.next = Option::from(Rc::new(RefCell::new(l2)));

    // l3.val = "333"; l3已经被Rc持有了，已经无效了
    
    // l2是Ref类型
    let l2 = l1.next.as_ref().expect("l1 no child").borrow(); // as_ref很重要，因为不as_ref那l1的所有权就通过next转移了。后续就没法用l1了。

    // l3是RefMut<ListNode>类型，但是要修改L3还是要声明为mut
    let mut l3 = l2.next.as_ref().expect("l2 no child").borrow_mut();
    l3.val = "333";
    // drop很重要，l3是第三个ListNode的可变引用，后面的print函数挨着打印的时候，到第三个节点也会对齐进行引用，此时同一上下文就有可变引用和不可变引用同时存在，触发panic，Ref drop后是销毁当前Ref而不会干掉内部的数据。
    drop(l3);
    print_list(&l1);
}
Copy

borrow of partially moved value: `l1`
partial move occurs because `l1.next` 。。。
Copy