fn main() {
    // 规则1：每个值有且仅有一个所有者
    let s = String::from("hello");

    // 规则2：同一时间只能有一个所有者
    let s2 = s; // s 的所有权移动（move）到 s2

    // println!("{}", s); // ❌ s 已失效
    println!("{}", s2);   // ✅ s2 是当前所有者

    // 规则3：当所有者离开作用域，值被自动释放
} // s2 离开作用域，String 被释放（调用 drop）

fn main() {
    let s1 = String::from("hello");
    let s2 = s1; // 移动（move）

    // s1 不再有效，不能再使用
    // println!("{}", s1); // ❌ 编译错误

    println!("{}", s2); // ✅
}

fn main() {
    let x = 5;
    let y = x; // 复制（copy）

    // 两个都有效
    println!("x={}, y={}", x, y); // ✅

    // Copy 类型包括：整数、浮点、布尔、字符、只包含 Copy 类型的元组
}

fn main() {
    let s1 = String::from("hello");
    let s2 = s1.clone(); // 深拷贝

    // 两个都有效且独立
    println!("s1={}, s2={}", s1, s2); // ✅

    // 修改 s2 不影响 s1
    let mut s2 = s2;
    s2.push_str(" world");
    println!("s1={}, s2={}", s1, s2); // s1="hello", s2="hello world"
}

fn takes_ownership(s: String) {
    println!("获得所有权: {}", s);
} // s 被释放

fn makes_copy(n: i32) {
    println!("复制的值: {}", n);
} // n 被释放，但原始值不受影响

fn main() {
    let s = String::from("hello");
    takes_ownership(s);
    // println!("{}", s); // ❌ s 的所有权已移动到函数中

    let x = 5;
    makes_copy(x);
    println!("x 仍然有效: {}", x); // ✅ x 是 Copy 类型
}

fn gives_ownership() -> String {
    let s = String::from("hello");
    s // 返回时移动所有权
}

fn takes_and_gives_back(s: String) -> String {
    println!("临时获得: {}", s);
    s // 返回时归还所有权
}

fn main() {
    let s1 = gives_ownership();
    println!("s1 = {}", s1);

    let s2 = takes_and_gives_back(s1);
    // println!("{}", s1); // ❌ s1 已移动
    println!("s2 = {}", s2); // ✅
}

fn calculate_length(s: &String) -> usize {
    s.len()
} // s 是引用，离开作用域不会释放原始数据

fn main() {
    let s = String::from("hello");
    let len = calculate_length(&s); // 借用 s
    println!("\"{}\" 的长度是 {}", s, len); // ✅ s 仍然有效
}

fn append_world(s: &mut String) {
    s.push_str(", world!");
}

fn main() {
    let mut s = String::from("hello");
    append_world(&mut s); // 可变借用
    println!("{}", s);    // hello, world!
}

fn main() {
    let mut s = String::from("hello");

    // ✅ 多个不可变引用可以共存
    let r1 = &s;
    let r2 = &s;
    println!("{} {}", r1, r2);

    // ✅ 不可变引用使用完后，可以创建可变引用
    let r3 = &mut s;
    r3.push_str(" world");
    println!("{}", r3);

    // ❌ 不能同时有不可变引用和可变引用
    // let r4 = &s;
    // let r5 = &mut s;
    // println!("{} {}", r4, r5); // 编译错误
}

fn main() {
    let mut s = String::from("hello");

    let r1 = &s;
    let r2 = &s;
    println!("{} {}", r1, r2);
    // r1 和 r2 在此之后不再使用（NLL），生命周期结束

    let r3 = &mut s; // ✅ 此时可以创建可变引用
    r3.push_str(" world");
    println!("{}", r3);
}

// ❌ 编译错误：返回对局部变量的引用
// fn dangle() -> &String {
//     let s = String::from("hello");
//     &s // s 在函数结束时被释放
// }

// ✅ 正确做法：返回所有权
fn no_dangle() -> String {
    let s = String::from("hello");
    s // 移动所有权给调用者
}

fn main() {
    let s = no_dangle();
    println!("{}", s);
}

// ❌ 编译器不知道返回值的生命周期与哪个参数相关
// fn longest(x: &str, y: &str) -> &str {
//     if x.len() > y.len() { x } else { y }
// }

// ✅ 使用生命周期标注
fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
    if x.len() > y.len() { x } else { y }
}

fn main() {
    let s1 = String::from("long string");
    let result;
    {
        let s2 = String::from("xyz");
        result = longest(s1.as_str(), s2.as_str());
        println!("最长的字符串: {}", result);
    }
    // println!("{}", result); // ❌ 可能编译错误：s2 已释放
}

#[derive(Debug)]
struct Excerpt<'a> {
    text: &'a str,
}

impl<'a> Excerpt<'a> {
    fn level(&self) -> i32 {
        3
    }

    fn announce(&self, announcement: &str) -> &str {
        println!("注意: {}", announcement);
        self.text // 返回的生命周期与 self 相同
    }
}

fn main() {
    let novel = String::from("Call me Ishmael. Some years ago...");
    let first_sentence;
    {
        let i = novel.find('.').unwrap_or(novel.len());
        first_sentence = Excerpt {
            text: &novel[..i],
        };
    }
    println!("摘录: {:?}", first_sentence);
}

// 不需要标注的情况
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 first_word<'a>(s: &'a str) -> &'a str { ... }

fn main() {
    let s = String::from("hello world");
    let word = first_word(&s);
    println!("第一个单词: {}", word);
}

// 'static 生命周期的数据存在于整个程序运行期间
let s: &'static str = "我有静态生命周期";

fn main() {
    // 字符串字面量都是 'static
    let greeting: &'static str = "hello";
    println!("{}", greeting);
}

use std::fmt::Display;

fn longest_with_announcement<'a, T>(
    x: &'a str,
    y: &'a str,
    ann: T,
) -> &'a str
where
    T: Display,
{
    println!("公告: {}", ann);
    if x.len() > y.len() { x } else { y }
}

fn main() {
    let s1 = String::from("long string");
    let s2 = "xyz";

    let result = longest_with_announcement(
        s1.as_str(),
        s2,
        "正在比较两个字符串的长度！",
    );
    println!("最长: {}", result);
}

use std::collections::HashMap;

struct Cache {
    data: HashMap<String, String>,
    max_size: usize,
}

impl Cache {
    fn new(max_size: usize) -> Self {
        Self {
            data: HashMap::new(),
            max_size,
        }
    }

    // 获取值的引用（借用）
    fn get(&self, key: &str) -> Option<&String> {
        self.data.get(key)
    }

    // 插入值（转移所有权）
    fn set(&mut self, key: String, value: String) {
        if self.data.len() >= self.max_size {
            // 移除一个旧条目（释放所有权）
            if let Some(oldest_key) = self.data.keys().next().cloned() {
                self.data.remove(&oldest_key);
            }
        }
        self.data.insert(key, value);
    }

    // 获取大小
    fn len(&self) -> usize {
        self.data.len()
    }
}

fn main() {
    let mut cache = Cache::new(3);

    // set 获得 key 和 value 的所有权
    cache.set("user:1".to_string(), "Alice".to_string());
    cache.set("user:2".to_string(), "Bob".to_string());
    cache.set("user:3".to_string(), "Charlie".to_string());

    // get 返回引用（借用）
    if let Some(name) = cache.get("user:1") {
        println!("用户1: {}", name);
    }

    // 添加第4个条目，会驱逐一个旧条目
    cache.set("user:4".to_string(), "David".to_string());
    println!("缓存大小: {}", cache.len()); // 3
}

/// 统计文本中每个单词的出现次数
/// 参数是不可变引用，不会夺走调用者的数据
fn word_frequency(text: &str) -> Vec<(&str, usize)> {
    let mut freq = std::collections::HashMap::new();

    for word in text.split_whitespace() {
        // entry API 返回可变引用
        *freq.entry(word).or_insert(0) += 1;
    }

    let mut result: Vec<_> = freq.into_iter().collect();
    result.sort_by(|a, b| b.1.cmp(&a.1));
    result
}

/// 提取文本摘要（前 n 个句子）
/// 返回的是对原始文本的切片引用
fn summarize(text: &str, n: usize) -> &str {
    let mut count = 0;
    for (i, ch) in text.char_indices() {
        if ch == '.' || ch == '。' {
            count += 1;
            if count == n {
                return &text[..=i];
            }
        }
    }
    text // 不足 n 句则返回全部
}

fn main() {
    let article = "Rust is a systems programming language. \
                   Rust is fast and safe. Rust has ownership. \
                   Rust prevents data races. Rust is loved.";

    // 借用 article，不转移所有权
    println!("摘要: {}", summarize(article, 2));
    println!();

    let freq = word_frequency(article);
    println!("词频统计:");
    for (word, count) in freq.iter().take(5) {
        println!("  \"{}\": {}次", word, count);
    }

    // article 仍然可用
    println!("\n原文长度: {} 字节", article.len());
}

fn main() {
    let mut v = vec![1, 2, 3, 4, 5];

    // ❌ 在迭代（借用）期间修改
    // for &item in &v {
    //     if item == 3 {
    //         v.push(6); // 不能在不可变借用期间可变借用
    //     }
    // }

    // ✅ 方案1：收集要修改的信息，迭代后再修改
    let should_add = v.contains(&3);
    if should_add {
        v.push(6);
    }
    println!("{:?}", v);

    // ✅ 方案2：使用 retain 等迭代器方法
    let mut v2 = vec![1, 2, 3, 4, 5, 6];
    v2.retain(|&x| x != 3); // 移除所有等于3的元素
    println!("retain后: {:?}", v2);
}

// ❌ 悬垂引用
// fn create_string() -> &str {
//     let s = String::from("hello");
//     &s // s 在函数结束后被释放
// }

// ✅ 返回所有权
fn create_string() -> String {
    String::from("hello")
}

// ✅ 返回 'static 引用
fn create_static() -> &'static str {
    "hello" // 字面量有 'static 生命周期
}

fn main() {
    let s1 = create_string();
    let s2 = create_static();
    println!("{}, {}", s1, s2);
}

fn main() {
    let name = String::from("Alice");

    // move 闭包获得所有权
    let closure = move || {
        println!("Hello, {}", name);
    };

    closure();
    // println!("{}", name); // ❌ name 已移动到闭包中

    // 如果是 Copy 类型则无此问题
    let n = 42;
    let closure2 = move || println!("n = {}", n);
    closure2();
    println!("n 仍然有效: {}", n); // ✅ i32 是 Copy 类型
}