深入解析Rust中的智能指针

#[derive(Debug)]
enum MyList {
    Cons(i32, Box<MyList>), // 必须为Box，此处为递归，大小不确定
    Nil,
}
use MyList::{Cons, Nil};
let list = Cons(1, Box::new(Cons(2, Box::new(Nil))));
println!("Recursive list: {:?}", list);

// 定义trait
trait Shape {
    fn area(&self) -> f64;
}
// 实现trait的结构体
struct Circle { radius: f64 }
impl Shape for Circle {
    fn area(&self) -> f64 { std::f64::consts::PI * self.radius.powf(2.0) }
}
struct Square { side: f64 }
impl Shape for Square {
    fn area(&self) -> f64 { self.side.powf(2.0) }
}
fn main() {
    // 用Box<dyn Shape>存储不同类型的Shape实现
    let shapes: Vec<Box<dyn Shape>> = vec![
        Box::new(Circle { radius: 1.0 }),
        Box::new(Square { side: 2.0 }),
    ];
    // 动态调用area方法（运行时确定具体类型）
    for shape in shapes {
        println!("面积：{:.2}", shape.area()); 
        // 输出：3.14（圆）、4.00（正方形）
    }
}

use std::rc::Rc;
fn main() {
    let a = Rc::new(String::from("hello"));
    let b = Rc::clone(&a);
    let c = Rc::clone(&a);
    println!("count = {}", Rc::strong_count(&a)); // 输出 3
    println!("{}", b);
} // 所有 Rc 离开作用域后才释放堆内存

use std::sync::Arc;
use std::thread;
pub fn arc_test() {
    let data = Arc::new(100); // 堆上的数据，原子引用计数=1
    let mut handles = vec![];
    // 创建3个线程共享data
    for i in 0..3 {
        let d = Arc::clone(&data); // 计数+1（原子操作）
        handles.push(thread::spawn(move || {
            println!("i: {}", d);
        }));
    }
    println!("before ref-count: {:?}", Arc::strong_count(&data));
    for h in handles {
        h.join().unwrap();
    }
    println!("after ref-count: {:?}", Arc::strong_count(&data)); // 原子引用计数=1
}

use std::rc::Rc;
use std::cell::RefCell;
pub fn refcell_test() {
    let shared_data = Rc::new(RefCell::new(0)); // 堆上的0，可共享且修改
    let a = Rc::clone(&shared_data);
    let b = Rc::clone(&shared_data);
    *a.borrow_mut() += 10; // a修改数据
    *b.borrow_mut() += 5; // b修改数据
    println!("{}", shared_data.borrow()); // 输出15
}

use std::sync::{Arc, Mutex};
use std::thread;
fn main() {
    let counter = Arc::new(Mutex::new(0));
    let mut handles = vec![];
    for _ in 0..5 {
        let c = Arc::clone(&counter);
        handles.push(thread::spawn(move || {
            let mut num = c.lock().unwrap();
            *num += 1;
        }));
    }
    for h in handles {
        h.join().unwrap();
    }
    println!("Result: {}", *counter.lock().unwrap());
}

use std::sync::RwLock;
use std::thread;
let data = RwLock::new(0);
// 启动一个写线程
let w_handle = thread::spawn(move || {
    let mut w = data.write().unwrap();
    thread::sleep(std::time::Duration::from_millis(100));
    *w = 42;
});
// 启动多个读线程
let mut r_handles = vec![];
for _ in 0..3 {
    let r_data = data.clone();
    let handle = thread::spawn(move || {
        let r = r_data.read().unwrap(); // 会被写线程阻塞，直到写完成
        println!("Read: {}", *r);
    });
    r_handles.push(handle);
}
w_handle.join().unwrap();
for h in r_handles { h.join().unwrap(); }

enum Cow<'a, B: ?Sized + 'a> where B: ToOwned {
    Borrowed(&'a B),
    Owned(<B as ToOwned>::Owned),
}

use std::borrow::Cow;
fn main() {
    let s = "immutable data".to_string();
    let mut cow = Cow::Borrowed(s.as_str()); // 借用 &str
    println!("Before: {:?}", cow); // Borrowed("immutable data")
    // 调用 to_mut() 会检测当前是否为借用
    let data = cow.to_mut(); // 克隆一份（从 Borrowed -> Owned）
    data.push_str(" modified");
    println!("After: {:?}", cow);  // Owned("immutable data modified")
}

use std::pin::Pin;
struct SelfRef {
    data: String,
    ptr: *const String,
}
impl SelfRef {
    fn new(txt: &str) -> Pin<Box<SelfRef>> {
        let mut boxed = Box::pin(SelfRef {
            data: String::from(txt),
            ptr: std::ptr::null(),
        });
        let ptr = &boxed.data as *const String;
        unsafe {
            let mut_ref = Pin::as_mut(&mut boxed);
            Pin::get_unchecked_mut(mut_ref).ptr = ptr;
        }
        boxed
    }
    fn show(&self) {
        unsafe {
            println!("data = {}, ptr = {}", self.data, &*self.ptr);
        }
    }
}
fn main() {
    let pinned = SelfRef::new("hello");
    pinned.show();
}