rust生命期

July 27, 2022

rust

此处的生命期指 lifetimes 而非 lifecycle

rust 生命期

生命期是一类允许我们向编译器提供引用如何相互关联的泛型。

Rust 的生命期功能允许在很多场景下借用值的同时仍然使编译器能够检查这些引用的有效性。

也就是说，生命期是编写者提供给编译器用于检查的，用于确保引用有效（不会构成悬垂引用）。

Rust 中的每一个引用都有其生命期（lifetime），也就是引用保持有效的作用域。

大部分时候生命期是隐含并可以推断的，正如大部分时候类型也是可以推断的一样。

（函数和结构体往往需要额外的生命期标注，因为难以静态分析）

类似于当因为有多种可能类型的时候必须注明类型，也会出现引用的生命期以一些不同方式相关联的情况，

所以 Rust 需要我们使用泛型生命期参数来注明他们的关系，这样就能确保运行时实际使用的引用绝对是有效的。

生命期标注语法

rust

&i32        // 引用
&'a i32     // 带有显式生命期的引用
&'a mut i32 // 带有显式生命期的可变引用

fn choose_first<'a: 'b, 'b>(first: &'a i32, _: &'b i32) -> &'b i32 {
    first
}
// `<'a: 'b, 'b>` 读作生命期 `'a` 至少和 `'b` 一样长。

函数的生命期

在 rust 中，普通函数的函数体都是一块作用域。

rust 中的借用是指对一块内存空间（或者说，对另一个变量）的引用。
rust 有一条借用规则是借用方的生命期不能比出借方的生命期还要长。

对于一个参数和返回值都包含引用的函数而言，函数的参数是出借方，函数返回值所绑定到的那个变量就是借用方。

所以，这种函数也需要满足借用规则（借用方的生命期不能比出借方的生命期还要长）。
那么就需要对函数返回值的生命期进行标注，告知编译器函数返回值的生命期信息。

一个典型的错误示例如下：

rust

fn max(a: &i32, b: &i32) -> &i32 {
    if a > b {
        a
    } else {
        b
    }
}

fn main() {
    let x = 1;
    let y = 0;
    let big = max(&x, &y);
    println!("{}", big);
}

编译器给出如下错误：

   Compiling playground v0.0.1 (/playground)
error[E0106]: missing lifetime specifier
 --> src/main.rs:1:29
  |
1 | fn max(a: &i32, b: &i32) -> &i32 {
  |           ----     ----     ^ expected named lifetime parameter
  |
  = help: this function's return type contains a borrowed value, but the signature does not say whether it is borrowed from `a` or `b`
help: consider introducing a named lifetime parameter
  |
1 | fn max<'a>(a: &'a i32, b: &'a i32) -> &'a i32 {
  |       ++++     ++          ++          ++

For more information about this error, try `rustc --explain E0106`.
error: could not compile `playground` due to previous error

根据提示做如下修改：

rust

fn max<'a>(a: &'a i32, b: &'a i32) -> &'a i32 {
    if a > b {
        a
    } else {
        b
    }
}

这个生命期表示获取了返回值（引用）的变量，其生命期应当与入参 a 和 b 相同

因此，如下代码不被允许编译：

rust

fn main() {
    let big: &i32;
    let x = 1;
    {
        let y = 0;
        big = max(&x, &y);
    }// 在这里，入参 y 的生命期已结束
    println!("{}", big); // 然而，在这里，另一个入参 x 的生命期存在，并且返回值的生命期也存在
    // 但函数的生命期标注表示，两个入参的生命期一致，并且与返回值的生命期一致
    // 这里的代码很明显不符合函数生命期标注，而可能获取无效引用。
    // 因此，编译器拒绝编译（即使通过观察作用域，代码可以正常运行，但会造成潜在的错误）
}

编译器给出如下错误：

   Compiling playground v0.0.1 (/playground)
error[E0597]: `y` does not live long enough
  --> src/main.rs:14:23
   |
14 |         big = max(&x, &y);
   |                       ^^ borrowed value does not live long enough
15 |     }
   |     - `y` dropped here while still borrowed
16 |     println!("{}", big);
   |                    --- borrow later used here

For more information about this error, try `rustc --explain E0597`.
error: could not compile `playground` due to previous error

以下代码有效：

rust

fn first<'a, 'b>(a: &'a i32, _b: &'b i32) -> &'a i32 {
    a
}

fn main() {
    let big: &i32;
    let x = 1;
    {
        let y = 0;
        big = first(&x, &y);
    }
    println!("{}", big);
}

结构体的生命期

对于一个含有引用成员的结构体，需要满足结构体的生命期不能超过其包含的任意引用成员的生命期。（同理，否则将结构体本身将构成悬垂引用）

编译器不允许如下结构体声明，因为需要提供生命期标注：

rust

struct Foo {
  v: &i32
}

修改为：

rust

struct Foo<'a> {
  v: &'a i32
}

生命期省略

函数或方法的参数的生命期被称为输入生命期（input lifetimes），而返回值的生命期被称为输出生命期（output lifetimes）。

对于入参和返回值都是引用的函数，无需声明生命期，编译器将推断输入生命期与输出生命期相同

对于对象方法（函数的其中一个参数是 &self 或 &mut self），编译器将推断输出生命期参数等同于 self 的生命期

静态生命期 `'static`

静态生命期表示引用在整个程序期间都有效。

所有的字符串字面量都拥有 'static 生命期，即：

rust

let s: &'static str = "I have a static lifetime.";
// 完全相等，无需标注
let s: &str = "I have a static lifetime.";

可以通过 static 赋值来声明一个在整个程序期间都有效的变量

那么，这个变量的引用将有 'static 生命期

因此，以下代码有效：

rust

fn main() {
    let big: &i32;
    let x = 1;
    {
        #[allow(non_upper_case_globals)] // static 变量名应当使用大写，这里出于演示而使用小写
        static y: i32 = 0; // 需要声明类型
        big = max(&x, &y);
    } // 在这里，入参 y 的生命期一直有效
    println!("{}", big); // 函数调用有效
}

←Back to home

This work is licensed under CC BY-NC-SA 4.0