【Rust 基础入门】(06) | 生命周期

在 Rust 的世界里，生命周期（Lifetime）就像是一场关于“租房”的思考。它确保了租客（引用）在租期内不会无房可住，避免了“房东提前收回房子，租客无家可归”的尴尬局面。今天，我们就来聊聊生命周期的概念，看看它是如何在 Rust 中发挥作用的。

1. 悬垂引用：房东提前收房，租客无家可归

悬垂引用（Dangling Reference）是 Rust 中的一大禁忌。它是指一个引用指向了已经被释放的内存.想象你租了一间房子，但还没等租期结束，房东就把房子卖了。这时，你还在房子里住着，却突然被赶了出来。Rust 通过借用检查器（Borrow Checker）来避免这种情况。Rust 的借用检查器就像是一个严格的房东，它会确保所有的“租约”都有效。

代码示例：

{
    let tenant;
    {
        let house = String::from("Apartment 101");
        tenant = &house; // house 的作用域结束了，但 tenant 还在引用它
    }
    println!("Tenant lives in: {}", tenant); // 编译失败：house 已经被释放
}

这段代码会编译失败，因为 house 的作用域结束后，tenant 仍然试图引用它，这会导致悬垂引用。

2. 生命周期：租约的期限

生命周期是 Rust 中引用的有效范围。它描述了引用在何时开始、何时结束。Rust 编译器会通过生命周期标注来确保引用不会超出其有效范围。

生命周期就像是一张租约的期限。租约上明确写着：“这间房子可以在 2025 年 1 月 1 日至 2025 年 12 月 31 日期间租用。” Rust 的生命周期标注就是这样的“租约”，它告诉编译器引用的有效范围。

代码示例：

fn choose_apartment<'a>(apt1: &'a str, apt2: &'a str) -> &'a str {
    if apt1.len() > apt2.len() {
        apt1
    } else {
        apt2
    }
}

这里的 'a 是一个生命周期标注，它表示 apt1 和 apt2 的生命周期重叠的部分。它并不是一个固定的范围，而是由 apt1 和 apt2 中较短的那个生命周期决定。

生命周期标注的核心思想是：多个引用之间的生命周期必须重叠，且返回值的生命周期不能超出输入参数的最小生命周期。

假设你和朋友合租一间房子，你们的租期可能不同。'a 代表你们租期的重叠部分，返回值的有效期只能在重叠租期内。

结构体的生命周期标注

struct RentalAgreement<'a> {
    apartment: &'a str,
}

fn main() {
    let apt = String::from("Apartment 202");
    let agreement = RentalAgreement { apartment: &apt }; // apartment 的生命周期必须大于 RentalAgreement 实例
}

3. 借用检查器：严格的房东

Rust 的借用检查器是生命周期的守护者，它通过比较引用的作用域来确保所有的借用都是有效的。借用检查器就像一个严格的房东，它会检查每一份“租约”是否在有效期内。如果发现有人试图使用过期的租约，它就会拒绝这笔交易。

借用检查器的工作原理

借用检查器会对变量的作用域范围进行标注，确保引用的作用域不会超出被引用值的范围。以下是一个例子：

{
    let greeting;             // ---------+-- 'a
                              //          |
    {                         //          |
        let name = "Alice";   // -+-- 'b  |
        greeting = &name;     //  |       |
    }                         // -+       |
                              //          |
    println!("{}", greeting); //          |
}

在这个例子中，变量 greeting 的作用域是 'a，而变量 name 的作用域是 'b。由于 'b 的范围小于 'a，即被引用的值 name 的作用域小于引用 greeting 的作用域，借用检查器会发现这个引用可能是无效的，从而导致编译失败。

如何通过借用检查器的检查？

要保证引用有效，只需要确保被引用的值的作用域大于或等于引用的作用域。换句话说，只要被引用的值一直存在，Rust 就认为这个引用是有效的。

{
    let name = "Bob";          // ----------+-- 'b
                               //           |
    let greeting = &name;      // --+-- 'a  |
                               //   |       |
    println!("{}", greeting);  //   |       |
                               // --+       |
}                              // ----------+

在这个修改后的例子中，name 的作用域 'b 大于 greeting 的作用域 'a，因此借用检查器会认为这个引用是有效的，代码能够顺利通过编译。

代码示例：

fn main() {
    let apt1 = String::from("Apartment 301");
    let chosen_apt;
    {
        let apt2 = String::from("Apartment 302");
        chosen_apt = choose_apartment(apt1.as_str(), apt2.as_str());
    }
    println!("Chosen apartment: {}", chosen_apt); // 编译失败：apt2 已被释放
}

这段代码会编译失败，因为 chosen_apt 的生命周期超出了 apt2 的作用域，借用检查器会阻止这种情况。

4. 总结

Rust 的生命周期管理可以有效避免悬垂引用，确保引用始终有效。借用检查器通过分析作用域，强制保证所有引用在合法的生命周期内。

• 悬垂引用：避免引用已被释放的内存。
• 生命周期标注：确保多个引用的生命周期不会超出安全范围。
• 借用检查器：检查引用的有效性，阻止非法借用。