《Rust编程入门》6.3 生命周期的定义与用法

6.3 生命周期的定义与用法

Rust 的生命周期是其内存安全模型中的一个核心概念。生命周期用于描述程序中引用的有效范围，确保引用在使用时始终指向有效的数据。Rust 通过生命周期标注来管理引用的生命周期，避免了悬垂指针、空悬引用等常见的内存错误，并通过严格的生命周期规则防止了数据竞争。

6.3.1 生命周期的基本概念

生命周期（lifetimes）是 Rust 用来表示引用有效时间的机制。在 Rust 中，引用总是必须处于某个有效的生命周期范围内，否则会导致编译错误。生命周期确保在引用的任何使用期间，引用指向的数据依然有效。

生命周期的作用

生命周期用于解决两个问题：

1. 悬垂引用（dangling references）：指向已经被销毁或不再有效的数据的引用。
2. 数据竞争：多个线程同时修改同一数据时可能导致的不确定行为。

6.3.2 生命周期标注

在 Rust 中，生命周期标注通过 'a 等符号来表示。生命周期标注并不直接影响程序的逻辑行为，它们只是编译器用来检查引用在作用域中的有效性。这些标注仅用于确保引用的数据在其生命周期内有效。

生命周期标注的基本语法

生命周期标注通常出现在函数签名中，标明函数参数和返回值中引用的有效范围。一个常见的生命周期标注例子如下：

1
2
3
4
5
6
7

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

• 在此例中，'a 是生命周期参数，表示 s1 和 s2 的引用以及函数的返回值都具有相同的生命周期 'a。
• 这意味着返回的引用是 s1 和 s2 引用中生命周期较短的那个。

6.3.3 生命周期与函数

生命周期标注最常见的用法之一是在函数签名中，特别是当函数接收引用作为参数并返回引用时。Rust 需要通过生命周期标注来确保返回的引用不会超出输入参数的生命周期。

返回引用时的生命周期

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

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[..i];
        }
    }
    &s[..]
}

fn main() {
    let s = String::from("Hello world");
    let word = first_word(&s);
    println!("The first word is: {}", word);
}

在这个例子中，first_word 函数接受一个字符串的引用并返回一个字符串切片的引用。通过生命周期标注 'a，我们明确表明返回的引用 &s[..] 不会比输入参数 s 的生命周期更长。这种方式确保了返回的切片不会引用一个已经被销毁的字符串。

6.3.4 生命周期和结构体

当结构体中包含引用时，生命周期也会成为一个重要的问题。我们需要为结构体中的引用添加生命周期标注，来确保结构体实例在引用有效的范围内。

结构体中的生命周期

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

struct Book<'a> {
    title: &'a str,
    author: &'a str,
}

fn main() {
    let s1 = String::from("Rust Programming");
    let s2 = String::from("Steve");

    let book = Book {
        title: &s1,
        author: &s2,
    };

    println!("Book title: {}, Author: {}", book.title, book.author);
}

在这个例子中，Book 结构体包含两个字符串的引用（title 和 author），因此我们使用生命周期标注 'a 来指定结构体实例中引用的生命周期。这样，book 的生命周期将被限制在 s1 和 s2 的生命周期之内。

6.3.5 生命周期推导

Rust 有一套生命周期推导规则，允许编译器在大多数情况下自动推导引用的生命周期，而无需显式地为每个函数或结构体添加生命周期标注。生命周期推导会根据函数参数的关系和返回值来自动推测生命周期。

例如，以下函数没有显式标注生命周期：

1
2
3
4
5
6
7

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

在这种情况下，Rust 会推导出生命周期标注，推测 longest 函数的参数和返回值的生命周期是相同的。也就是说，s1 和 s2 的生命周期应该一致，且返回值的生命周期与较短的输入参数生命周期一致。

6.3.6 生命周期和静态生命周期

Rust 还提供了一个特殊的生命周期标注：'static。它表示引用的生命周期是程序的整个运行期，即引用指向的数据永远有效。一个常见的例子是字符串字面量：

1
2
3
4
5
6
7
8

fn greet() -> &'static str {
    "Hello, world!"
}

fn main() {
    let message = greet();
    println!("{}", message);
}

在此，"Hello, world!" 是一个静态字符串字面量，它的生命周期是 'static。返回值的生命周期也标注为 'static，表明该值在整个程序运行期间都有效。

6.3.7 生命周期省略规则

Rust 提供了生命周期省略规则，这使得我们不必每次都显式写出生命周期标注。Rust 会根据函数签名的某些规则自动推导出生命周期。

生命周期省略的三条规则：

1. 函数有一个输入参数引用时，生命周期标注会省略。
2. 如果有多个输入参数引用，Rust 会推导出它们的生命周期是一样的。
3. 如果返回值是引用，那么返回值的生命周期会推导为与参数中第一个引用的生命周期相同。

例如：

1
2
3

fn first_word(s: &str) -> &str { 
    s 
}

在此，Rust 会自动推导出生命周期标注，因为 first_word 函数的参数 s 是一个引用，返回值的生命周期与 s 的生命周期相同。

6.3.8 小结

• 生命周期 是 Rust 的内存安全模型中非常重要的部分，它帮助我们管理引用的有效期，防止悬垂指针和数据竞争。
• 生命周期标注（如 'a）用于显式指定引用的生命周期，Rust 的编译器可以推导大多数情况下的生命周期，但在某些情况下我们需要显式标注。
• 生命周期的规则和推导确保了 Rust 程序在高性能和安全性之间取得平衡，同时避免了常见的内存错误。

下一节将深入探讨 Rust 中 结构体与枚举的使用与设计，并介绍如何在实际项目中使用它们来构建健壮的程序。

• Rust
• Rust Tutors
• Rust编程入门