所有权与借用

1. 每个值有且只有一个"所有者"（变量）
2. 同一时刻，只能有一个所有者
3. 所有者离开作用域时，值被立即释放（drop）

// i32、f64、bool、char 等实现了 Copy
let x = 5;
let y = x; // 复制，不是移动
 
println!("{x}"); // ✓ x 依然有效
println!("{y}"); // ✓
 
// 规律：如果类型的所有部分都是 Copy，整体才是 Copy
// String 不是 Copy（堆上分配，大小不固定）
// i32 是 Copy（固定 4 字节，栈上）

fn main() {
    let s = String::from("hello");
    takes_ownership(s);      // s 的所有权移入函数
    // println!("{s}");      // ✗ s 已被移走
 
    let x = 5;
    makes_copy(x);           // i32 是 Copy，x 依然有效
    println!("{x}");         // ✓
 
    // 方案：函数返回所有权
    let s2 = gives_ownership();  // 接收返回值的所有权
    println!("{s2}");
}
 
fn takes_ownership(s: String) {
    println!("{s}");
} // s 在这里被 drop
 
fn makes_copy(n: i32) {
    println!("{n}");
} // n 被复制，原变量不受影响
 
fn gives_ownership() -> String {
    String::from("yours now")
}

fn main() {
    let s = String::from("hello");
 
    // & 符号创建借用（引用）
    let len = calculate_length(&s); // 借用 s，不移走
 
    println!("'{s}' 的长度是 {len}"); // s 依然有效 ✓
}
 
// 参数类型是 &String，表示借用
fn calculate_length(s: &String) -> usize {
    s.len()
} // s 是借用，函数结束自动归还，不 drop

同一时刻，对同一数据，二选一：
  ● 任意数量的不可变借用（&T）
  ● 只能有一个可变借用（&mut T）
两者不能同时存在

fn main() {
    let mut s = String::from("hello");
 
    // 不可变借用：可以同时有多个
    let r1 = &s;
    let r2 = &s;
    println!("{r1} and {r2}"); // ✓
 
    // r1, r2 最后使用在上面这行，借用在这里结束
    // （NLL：Non-Lexical Lifetimes，编译器足够聪明）
 
    // 可变借用：只能有一个，且不能和不可变借用共存
    let r3 = &mut s;
    r3.push_str(", world");
    println!("{r3}"); // ✓
}

fn first_word(s: &str) -> &str {
    let bytes = s.as_bytes();
    for (i, &byte) in bytes.iter().enumerate() {
        if byte == b' ' {
            return &s[..i]; // 返回第一个空格前的切片
        }
    }
    &s[..] // 整个字符串
}
 
fn main() {
    let s = String::from("hello world");
    let word = first_word(&s); // 借用 s 的一部分
 
    // s.clear(); // ✗ 编译错误：s 被可变借用时 word 还在用
    println!("第一个词: {word}"); // ✓
}

// src/main.rs — 完整字符串处理器
fn main() {
    // 拥有所有权的字符串集合
    let mut words: Vec<String> = Vec::new();
 
    // push 移动所有权进 Vec
    words.push(String::from("hello"));
    words.push(String::from("world"));
    words.push(String::from("rust"));
 
    // 借用 Vec 进行只读操作
    let total_chars = count_chars(&words);
    println!("总字符数: {total_chars}");
 
    // 借用 Vec，返回新数据（不修改原 Vec）
    let upper = to_uppercase(&words);
    println!("大写: {upper:?}");
 
    // 可变借用：原地修改
    filter_short(&mut words, 4);
    println!("过滤后: {words:?}");
 
    // words 在 main 结束时自动 drop
}
 
// &Vec<String> — 不可变借用
fn count_chars(words: &Vec<String>) -> usize {
    words.iter().map(|w| w.len()).sum()
}
 
// 返回新的 Vec，不修改原数据
fn to_uppercase(words: &Vec<String>) -> Vec<String> {
    words.iter().map(|w| w.to_uppercase()).collect()
}
 
// &mut Vec — 可变借用，原地修改
fn filter_short(words: &mut Vec<String>, min_len: usize) {
    words.retain(|w| w.len() >= min_len);
}