Rust生命周期

程序中每个变量都有一个固定的作用域，当超出变量的作用域以后，变量就会被销毁。变量在作用域中从初始化到销毁的整个过程称之为生命周期。

fn main() {  let a;       // --------------+-- a start  {            //               |    let b = 5; // -+-- b start  |  }            // -+-- b over   |}              // --------------+-- a over

生命周期与借用

rust中的借用是指对一块内存空间的引用。rust有一条借用规则是借用方的生命周期不能比出借方的生命周期还要长。

fn main() {  let a;                // -------------+-- a start  {                     //              |    let b = 5;          // -+-- b start |    a = &b;             //  |           |  }                     // -+-- b over  |  println!("a: {}", a); //              |}                       // -------------+-- a over

error[E0597]: `b` does not live long enough --> src/main.rs:5:13  |5 |         a = &b;  |             ^^ borrowed value does not live long enough6 |     };  |     - `b` dropped here while still borrowed7 |     println!("a:{}", a);  |                      - borrow later used here

fn main() {  let a = 1;            // -------------+-- a start  let b = &a;           // -------------+-- b start  println!("a: {}", a); //              |}                       // -------------+-- b, a over

函数中的生命周期参数

对于一个参数和返回值都包含引用的函数而言，该函数的参数是出借方，函数返回值所绑定到的那个变量就是借用方。所以这种函数也需要满足借用规则（借用方的生命周期不能比出借方的生命周期还要长）。那么就需要对函数返回值的生命周期进行标注，告知编译器函数返回值的生命周期信息。

fn max_num(x: &i32, y: &i32) -> &i32 {  if x > y {    &x  } else {    &y  }}
fn main() {  let x = 1;                // -------------+-- x start  let max;                  // -------------+-- max start  {                         //              |    let y = 8;              // -------------+-- y start    max = max_num(&x, &y);  //              |  }                         // -------------+-- y over  println!("max: {}", max); //              |}                           // -------------+-- max, x over

error[E0106]: missing lifetime specifier --> src/main.rs:1:33  |1 | fn max_num(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 `

函数的生命周期参数声明在函数名后的尖括号<>里，然后每个参数名跟在一个单引号'后面，多个参数用逗号隔开。如果在参数和返回值的地方需要使用生命周期进行标注时，只需要在&符号后面加上一个单引号'和之前声明的参数名即可。生命周期参数名可以是任意合法的名称。例如：

fn max_num<'a>(x: &'a i32, y: &'a i32) -> &'a i32 {  if x > y {    &x  } else {    &y  }}fn main() {  let x = 1;                // -------------+-- x start  let max;                  // -------------+-- max start  {                         //              |    let y = 8;              // -------------+-- y start    max = max_num(&x, &y);  //              |  }                         // -------------+-- y over  println!("max: {}", max); //              |}                           // -------------+-- max, x over

上面代码对函数max_num的参数和返回值的生命周期进行了标注，用于告诉编译器函数参数和函数返回值的生命周期一样长。在第13行代码对max_num进行调用时，编译器会把变量x的生命周期和变量y的生命周期与max_num函数的生命周期参数'a建立关联。这里值得注意的是，变量x和变量y的生命周期长短其实是不一样的，那么关联到max_num函数的生命周期参数'a的长度是多少呢？实际上编译器会取变量x的生命周期和变量y的生命周期重叠的部分，也就是取最短的那个变量的生命周期与'a建立关联。这里最短的生命周期是变量y，所以'a关联的生命周期就是变量y的生命周期。

error[E0597]: `y` does not live long enough  --> src/main.rs:13:27   |13 |         max = max_num(&x, &y);   |                           ^^ borrowed value does not live long enough14 |     }   |     - `y` dropped here while still borrowed15 |     println!("max: {}", max);   |                         --- borrow later used here

fn max_num<'a>(x: &'a i32, y: &'a i32) -> &'a i32 {  if x > y {    &x  } else {    &y  }}fn main() {  let x = 1;                  // -------------+-- x start  let y = 8;                  // -------------+-- y start  let max = max_num(&x, &y);  // -------------+-- max start  println!("max: {}", max);   //              |}                             // -------------+-- max, y, x over

函数存在多个生命周期参数时，需要标注各个参数之间的关系。例如：

fn max_num<'a, 'b: 'a>(x: &'a i32, y: &'b i32) -> &'a i32 {  if x > y {    &x  } else {    &y  }}fn main() {  let x = 1;                  // -------------+-- x start  let y = 8;                  // -------------+-- y start  let max = max_num(&x, &y);  // -------------+-- max start  println!("max: {}", max);   //              |}                             // -------------+-- max, y, x over

结构体中的生命周期参数

一个包含引用成员的结构体，必须保证结构体本身的生命周期不能超过任何一个引用成员的生命周期。否则就会出现成员已经被销毁之后，结构体还保持对那个成员的引用就会产生悬垂引用。所以这依旧是rust的借用规则即借用方（结构体本身）的生命周期不能比出借方（结构体中的引用成员）的生命周期还要长。因此就需要在声明结构体的同时也声明生命周期参数，同时对结构体的引用成员进行生命周期参数标注。

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

#[derive(Debug)]struct Foo<'a> {  v: &'a i32}
fn main() {  let foo;                    // -------------+-- foo start  {                           //              |    let v = 123;              // -------------+-- v start    foo = Foo {               //              |      v: &v                   //              |    }                         //              |  }                           // -------------+-- v over  println!("foo: {:?}", foo); //              |}                             // -------------+-- foo over

上面代码的第14行到15行foo的生命周期依然没有结束，但是它所引用的变量v已经被销毁了，因此出现了悬垂引用。编译器会给出报错提示：变量v的的生命周期不够长。

静态生命周期参数

有一个特殊的生命周期参数叫static，它的生命周期是整个应用程序。跟其他生命周期参数不同的是，它是表示一个具体的生命周期长度，而不是泛指。static生命周期的变量存储在静态段中。

let s: &'static str = "codercat is a static lifetime.";

let s: &str = "codercat is a static lifetime.";

static V: i32 = 123;

fn max_num<'a>(x: &'a i32, y: &'a i32) -> &'a i32 {  if x > y {    &x  } else {    &y  }}fn main() {  let x = 1;                // -------------+-- x start  let max;                  // -------------+-- max start  {                         //              |    static Y: i32 = 8;      // -------------+-- Y start    max = max_num(&x, &Y);  //              |  }                         //              |  println!("max: {}", max); //              |}                           // -------------+-- max, Y, x over

总结