Rust内存安全与所有权系统深度实战：从编译期保证到零成本抽象的完整工程实践

fn demonstrate_move() {
    let heap_data = vec![1, 2, 3, 4, 5];
    let data_ref = heap_data; // 所有权转移
    // println!("{:?}", heap_data); // 编译错误！heap_data已被移动
    process_data(data_ref);    // data_ref的所有权传给函数
    // data_ref在此处已无效
}

fn process_data(data: Vec<i32>) {
    println!("Processing {} items", data.len());
    // data离开作用域，堆内存自动释放
}

fn copy_vs_move() {
    let x = 42;
    let y = x;           // i32实现了Copy，这是复制不是移动
    println!("x={}, y={}", x, y); // 两者都有效

    let flag = true;
    let other = flag;    // bool也实现了Copy
    println!("flag={}, other={}", flag, other);
}

fn borrowing_hierarchy() {
    let data = vec![10, 20, 30];

    // 不可变借用：允许多个共存
    let ref1 = &data;
    let ref2 = &data;    // OK：多个不可变引用共存
    println!("{} {} {}", ref1[0], ref2[1], data[2]);

    // 可变借用：独占访问
    let mut mutable = vec![1, 2, 3];
    let mref = &mut mutable;
    mref.push(4);        // 独占可变访问
    // println!("{}", mutable[0]); // 错误！可变借用活跃时不可有其他借用
    println!("{:?}", mref);

    // 借用一旦不再使用，作用域结束，借用释放
    println!("{}", mutable[0]); // OK：可变借用已结束
}

// 编译器无法推断返回引用来自哪个参数
fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
    if x.len() > y.len() { x } else { y }
}

// 'a 表示：返回值的生命周期不长于x和y中较短的那个
fn demonstrate_lifetime() {
    let outer = String::from("long outer string");
    let result;
    {
        let inner = String::from("short");
        result = longest(outer.as_str(), inner.as_str());
        println!("Longest: {}", result); // 有效：inner还活着
    }
    // println!("Longer: {}", result); !危险：inner已释放，result不应使用
}

struct TextAnalyzer<'a> {
    source: &'a str,       // 引用外部数据的字段
    position: usize,       // 自有数据
}

impl<'a> TextAnalyzer<'a> {
    fn new(text: &'a str) -> Self {
        TextAnalyzer { source: text, position: 0 }
    }

    fn next_word(&mut self) -> Option<&'a str> {
        let remaining = &self.source[self.position..];
        remaining.split_whitespace().next().map(|word| {
            self.position += word.len() + 1;
            word
        })
    }
}

fn analyze_text() {
    let document = "Rust ownership system prevents memory bugs".to_string();
    let mut analyzer = TextAnalyzer::new(&document);

    while let Some(word) = analyzer.next_word() {
        println!("Token: {}", word);
    }
}

// Box解决"递归类型大小不确定"问题
enum List<T> {
    Cons(T, Box<List<T>>),  // Box使递归类型有确定大小
    Nil,
}

fn build_list() {
    let list: List<i32> = List::Cons(1, Box::new(
        List::Cons(2, Box::new(
            List::Cons(3, Box::new(List::Nil))
        ))
    ));
    println!("Recursive list built successfully");
}

use std::rc::Rc;

fn shared_ownership() {
    let data = Rc::new(vec![1, 2, 3]);
    let ref1 = Rc::clone(&data); // 引用计数+1
    let ref2 = Rc::clone(&data); // 引用计数+1

    println!("Reference count: {}", Rc::strong_count(&data)); // 3

    // Rc配合RefCell实现"内部可变性"
    use std::cell::RefCell;
    let mutable_data = Rc::new(RefCell::new(vec![10, 20]));
    let rc_clone = Rc::clone(&mutable_data);

    mutable_data.borrow_mut().push(30);
    rc_clone.borrow_mut().push(40);
    println!("{:?}", mutable_data.borrow()); // [10, 20, 30, 40]
}

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

fn concurrent_shared_state() {
    let counter = Arc::new(Mutex::new(0u64));
    let mut handles = Vec::with_capacity(10);

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

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

/// 安全的环形缓冲区：unsafe操作被封装在实现内部
struct RingBuffer<T> {
    buffer: Vec<T>,
    head: usize, tail: usize, len: usize,
}

impl<T: Default + Clone> RingBuffer<T> {
    fn new(capacity: usize) -> Self {
        RingBuffer {
            buffer: vec![T::default(); capacity],
            head: 0, tail: 0, len: 0,
        }
    }

    fn push(&mut self, item: T) -> bool {
        if self.len == self.buffer.len() { return false; }
        self.buffer[self.tail] = item;
        self.tail = (self.tail + 1) % self.buffer.len();
        self.len += 1; true
    }

    fn pop(&mut self) -> Option<T> {
        if self.len == 0 { return None; }
        let item = self.buffer[self.head].clone();
        self.head = (self.head + 1) % self.buffer.len();
        self.len -= 1; Some(item)
    }
}

// 反模式：不必要的克隆
fn anti_pattern(input: String) -> String {
    let owned = input.clone(); // 不必要的clone
    owned.to_uppercase()
}

// 正确做法：接受借用
fn idiomatic(input: &str) -> String {
    input.to_uppercase()
}

use std::borrow::Cow;

fn process_name(input: &str) -> Cow<'_ str> {
    if input.chars().all(|c| c.is_ascii_alphanumeric() || c == '_') {
        Cow::Borrowed(input) // 零堆分配
    } else {
        Cow::Owned(input.replace(|c: char| !c.is_ascii_alphanumeric(), "_"))
    }
}

fn cow_demo() {
    println!("{}", process_name("valid_name"));   // 零分配
    println!("{}", process_name("invalid-name!")); // 按需分配
}

// 用类型区分"已验证"和"未验证"数据
struct UnverifiedEmail(String);
struct VerifiedEmail(String);

impl UnverifiedEmail {
    fn verify(self, code: &str) -> Result<VerifiedEmail, String> {
        if code == "123456" {
            Ok(VerifiedEmail(self.0))
        } else { Err("Invalid code".into()) }
    }
}

fn send_welcome(email: VerifiedEmail) {
    println!("Sending welcome to {}", email.0);
}

fn type_state_demo() {
    let raw = UnverifiedEmail("[email protected]".into());
    // send_welcome(raw); 编译错误：未验证邮箱不能调用
    if let Ok(verified) = raw.verify("123456") {
        send_welcome(verified); // 类型保证只有已验证邮箱才能发送
    }
}