#生命周期

Rust 的生命周期（lifetimes）是其借用检查器（borrow checker）的一部分，用于确保引用的有效性。它防止悬垂引用（dangling references）和使用无效数据的问题，而无需运行时检查。生命周期在编译时验证引用不会超过被引用数据的生存期，这增强了内存安全。生命周期注解如 'a 是显式的，帮助编译器理解复杂借用关系。

1. 生命周期简介

  • 什么是生命周期？：生命周期表示值或引用的生存范围，从创建到销毁。Rust 隐式推断大多数生命周期，但复杂情况下需显式注解。
  • 为什么需要？：确保引用不指向已释放的内存。借用规则要求引用不能比所有者活得长。
  • 语法：用 'a（单引号 + 字母）表示，如 &'a T。'a 是泛型生命周期参数。
  • 规则：
    • 每个引用都有生命周期。
    • 函数签名中指定以帮助编译器。
    • 默认规则：函数参数的生命周期独立，返回值的生命周期与参数相关。
  • 'elision rules'：Rust 自动省略简单情况的注解（如 fn foo(s: &str) -> &str）。

示例：无注解的简单借用

fn longest(x: &str, y: &str) -> &str {
    if x.len() > y.len() {
        x
    } else {
        y
    }
}

// fn main() {
//     let result = longest("short", "longer");  // 有效，但无注解会错误（见下文）
// }
  • 解释：无注解时编译错误，因为返回的 &str 的生命周期不明。编译器无法确定是 'x 还是 'y 的生命周期。

2. 显式生命周期注解

在签名中添加 'a 指定关系。

示例：函数中的生命周期

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("short");
    let result;
    {
        let string2 = String::from("longer");
        result = longest(&string1, &string2);
        println!("最长: {}", result);  // 有效，在 string2 销毁前使用
    }
    // println!("{}", result);  // 错误！result 的 'a 与 string2 绑定，string2 已 drop
}
  • 解释：<'a> 声明参数，&'a str 表示 x 和 y 的引用至少活 'a 长。返回 &'a str 与参数共享生命周期（最短的那个）。这防止返回悬垂引用。

3. 结构体中的生命周期

结构体持有引用时，必须注解生命周期。

示例：结构体生命周期

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

fn main() {
    let novel = String::from("Call me Ishmael. Some years ago...");
    let first_sentence = novel.split('.').next().expect("找不到 '.'");
    let e = Excerpt { part: first_sentence };
    println!("{:?}", e);  // 输出: Excerpt { part: "Call me Ishmael" }
}
  • 解释：<'a> 表示 Excerpt 的生命周期不超过 part 引用的源。结构体实例不能比引用源活得长。

impl 中的生命周期

#![allow(unused)]
fn main() {
impl<'a> Excerpt<'a> {
    fn announce_and_return_part(&'a self, announcement: &str) -> &'a str {
        println!("注意！{}", announcement);
        self.part
    }
}
}
  • 解释：方法可添加自己的 'a，但通常与结构体共享。

4. 静态生命周期（'static）

'static 表示引用活到程序结束（如字符串字面量）。

示例：'static

fn static_ref() -> &'static str {
    "I have a static lifetime."
}

fn main() {
    let s: &'static str = "hello";
    println!("{}", s);
}
  • 解释：字符串字面量是 'static。Box::leak 可创建 'static，但小心内存泄漏。

5. 多生命周期和 bound

函数可有多个生命周期参数。

示例：多生命周期

#![allow(unused)]
fn main() {
fn longest_with_announce<'a, 'b>(x: &'a str, y: &'b str, ann: &str) -> &'a str {
    println!("公告: {}", ann);
    if x.len() > y.len() { x } else { x }  // 这里返回 'a，但 y 是 'b
}
}
  • 解释：'a 和 'b 独立。返回 &'a str 表示与 x 相关。如果返回 y，会错误，除非调整为最短生命周期。

生命周期 bound

如 T: 'a 表示 T 的引用至少活 'a 长。

6. 高级主题：NLL 和 Polonius

  • Non-Lexical Lifetimes (NLL)：Rust 1.31+ 引入，生命周期基于实际使用而非词法作用域。
  • Polonius：实验 borrow checker，处理更复杂借用（截至 2025 年，仍实验，但改善如条件借用）。
  • 生命周期子类型：'a: 'b 表示 'a 至少比 'b 长。
  • 高阶 trait bound：如 for<'a> Fn(&'a T)，用于闭包。

7. 最佳实践和常见陷阱

  • 只在必要时注解：依赖 elision rules（如单一 & 参数，返回 & 与其相关）。
  • 最小生命周期：注解最短必要生命周期，避免过度限制。
  • 调试错误：常见 "does not live long enough" – 检查借用顺序，用 {} 调整作用域。
  • 常见错误：
    • 返回局部引用：编译错误（missing lifetime specifier）。
    • 结构体引用自身：需 Box 或其他方式（不能直接 &'a self in 'a struct）。
    • 泛型与生命周期混用：如 fn foo<'a, T>(s: &'a T) – 确保 bound 如 T: 'a。
    • 线程中 'static：跨线程引用需 'static 或 Arc。
  • 性能：生命周期是编译时概念，零运行时开销。
  • 工具：用 rust-analyzer 可视化生命周期错误。

练习建议

  1. 修改 longest 函数，返回较短字符串（调整注解）。
  2. 创建持有两个引用的结构体，确保不同生命周期。
  3. 实现一个返回 'static 引用的函数，并与局部借用比较。