🦀 第11课：生命周期

生命周期（lifetime）是Rust中最独特的概念，也是初学者的最大难关。但它的本质很简单：确保引用在使用时仍然有效。生命周期不是运行时概念，而是编译期的静态分析工具。

🤔 为什么需要生命周期？

考虑这个函数——编译器无法确定返回的引用指向x还是y：

// ❌ 编译错误：缺少生命周期标注
// fn longest(x: &str, y: &str) -> &str {
//     if x.len() > y.len() { x } else { y }
// }
// 编译器问：返回的引用和x还是y的生命周期绑定？

🏷️ 生命周期标注语法

生命周期标注以'a的形式出现，表示引用的有效期限。它不改变引用的生命周期，只是告诉编译器引用之间的关系。

// &i32        → 引用，无生命周期参数
// &'a i32     → 带显式生命周期的引用
// &'a mut i32 → 带显式生命周期的可变引用

// 告诉编译器：返回值的生命周期与两个参数中较短的那个一致
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);  // ✅ s2还活着
    }
    // println!("{}", result);  // ❌ result可能指向s2，但s2已死
    
    // 更长的s1在外部
    let s3 = String::from("hello");
    let s4 = String::from("world!");
    let r = longest(s3.as_str(), s4.as_str());
    println!("最长: {}", r);  // ✅ s3和s4都还活着
}

✅ 验证通过

📐 结构体中的生命周期

// 结构体持有引用时必须标注生命周期
struct ImportantExcerpt<'a> {
    part: &'a str,  // 引用的生命周期至少要和结构体一样长
}

impl<'a> ImportantExcerpt<'a> {
    fn level(&self) -> i32 {
        3
    }
    
    // 返回值的生命周期与self一致（省略规则允许省略）
    fn announce_and_return_part(&self, announcement: &str) -> &str {
        println!("公告: {}", announcement);
        self.part
    }
}

fn main() {
    let novel = String::from("Call me Ishmael. Some years ago...");
    let first_sentence = novel.split('.').next().unwrap();
    
    let excerpt = ImportantExcerpt {
        part: first_sentence,
    };
    println!("摘录: {}", excerpt.part);
    println!("级别: {}", excerpt.level());
    
    let result = excerpt.announce_and_return_part("注意这段话");
    println!("返回: {}", result);
}

✅ 验证通过

📏 生命周期省略规则

虽然每个引用都有生命周期，但Rust允许在明确的情况下省略标注：

// 省略前 → 省略后

// 规则2：单一输入
fn foo<'a>(x: &'a str) -> &'a str { ... }
fn foo(x: &str) -> &str { ... }  // ✅ 省略

// 规则3：方法中的self
fn bar<'a>(&'a self, x: &str) -> &'a str { ... }
fn bar(&self, x: &str) -> &str { ... }  // ✅ 省略

// 规则1+需要标注：多个输入，没有self
fn baz<'a, 'b>(x: &'a str, y: &'b str) -> &??? str { ... }
fn baz(x: &str, y: &str) -> &str { ... }  // ❌ 无法推断！必须标注

🔒 静态生命周期 'static

fn main() {
    // 'static表示引用在整个程序运行期间都有效
    let s: &'static str = "我是静态字符串";  // 字符串字面量
    
    // 所有字符串字面量都是'static
    let greeting: &str = "Hello";  // 隐式'static
    
    // 显式标注（但不推荐滥用）
    fn get_static_str() -> &'static str {
        "这个字符串硬编码在二进制中"
    }
    
    println!("{}", get_static_str());
    
    // ⚠️ 不要为了解决生命周期错误就加'static
    // 这通常是设计问题的信号
    // fn bad() -> &'static str {
    //     let s = String::from("created at runtime");
    //     &s  // ❌ 即使标注'static也无法逃避编译检查
    // }
    
    // 使用owned类型替代引用来避免生命周期问题
    fn flexible() -> String {  // 返回String而非&str
        String::from("owned string, no lifetime issues")
    }
    println!("{}", flexible());
}

✅ 验证通过

🏗️ 综合实战：文本分析器

use std::collections::HashMap;

struct TextAnalyzer<'a> {
    text: &'a str,  // 借用文本，不拥有
    word_cache: HashMap<&'a str, usize>,  // 切片引用同一个文本
}

impl<'a> TextAnalyzer<'a> {
    fn new(text: &'a str) -> Self {
        let mut word_cache = HashMap::new();
        for word in text.split_whitespace() {
            *word_cache.entry(word).or_insert(0) += 1;
        }
        TextAnalyzer { text, word_cache }
    }
    
    fn word_count(&self) -> usize {
        self.word_cache.values().sum()
    }
    
    fn unique_words(&self) -> usize {
        self.word_cache.len()
    }
    
    fn most_common(&self, n: usize) -> Vec<(&'a str, usize)> {
        let mut words: Vec<_> = self.word_cache.iter().collect();
        words.sort_by(|a, b| b.1.cmp(a.1));
        words.into_iter().take(n).map(|(w, c)| (*w, *c)).collect()
    }
    
    fn find_context(&self, word: &str) -> Option<&'a str> {
        let start = self.text.find(word)?;
        let context_start = start.saturating_sub(20);
        let context_end = (start + word.len() + 20).min(self.text.len());
        Some(&self.text[context_start..context_end])
    }
    
    fn contains(&self, word: &str) -> bool {
        self.word_cache.contains_key(word)
    }
}

fn main() {
    let text = "Rust is a systems programming language that is safe and fast. \
                Rust provides zero-cost abstractions and guarantees memory safety. \
                Rust is loved by developers worldwide.";
    
    let analyzer = TextAnalyzer::new(text);
    
    println!("📊 文本分析结果:");
    println!("  总词数: {}", analyzer.word_count());
    println!("  不同词数: {}", analyzer.unique_words());
    
    println!("\n🏆 最常用词:");
    for (word, count) in analyzer.most_common(5) {
        println!("  '{}': {}次", word, count);
    }
    
    println!("\n🔍 搜索 'Rust':");
    if analyzer.contains("Rust") {
        if let Some(ctx) = analyzer.find_context("Rust") {
            println!("  上下文: ...{}...", ctx);
        }
    }
}

✅ 验证通过

📝 练习

🔧 生命周期高级模式

use std::collections::HashMap;

// 生命周期与结构体
struct Parser<'a> {
    input: &'a str,
    pos: usize,
}

impl<'a> Parser<'a> {
    fn new(input: &'a str) -> Self { Parser { input, pos: 0 } }
    
    fn peek(&self) -> Option { self.input[self.pos..].chars().next() }
    
    fn consume_while(&mut self, condition: F) -> &'a str
    where F: Fn(char) -> bool {
        let start = self.pos;
        while let Some(c) = self.peek() {
            if !condition(c) { break; }
            self.pos += c.len_utf8();
        }
        &self.input[start..self.pos]
    }
    
    fn parse_word(&mut self) -> Option<&'a str> {
        self.consume_while(|c| c.is_alphabetic())
            .is_empty()
            .then_some(None)
            .unwrap_or_else(|| Some(self.consume_while(|c| c.is_alphabetic())))
    }
}

fn main() {
    let text = "hello world rust";
    let mut parser = Parser::new(text);
    
    while let Some(word) = parser.parse_word() {
        println!("词: {}", word);
        parser.consume_while(|c| c.is_whitespace()); // 跳过空白
    }
    
    // 生命周期省略示例
    fn first<'a>(s: &'a str) -> &'a str {
        s.split_whitespace().next().unwrap_or("")
    }
    println!("第一个词: {}", first("hello world"));
}

✅ 验证通过

🏗️ 生命周期实战：解析器

use std::collections::HashMap;

struct IniParser<'a> {
    input: &'a str,
    sections: HashMap>,
}

impl<'a> IniParser<'a> {
    fn new(input: &'a str) -> Self {
        let mut sections = HashMap::new();
        let mut current_section = String::from("default");
        
        for line in input.lines() {
            let line = line.trim();
            if line.is_empty() || line.starts_with('#') { continue; }
            if line.starts_with('[') && line.ends_with(']') {
                current_section = line[1..line.len()-1].trim().to_string();
                sections.entry(current_section.clone()).or_insert_with(HashMap::new);
            } else if let Some((key, value)) = line.split_once('=') {
                sections.entry(current_section.clone())
                    .or_insert_with(HashMap::new)
                    .insert(key.trim().to_string(), value.trim().to_string());
            }
        }
        IniParser { input, sections }
    }
    
    fn get(&self, section: &str, key: &str) -> Option<&str> {
        self.sections.get(section).and_then(|s| s.get(key)).map(|s| s.as_str())
    }
    
    fn sections(&self) -> Vec<&str> {
        self.sections.keys().map(|s| s.as_str()).collect()
    }
}

fn main() {
    let config = r#"
[database]
host = localhost
port = 5432
name = myapp

[server]
port = 8080
workers = 4
debug = true
"#;
    let parser = IniParser::new(config);
    println!("段: {:?}", parser.sections());
    println!("数据库主机: {}", parser.get("database", "host").unwrap_or("?"));
    println!("服务器端口: {}", parser.get("server", "port").unwrap_or("?"));
}

✅ 验证通过