第 9 章：生命周期 —— 引用的"保质期"¶

// 这个函数编译不通过！
// fn longest(x: &str, y: &str) -> &str {
//     if x.len() > y.len() { x } else { y }
// }
// 错误：编译器不知道返回的引用来自 x 还是 y

// 'a 表示：x、y 和返回值都拥有相同的生命周期
fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
    if x.len() > y.len() {
        x
    } else {
        y
    }
}

fn main() {
    let string1 = String::from("abcd");
    let string2 = String::from("xyz");

    let result = longest(&string1, &string2);
    println!("较长的字符串: {}", result);
}

// 规则 2 的例子：只有一个引用参数，编译器自动推断
fn first_word(s: &str) -> &str {  // 自动推断为 fn first_word<'a>(s: &'a str) -> &'a str
    let bytes = s.as_bytes();
    for (i, &item) in bytes.iter().enumerate() {
        if item == b' ' {
            return &s[0..i];
        }
    }
    &s[..]
}

// 规则 3 的例子：方法中的 &self
struct Student {
    name: String,
}

impl Student {
    fn get_name(&self) -> &str {  // 自动推断生命周期
        &self.name
    }
}

// 结构体持有引用，需要生命周期标注
struct Excerpt<'a> {
    part: &'a str,  // Excerpt 的生命周期不能超过 part 引用的有效期
}

fn main() {
    let novel = String::from("从前有座山，山里有座庙...");
    let first_sentence = novel.split('。').next().expect("找不到句号");

    let excerpt = Excerpt {
        part: first_sentence,
    };

    println!("摘录: {}", excerpt.part);
}

fn main() {
    // 字符串字面量拥有 'static 生命周期
    let s: &'static str = "Hello, world!";
    println!("{}", s);

    // 常量也拥有 'static 生命周期
    const GREETING: &str = "你好，世界！";
    println!("{}", GREETING);
}

// 结构体 + 生命周期 + 泛型 + Trait Bound
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("hello");
    let s2 = String::from("world!");

    let result = longest_with_announcement(&s1, &s2, "比较两个字符串");
    println!("较长的: {}", result);

    // 生命周期约束示例
    let string1 = String::from("long string is long");
    {
        let string2 = String::from("xyz");
        let result = longest(&string1, &string2);
        println!("较长的: {}", result);
    }  // string2 在这里释放

    // 下面的代码编译不通过：
    // let string1 = String::from("long string is long");
    // let result;
    // {
    //     let string2 = String::from("xyz");
    //     result = longest(&string1, &string2);
    // }  // string2 释放，但 result 还引用着它
    // println!("较长的: {}", result);  // 编译错误！
}