Rust 所有权与内存安全：智能指针、内部可变性与 Unsafe 边界

let s = String::from("hello");
let t = s;  // s 的所有权 move 到 t
// println!("{}", s); // 编译错误：value borrowed here after move

#[derive(Copy, Clone)]
struct Point { x: i32, y: i32 } // ✅ 纯栈数据

struct Wrapper(String); // ❌ 无法 Copy

fn takes_ownership(s: String) { /* s 的所有权进入函数 */ }
fn borrows(s: &String) { /* 仅借用 */ }
fn mut_borrows(s: &mut String) { s.push('!'); }

fn main() {
    let s = String::from("hi");
    takes_ownership(s);       // s 被 move
    // takes_ownership(s);    // ❌ 已 move
    
    let mut t = String::from("hello");
    borrows(&t);              // ✅ 不可变借用
    mut_borrows(&mut t);      // ✅ 可变借用
}

let b = Box::new(5);        // 5 在堆上分配
let list = Box::new(Node {  // 递归结构必须使用 Box
    value: 1,
    next: Some(Box::new(Node { value: 2, next: None })),
});

use std::rc::Rc;

let data = Rc::new(String::from("shared"));
let d2 = Rc::clone(&data);   // 引用计数 +1
let d3 = Rc::clone(&data);   // 引用计数 +1

println!("count: {}", Rc::strong_count(&data)); // 3
// Rc::downgrade 创建弱引用，打破循环引用

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

let data = Arc::new(vec![1, 2, 3]);
let mut handles = vec![];

for i in 0..3 {
    let clone = Arc::clone(&data);
    handles.push(thread::spawn(move || {
        println!("thread {}: {:?}", i, clone);
    }));
}

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

use std::cell::RefCell;

let cell = RefCell::new(5);
*cell.borrow_mut() += 1;     // 运行时检查借用规则
println!("{}", cell.borrow()); // 6

// 违反规则会 panic（运行时，非编译期）
// let r1 = cell.borrow_mut();
// let r2 = cell.borrow_mut(); // thread 'main' panicked

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

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

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

for h in handles { h.join().unwrap(); }
println!("count: {}", *counter.lock().unwrap()); // 10

use std::borrow::Cow;

fn title_case(input: &str) -> Cow<'_, str> {
    if input.chars().all(|c| !c.is_lowercase()) {
        Cow::Borrowed(input)     // 无需修改，零拷贝
    } else {
        Cow::Owned(input.to_uppercase()) // 需要时才分配
    }
}

use std::cell::Cell;

let cell = Cell::new(5);
cell.set(10);              // 不可变引用下修改
println!("{}", cell.get()); // 10

use std::cell::RefCell;

struct Logger {
    logs: RefCell<Vec<String>>,
}

impl Logger {
    fn log(&self, msg: &str) {
        self.logs.borrow_mut().push(msg.to_string()); // &self 下修改
    }
}

use std::sync::LazyLock;

static CONFIG: LazyLock<String> = LazyLock::new(|| {
    std::fs::read_to_string("config.toml").unwrap()
});

fn main() {
    println!("{}", *CONFIG); // 首次调用时初始化
}

struct FileGuard {
    fd: i32,
    path: String,
}

impl Drop for FileGuard {
    fn drop(&mut self) {
        println!("Closing file: {}", self.path);
        // unsafe { libc::close(self.fd); }
    }
}

fn main() {
    let guard = FileGuard { fd: 1, path: "data.txt".to_string() };
    // guard 离开作用域时自动调用 drop()
}

let s = String::from("leak");
std::mem::forget(s); // 不调用 drop，产生内存泄漏
// 安全但不好；通常应避免

use std::mem::ManuallyDrop;

let mut m = ManuallyDrop::new(String::from("manual"));
// 不会自动调用 drop
unsafe { ManuallyDrop::drop(&mut m); } // 显式释放

println!("size: {}, align: {}", 
    std::mem::size_of::<String>(),
    std::mem::align_of::<String>()
);

#[repr(C)] // C 兼容布局
struct CStruct { a: u8, b: u32 }

#[repr(packed)] // 无填充（紧凑但可能慢）
struct Packed { a: u8, b: u32 }

#[repr(align(16))] // 16 字节对齐
struct Aligned { value: u64 }

struct Unit;           // size = 0
enum Void {}           // size = 0（不可实例化）

let v: Vec<Unit> = vec![Unit; 1000]; // 不分配堆内存！

fn dangling() -> &String {
    let s = String::from("dangle");
    &s // ❌ 编译错误：返回局部变量的引用
}   // s 在这里被 drop

let mut s = String::from("hello");
let r1 = &s;
let r2 = &mut s; // ❌ 编译错误：不能与不可变借用同时存在
// 规则确保条件 2（写入）且条件 3（无同步）的情况被消除

pub struct MyVec<T> {
    ptr: *mut T,
    len: usize,
    cap: usize,
}

impl<T> MyVec<T> {
    pub fn get(&self, index: usize) -> Option<&T> {
        if index >= self.len { return None; }
        // unsafe 块最小化
        Some(unsafe { &*self.ptr.add(index) })
    }
}

let mut x = 5;
let r = &mut x as *mut i32;       // 从引用创建裸指针
unsafe {
    *r = 10;                       // 解引用裸指针
    println!("{}", *r);
}

/// # Safety
/// 调用者必须确保 ptr 指向有效的、已初始化的 T 值
/// 且 ptr 的生命周期至少与返回引用一样长
unsafe fn from_raw<'a, T>(ptr: *const T) -> &'a T {
    &*ptr
}

// ❌ 低效
fn process(data: Vec<String>) -> Vec<String> { ... }

// ✅ 高效：借用
fn process(data: &[String]) -> Vec<String> { ... }

use std::borrow::Cow;

fn normalize(input: &str) -> Cow<'_, str> {
    if input.starts_with("prefix_") {
        Cow::Borrowed(input)
    } else {
        Cow::Owned(format!("prefix_{}", input))
    }
}

// ❌ 强制调用者 clone
fn greet(name: String) { println!("Hello, {}", name); }

// ✅ 灵活接受 String 和 &str
fn greet(name: &str) { println!("Hello, {}", name); }

greet("world");              // &str
greet(&String::from("world")); // &String 自动解引用