[Rust]生命周期

简介

一个变量的生命周期就是变量从创建到销毁的整个过程，Rust中主要是通过大花括号的范围控制和计算生命周期。

fn main() {
    let a = vec![1,2,3];    // a的生命周期开始
    {
        let b = v[0];             // b的生命周期开始
        println!("{}", b);
    }                             // b的生命周期结束
    println!("{:?}", a);
}                           // a的生命周期结束

生命周期标识符

对函数内部生命周期分析很容易，但如果涉及跨函数生命周期（主要是借用），编译器需要生命周期标识，而此时，生命周期标记经常是不好理解的，而且很容易引起混乱。

语法

1. 标识符语法
   针对借用和可变借用语法如下：
   单引号开头，后跟合法的名字

&i32 => &'a i32
&mut i32 => &'a mut i32

2. 包含关系
   如果生命周期'a大于等于'b，那可以写为'a: 'b
3. 'static
   特殊生命周期标识符，代表这个变量的生命周期是从整个程序开始到结束

生命周期标识规则

生命周期标识符和泛型类型参数是一样的，都需要先声明后使用。
1. 只有借用才需要生命周期标识符
函数入参存在借用，且返回值为借用
2. 在函数中，生命周期标识符是映射输入（入参）到输出（返回值）

• 如果返回值不是借用指针，即使入参有多个借用指针（编译器不会自动补充生命周期标识符），也可以完全不用生命周期标识符

fn main() {
    let x1: i32 = 20;
    let x2: i32 = 10;
    println!("sum: {}", sum(&x1, &x2));
}

fn sum(x: &i32, y: &i32) -> i32 {
    *x + *y
}

• 如果入参有多个借用，且返回值类型也是借用，只需要给会影响返回值的入参加生命周期标识符

fn main() {
    let x1: i32 = 10;
    let x2: i32 = 20;
    let x3: i32 = 30;

    println!("which is bigger? {}", bigger(&x1, &x2, &x3));
}

fn bigger<'a>(x: &'a i32, y: &'a i32, z: &i32) -> &'a i32
{
    println!("z is not affecting return value: {}", z);
    if x >= y {
        x
    } else {
        y
    }
}

生命周期自动补全规则

某些场景下，编译器可以自动补全生命周期标识符，即代码中可以省略生命周期标识符。但是，自动补全有时会导致编译不通过

• 每个带生命周期参数的输入参数，对应不同的生命周期参数；
• 如果只有一个输入参数带生命周期参数，那么返回值的生命周期被指定为这个参数；
• 如果有多个输入参数带生命周期参数，但其中有&self或者&mut self，那么返回值的生命周期被指定为这个参数；
• 以上都不满足，就不能自动补全返回值的生命周期参数。

常见错误

1. xxx does not live long enough

fn main() {
    let a;                // a生命周期开始
    {
        let b = 5;   // b生命周期开始
        a = &b;
    }                // b生命周期结束
    println!("{}", a);
}                        // a生命周期结束

编译器错误信息显示了详细错误原因， b销毁之后，a还有b的引用。

  |
5 |         a = &b;
  |             ^^ borrowed value does not live long enough
6 |     }
  |     - `b` dropped here while still borrowed
7 |     println!("{}", a);
  |                    - borrow later used here

2. missing lifetime specifier

fn main() {
    let x1: i32 = 10;
    let x2: i32 = 20;
    println!("which is bigger? {}", bigger(&x1, &x2));
}

fn bigger(x: &i32, y: &i32) -> &i32 {
    if x >= y {
        x
    } else {
        y
    }
}

编译器错误信息显示了详细错误原因，当有多个入参是引用类型且返回值类型也是引用类型，必须显式声明生命周期标识符。

  |
7 | fn bigger(x: &i32, y: &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 `x` or `y`
help: consider introducing a named lifetime parameter
  |
7 | fn bigger<'lifetime>(x: &i32, y: &i32) -> &'lifetime i32 {
  |          ^^^^^^^^^^^                      ^^^^^^^^^^

3. lifetime mismatch

fn bigger<'a, 'b>(x: &'a i32, y: &'b i32) -> &'a i32
where 'a: 'b
{
    if x >= y {
        x
    } else {
        y
    }
}

此处返回值的生命周期标识符大于入参y的生命周期

   |
16 | fn bigger<'a, 'b>(x: &'a i32, y: &'b i32) -> &'a i32
   |                      -------     ------- these two types are declared with different lifetimes...
...
22 |         y
   |         ^ ...but data from `y` flows into `x` here

修复方法：修改返回值生命周期标识符

fn bigger<'a, 'b>(x: &'a i32, y: &'b i32) -> &'b i32
where 'a: 'b
{
    if x >= y {
        x
    } else {
        y
    }
}