1. 生命周期的作用：防止懸垂引用

懸垂引用是指引用指向的數(shù)據(jù)已經(jīng)被釋放，從而導(dǎo)致引用變得無效。Rust 通過生命周期和借用檢查器在編譯時就捕獲此類問題，從而避免運行時錯誤。

考慮下面這個示例（Listing 10-16），該代碼嘗試將外部變量 r 設(shè)置為引用內(nèi)層變量 x 的值，但內(nèi)層變量在作用域結(jié)束后便被清理，從而使引用 r 指向已釋放的數(shù)據(jù)：

fn main() {
    let r;              // r 的作用域延伸到整個 main 函數(shù)
    {
        let x = 5;
        r = &x;         // 將 r 設(shè)為 x 的引用，此時 x 的生命周期僅在此塊內(nèi)
    }
    // 此處 x 已經(jīng)超出作用域，r 將成為懸垂引用
    println!("r: {}", r);
}

編譯器會報錯，提示 x does not live long enough，這是因為 x 的生命周期比 r 短，無法保證 r 引用的內(nèi)存始終有效。

2. 借用檢查器與生命周期注解

Rust 的借用檢查器負責(zé)比較變量的作用域（生命周期），確保所有引用在使用時都是有效的。我們可以通過在代碼中手動注解生命周期，來明確告訴編譯器各引用的有效范圍。

例如，在下面（Listing 10-17）我們用 'a 和 'b 分別標(biāo)注了 r 和 x 的生命周期：

fn main() {
    // 'a: r 的生命周期，延伸到整個 main
    let r: &'a i32;
    {
        // 'b: x 的生命周期，只在此塊內(nèi)
        let x = 5;
        r = &x;
    }
    // 此時 r 引用的 x 的生命周期 'b 已結(jié)束，編譯器將報錯
    println!("r: {}", r);
}

在這段代碼中，借用檢查器比較了生命周期 'a 和 'b，發(fā)現(xiàn) r 的生命周期（外層）比它所引用的 x 的生命周期（內(nèi)層）長，因此拒絕編譯，從而防止了懸垂引用問題。

為修復(fù)這種錯誤，我們需要確保引用的生命周期不超過數(shù)據(jù)本身的生命周期。

例如，可以將 x 的聲明移動到 r 的作用域內(nèi)，確保它在整個使用期間有效：

fn main() {
    let x = 5;          // x 的生命周期延伸到 main
    let r = &x;         // r 引用 x，生命周期與 x 保持一致
    println!("r: {}", r);
}

這樣編譯器就能確認(rèn) r 引用的內(nèi)存始終有效。

3. 在函數(shù)中使用泛型生命周期

考慮一個返回較長字符串切片的函數(shù) longest。由于函數(shù)參數(shù)是引用，為了確保返回值引用有效，必須為引用指定生命周期。最初可能寫成如下代碼，但編譯時會報錯：

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

編譯器不知道返回的引用是屬于 x 還是 y 的生命周期，因此報錯。解決辦法是在函數(shù)簽名中為引用添加相同的生命周期參數(shù)，如下所示（Listing 10-21）：

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

這表示對于某個生命周期 'a，x 和 y 的引用至少活躍 'a 時間，而返回的引用也保證至少活躍 'a。當(dāng)我們調(diào)用 longest 時，編譯器會選擇 x 和 y 中較短的那段生命周期作為返回引用的實際生命周期。

例如，在下面的代碼中，string1 的生命周期長于 string2 的生命周期，所以返回的引用的生命周期為較短的 string2 的作用域范圍（Listing 10-22）：

fn main() {
    let string1 = String::from("long string is long");
    let result;
    {
        let string2 = String::from("xyz");
        result = longest(string1.as_str(), string2.as_str());
        println!("The longest string is {}", result); // 在此處，result 引用 string2
    }
    // 如果在此處使用 result，就會出錯，因為 string2 已經(jīng)超出作用域
}

這樣確保了引用的安全性：編譯器拒絕在數(shù)據(jù)無效時使用引用。

4. 生命周期注解的更多應(yīng)用

4.1 在結(jié)構(gòu)體中使用生命周期

如果結(jié)構(gòu)體持有引用，則需要在結(jié)構(gòu)體定義中為引用字段指定生命周期參數(shù)。

例如，定義一個保存字符串切片的結(jié)構(gòu)體 ImportantExcerpt（Listing 10-24）：

struct ImportantExcerpt<'a> {
    part: &'a str,
}

fn main() {
    let novel = String::from("Call me Ishmael. Some years ago...");
    let first_sentence = novel.split('.').next().expect("Could not find a '.'");
    let excerpt = ImportantExcerpt { part: first_sentence };
    println!("Excerpt: {}", excerpt.part);
}

這里，我們在結(jié)構(gòu)體名后面聲明了生命周期參數(shù) 'a，并將其用在字段 part 的引用類型上。這意味著 ImportantExcerpt 的實例不能比它所持有的引用活得更久。

4.2 生命周期省略規(guī)則

Rust 設(shè)計了一套生命周期省略規(guī)則，讓在大部分情況下無需顯式標(biāo)注生命周期。比如函數(shù) first_word（Listing 10-25）在沒有顯式注解的情況下仍能編譯：

fn first_word(s: &str) -> &str {
    let bytes = s.as_bytes();
    for (i, &item) in bytes.iter().enumerate() {
        if item == b' ' {
            return &s[0..i];
        }
    }
    &s[..]
}

編譯器根據(jù)規(guī)則自動推斷出所有引用應(yīng)當(dāng)共享相同的生命周期。但如果函數(shù)涉及多個引用且關(guān)系復(fù)雜，可能就需要手動添加生命周期注解了。

4.3 靜態(tài)生命周期

'static 是一個特殊的生命周期，表示引用可以在整個程序執(zhí)行期間都有效。所有字符串字面值都具有 'static 生命周期：

let s: &'static str = "I have a static lifetime.";

通常我們不需要顯式使用 'static，除非遇到編譯器建議或特殊需求。在大多數(shù)場景下，正確使用生命周期參數(shù)即可滿足內(nèi)存安全需求。

5. 泛型、特質(zhì)與生命周期的綜合使用

由于生命周期也是一種泛型，因此它們可以與類型泛型和特質(zhì)約束一同使用。

例如，下面是一個擴展版的 longest 函數(shù)，它不僅返回較長的字符串切片，還接受一個額外的參數(shù) ann，要求該參數(shù)實現(xiàn) Display 特質(zhì)（Listing 10-11 綜合示例）：

use std::fmt::Display;

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

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

    let result = longest_with_an_announcement(string1.as_str(), string2, "Comparing strings");
    println!("The longest string is {}", result);
}

在這個例子中，我們在函數(shù)名后面的尖括號中同時聲明了生命周期參數(shù) 'a 和泛型類型參數(shù) T。T 通過 where 子句被約束為必須實現(xiàn) Display，保證我們可以使用 {} 格式化輸出 ann。同時，返回的引用的生命周期為 'a，確保它與輸入?yún)?shù)中的較短生命周期一致。

總結(jié)

本文介紹了 Rust 中如何通過生命周期注解來驗證引用的有效性，并確保引用不會出現(xiàn)懸垂問題。我們討論了：

• 防止懸垂引用：如何利用生命周期保證引用不會超過其指向數(shù)據(jù)的作用域，以及借用檢查器如何在編譯時分析生命周期。
• 在函數(shù)中的泛型生命周期：通過給函數(shù)參數(shù)和返回值添加生命周期參數(shù)（如 'a），使得函數(shù)能夠安全返回引用，例子中展示了 longest 函數(shù)的正確寫法。
• 生命周期省略規(guī)則：解釋了在簡單情況下 Rust 如何自動推斷引用的生命周期，從而使代碼更簡潔。
• 在結(jié)構(gòu)體中使用生命周期：當(dāng)結(jié)構(gòu)體持有引用時，需要為引用字段指定生命周期，保證結(jié)構(gòu)體實例不會超出其引用的數(shù)據(jù)有效范圍。
• 靜態(tài)生命周期與綜合應(yīng)用：介紹了 'static 生命周期以及如何將生命周期與泛型和特質(zhì)約束相結(jié)合來編寫更靈活的代碼。

通過這些機制，Rust 將所有內(nèi)存安全問題提前到了編譯時檢查，從而使得程序在運行時既高效又安全。希望這篇博客能幫助你理解并掌握 Rust 中生命周期的使用，在實際開發(fā)中編寫出既靈活又安全的代碼！也希望大家多多支持腳本之家。

最新評論