rust中智能指针的实现

fn main() {
    let x = 5;
    let p: *const i32 = &x; // 获取原生指针

    unsafe {
        println!("值是：{}", *p); // 只有在 unsafe 代码块中才能解引用
    }
}

fn main() {
    let b = Box::new(42);
    let ptr = Box::into_raw(b);         // 转换为裸指针，不再自动释放

    unsafe {
        let b2 = Box::from_raw(ptr);    // 重新接管所有权
        println!("恢复值：{}", b2);
    } // 自动释放
}

fn main() {
    let b = Box::new(100);              // 将整数 100 放到堆上
    println!("b 的值是：{}", *b);       // 解引用访问
} // 离开作用域自动释放（RAII）

use std::rc::Rc;

fn main() {
    let a = Rc::new("hello".to_string());
    let b = Rc::clone(&a);              // 引用计数 +1
    println!("a = {}, b = {}", a, b);   // 多个变量共享同一块内存
}

use std::cell::RefCell;

fn main() {
    let x = RefCell::new(10);           // 创建可变容器
    *x.borrow_mut() += 5;               // 可变借用
    println!("当前值: {}", x.borrow());
}

use std::borrow::Cow;

fn modify(input: Cow<str>) -> Cow<str> {
    if input.contains("x") {
        Cow::Owned(input.replace("x", "y")) // 真要改时才复制
    } else {
        input
    }
}

fn main() {
    let s = Cow::Borrowed("hexo");
    let result = modify(s);
    println!("结果：{}", result);
}

fn get_name() -> Option<&'static str> {
    Some("Tom")
}

fn main() {
    if let Some(name) = get_name() {
        println!("找到名字：{}", name);
    }
}

use std::sync::Arc;

fn main() {
    let a = Arc::new(42);
    let b = Arc::clone(&a);
    println!("a = {}, b = {}", a, b);
}

use std::sync::Mutex;

fn main() {
    let m = Mutex::new(0);
    {
        let mut data = m.lock().unwrap();
        *data += 1;
    }
    println!("当前值: {:?}", m);
}

use std::sync::RwLock;

fn main() {
    let lock = RwLock::new(10);

    {
        let r1 = lock.read().unwrap();
        let r2 = lock.read().unwrap();
        println!("读者1: {}, 读者2: {}", r1, r2);
    }

    {
        let mut w = lock.write().unwrap();
        *w += 10;
    }

    println!("写后值: {}", *lock.read().unwrap());
}

use std::sync::atomic::{AtomicUsize, Ordering};

fn main() {
    let counter = AtomicUsize::new(0);
    counter.fetch_add(1, Ordering::SeqCst); // 原子 +1
    println!("计数器值: {}", counter.load(Ordering::SeqCst));
}

use std::sync::{Arc, Mutex};
use std::thread;

fn main() {
    let counter = Arc::new(Mutex::new(0));
    let mut handles = vec![];

    for _ in 0..10 {
        let c = Arc::clone(&counter);
        let handle = thread::spawn(move || {
            let mut num = c.lock().unwrap();
            *num += 1;
        });
        handles.push(handle);
    }

    for h in handles {
        h.join().unwrap();
    }

    println!("最终结果: {}", *counter.lock().unwrap());
}

use std::rc::{Rc, Weak};
use std::cell::RefCell;

struct Node {
    next: RefCell<Option<Rc<Node>>>,
    prev: RefCell<Option<Weak<Node>>>, // 使用弱引用避免循环
}

use std::pin::Pin;

fn main() {
    let data = String::from("hello");
    let pinned = Pin::new(&data);
    println!("{}", pinned);
}

use std::cell::UnsafeCell;

struct MyType {
    data: UnsafeCell<i32>,
}

unsafe impl Sync for MyType {}

fn main() {
    let x = MyType { data: UnsafeCell::new(0) };

    unsafe {
        *x.data.get() = 42;
        println!("{}", *x.data.get());
    }
}