前面我们讲解了 Rust 中 所有权 和 借用 这两个重要概念，今天就接着来介绍一下，所有权系统三剑客的最后一位：生命周期。

在 Rust 中，每个变量都有严格的生命周期限定。生命周期的主要目的，是防止垂悬指针出现。

我们先来看下面一段程序：

fn main() {
    let a;

    {
        let b = 5;
        a = &b; // error: borrowed value does not live long enough
    }

    println!("{}", a);
}

当我们编译上面代码时，会出现一个异常，提示我们变量 b 的生命周期太短，不能借用给生命周期较长的变量 a。

这很容易理解，出了块级作用域，变量 b 就被销毁了，变量 a 拿到的，只是一个垂悬指针，编译器不允许这种现象发生。

如果使用一种标记来指明变量 a 和 b 的生命周期，将会是下面这样：

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

在函数体内部，变量的生命周期是可以自动推断的，一个变量的生命周期，从声明语句开始，到不再被使用时结束，我们也无需手动声明上面的 'a 和 'b。

但是，在封装一个函数时，对于函数的参数和返回值，编译器无法静态推断出它们的生命周期，这时候，我们要显式声明生命周期。

下面，我们先来试着封装一个函数，根据传递进来的两个字符串参数，返回较长的那个字符串：

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

看起来，这个函数一点毛病没有。接下来我们就来调用一下：

fn main() {
    let s1 = String::from("hey");
    let s2 = String::from("hello");
    let longest = get_longest(&s1, &s2);
    println!("{}", longest);
}

这时候我们发现，编译器给我们报了个错误，提示 get_longest() 函数的返回值是一个借用，但是缺少生命周期标识，编译器无法判断是来自哪个入参的借用：

fn get_longest(s1: &String, s2: &String) -> &String {
                   -------      -------     ^ expected named lifetime parameter

热心的编译器甚至给出了改进建议：

help: consider introducing a named lifetime parameter

fn get_longest<'a>(s1: &'a String, s2: &'a String) -> &'a String {
              ^^^^     ^^^^^^^^^^      ^^^^^^^^^^     ^^^

编译器似乎在说：你起码要告诉我，参数值都属于同一个生命周期范围吧。

你可能会觉得纳闷儿，变量 s1 和 s2 的生命周期都是一样的，难道编译器不知道吗？

编译器是知道的，但我们封装的函数，是可以在多个地方调用的，比如下面这样：

fn main() {
    let s1 = String::from("hey");

    let longest;

    {
        let s2 = String::from("hello");

        longest = get_longest(&s1, &s2);
    }

    println!("{}", longest);
}

是不是跟我们第一个例子很相似？根据我们的推断，最长的字符串是 s2，那么作为 s2 的借用，变量 longest 会成为一个垂悬指针。

所以总得给编译一些指示吧，让它根据参数的生命周期标识，来判定代码是否安全。

那我们就改造一下 get_longest() 方法，就像下面这样，在方法名后面，加入一个类似泛型的标记，并指定生命周期 'a，然后为参数和返回值都加上生命周期限定符：

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

编译顺利通过。

这个时候，你可能想问，前面的例子中，s1 和 s2 是不同的生命周期，但在 get_longest() 函数声明中，统一都使用了 'a 标记，这也能行？

实际上，编译器会替我们处理这个问题，当 s1 和 s2 的生命周期范围不同时，'a 会被解析为生命周期最小的那个范围。

这样，问题就得以解决了。编译器限定这个函数，总会返回生命周期最小的借用，如果这个借用，超出了它自己的生命周期继续使用，编译器就会及时抛出异常，提前规避风险。

如果你觉得仅使用 'a 不够精确，还可以尝试下面这种方式，为两个参数都指定自己的生命周期标识：

// 'a : 'b 表示 'a 大于或等于 'b
fn get_longest<'a, 'b>(s1: &'a String, s2: &'b String) -> &'b String where 'a : 'b {
    if s1.len() > s2.len() {
        s1
    } else {
        s2
    }
}

fn main() {
    let s1 = String::from("hey");

    {
        let s2 = String::from("hello");

        let longest = get_longest(&s1, &s2);

        println!("{}", longest);
    }
}

除了函数参数，生命周期标记也会出现在结构体定义中，帮助编译器检查每个结构体字段的生命周期，以确保不会出现垂悬指针：

struct Coord<'a, 'b> {
    x: &'a i32,
    y: &'b i32,
}

fn main() {
    let m;
    let x = 3;

    {
        let y = 5;

        let coord = Coord { x: &x, y: &y };

        println!("{}", coord.y);

        m = coord.x;
    }

    println!("{}", m);
}

最后，Rust 中还存在一个特殊的生命周期：'static，其存活周期将横跨整个程序运行期。

所有的字符串字面量都拥有 'static 生命周期，我们也可以像下面这样给它标注出来：

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

关于生命周期，就先介绍到这里了。