rust / スマートポインタ ( Rc Arc RefCell Box )

pub fn run() {
    let val = Rc::new(10);
    let val2 = val.clone();
    let val3 = val.clone();
    println!("val: {},", Rc::strong_count(&val));
    // reference counter is 3
    println!("val: {}", *val);
    // val is 10
}

use std::rc::Rc;

pub fn run() {
    let a = Rc::new(List::Cons(5, Rc::new(List::Cons(10, Rc::new(List::Nil)))));
    let b = List::Cons(3, Rc::clone(&a));
    let c = List::Cons(4, Rc::clone(&a));
    println!("{:?}", c);
    // Cons(4, Cons(5, Cons(10, Nil)))
}

#[derive(Debug)]
enum List {
    Cons(i32, Rc<List>),
    Nil,
}

pub fn run() {
    let mut a = 10;
    let a1 = &mut a;
    let a2 = &a;
    *a1 = 10;
}

pub fn run() {
    let a = RefCell::new(10);
    let mut a1 = a.borrow_mut();
    let a2 = a.borrow();
    *a1 = 10;
}

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

pub struct Test {
    x: i32,
}

impl Test {
    pub fn println(&self) {
        println!("{}", self.x);
    }
}

pub fn run() {
    let a = Rc::new(RefCell::new(Test { x: 11 }));
    a.borrow().println();
    let a1 = a.clone();
    let a2 = a.clone();

    a1.borrow_mut().x = 12;
    a2.borrow().println();
    // count of references
    println!("{}", Rc::strong_count(&a));
}

use std::rc::Rc;
use std::thread;

fn main() {
    let rc = Rc::new(42);
    let thread = thread::spawn(move || {
        //       ^^^^^^^^^^^^^ `std::rc::Rc<i32>` cannot be sent between threads safely
        eprintln!("value = {}", rc);
    });
    thread.join().unwrap();
}

use std::sync::Arc;
use std::thread;

fn main() {
    let rc = Arc::new(42);
    let thread = thread::spawn(move || {
        eprintln!("value = {}", rc);
    });
    thread.join().unwrap();
}