0
0

【Rust】——生命周期

🎃个人专栏：

🐬 算法设计与分析：算法设计与分析_IT闫的博客-CSDN博客

🐳Java基础：Java基础_IT闫的博客-CSDN博客

🐋c语言：c语言_IT闫的博客-CSDN博客

🐟MySQL：数据结构_IT闫的博客-CSDN博客

🐠数据结构：​​​​​​数据结构_IT闫的博客-CSDN博客

💎C++：C++_IT闫的博客-CSDN博客

🥽C51单片机：C51单片机（STC89C516）_IT闫的博客-CSDN博客

💻基于HTML5的网页设计及应用：基于HTML5的网页设计及应用_IT闫的博客-CSDN博客​​​​​​

🥏python：python_IT闫的博客-CSDN博客

🐠离散数学：离散数学_IT闫的博客-CSDN博客

​​​​​​🥽Linux：​​​​Linux_Y小夜的博客-CSDN博客

🚝Rust：Rust_Y小夜的博客-CSDN博客

欢迎收看，希望对大家有用！

🎯生命周期

    Rust 中的每一个引用都有其 **生命周期**（*lifetime*），也就是引用保持有效的作用域。大部分时候生命周期是隐含并可以推断的，正如大部分时候类型也是可以推断的一样。

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

🎯生命周期避免了悬垂引用

fn main() {
    let r;

    {
        let x = 5;
        r = &x;
    }

    println!("r: {}", r);
}

    外部作用域声明了一个没有初值的变量 

r

，而内部作用域声明了一个初值为 5 的变量

x

。在内部作用域中，我们尝试将 

r

的值设置为一个 

x

的引用。接着在内部作用域结束后，尝试打印出 

r

的值。这段代码不能编译因为 

r

引用的值在尝试使用之前就离开了作用域。

    变量 

x

并没有 “存在的足够久”。其原因是 

x

在到达第 7 行内部作用域结束时就离开了作用域。不过 

r

在外部作用域仍是有效的；作用域越大我们就说它 “存在的越久”。如果 Rust 允许这段代码工作，

r

将会引用在 

x

离开作用域时被释放的内存，这时尝试对 

r

做任何操作都不能正常工作。那么 Rust 是如何决定这段代码是不被允许的呢？这得益于借用检查器。

🎃借用检查器

    Rust 编译器有一个 **借用检查器**（*borrow checker*），它比较作用域来确保所有的借用都是有效的。

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

    这里将 

r

的生命周期标记为 

'a

并将 

x

的生命周期标记为 

'b

。如你所见，内部的 

'b

块要比外部的生命周期 

'a

小得多。在编译时，Rust 比较这两个生命周期的大小，并发现 

r

拥有生命周期 

'a

，不过它引用了一个拥有生命周期 

'b

的对象。程序被拒绝编译，因为生命周期 

'b

比生命周期 

'a

要小：被引用的对象比它的引用者存在的时间更短。

🎯函数中的泛型生命周期

    编写一个返回两个字符串 slice 中较长者的函数。这个函数获取两个字符串 slice 并返回一个字符串 slice。一旦我们实现了 

longest

函数

fn main() {
    let string1 = String::from("abcd");
    let string2 = "xyz";

    let result = longest(string1.as_str(), string2);
    println!("The longest string is {}", result);
}

    这个函数获取作为引用的字符串 slice，而不是字符串，因为我们不希望 

longest

函数获取参数的所有权。

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

    会出现有关生命周期的错误：返回值需要一个泛型生命周期参数，因为 Rust 并不知道将要返回的引用是指向 

x

或 

y

。事实上我们也不知道，因为函数体中 

if

块返回一个 

x

的引用而 

else

块返回一个 

y

的引用！

    当我们定义这个函数的时候，并不知道传递给函数的具体值，所以也不知道到底是 

if

还是 

else

会被执行。我们也不知道传入的引用的具体生命周期，所以也就不能像示例 那样通过观察作用域来确定返回的引用是否总是有效。借用检查器自身同样也无法确定，因为它不知道 

x

和 

y

的生命周期是如何与返回值的生命周期相关联的。为了修复这个错误，我们将增加泛型生命周期参数来定义引用间的关系以便借用检查器可以进行分析。

🎯生命周期注解语法

    生命周期注解并不改变任何引用的生命周期的长短。相反它们描述了多个引用生命周期相互的关系，而不影响其生命周期。与当函数签名中指定了泛型类型参数后就可以接受任何类型一样，当指定了泛型生命周期后函数也能接受任何生命周期的引用。

    生命周期注解有着一个不太常见的语法：生命周期参数名称必须以**撇号（

'

）**开头，其名称通常全是小写，类似于泛型其名称非常短。大多数人使用 

'a

作为第一个生命周期注解。生命周期参数**注解位于引用的 

&

之后，并有一个空格来将引用类型与生命周期注解分隔开。**

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

   ** 单个的生命周期注解本身没有多少意义**，因为生命周期注解告诉 Rust 多个引用的泛型生命周期参数如何相互联系的。让我们在 

longest

函数的上下文中理解生命周期注解如何相互联系。

🎯函数签名中的生命周期注解

    为了在函数签名中使用生命周期注解，需要在函数名和参数列表间的尖括号中声明泛型**生命周期（*lifetime*）**参数，就像泛型**类型（*type*）参数**一样。

    我们希望函数签名表达如下限制：也就是这两个参数和返回的引用存活的一样久。（两个）参数和返回的引用的生命周期是相关的。

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

    现在函数签名表明对于某些生命周期 

'a

，函数会获取两个参数，它们都是与生命周期 

'a

存在的一样长的字符串 slice。函数会返回一个同样也与生命周期 

'a

存在的一样长的字符串 slice。它的实际含义是 

longest

函数返回的引用的生命周期与函数参数所引用的值的生命周期的较小者一致。这些关系就是我们希望 Rust 分析代码时所使用的。

    记住通过在函数签名中指定生命周期参数时，我们**并没有改变任何传入值或返回值的生命周期**，而是指出任何不满足这个约束条件的值都将被借用检查器拒绝。注意 

longest

函数并不需要知道 

x

和 

y

具体会存在多久，而只需要知道有某个可以被 

'a

替代的作用域将会满足这个签名。

🎯深入理解生命周期

指定生命周期参数的正确方式依赖函数实现的具体功能。

fn longest<'a>(x: &'a str, y: &str) -> &'a str {
    x
}

    我们为参数 

x

和返回值指定了生命周期参数 

'a

，不过没有为参数 

y

指定，因为 

y

的生命周期与参数 

x

和返回值的生命周期没有任何关系。

    当从函数返回一个引用，返回值的生命周期参数需要与一个参数的生命周期参数相匹配。如果返回的引用 **没有** 指向任何一个参数，那么唯一的可能就是它指向一个函数内部创建的值。然而它将会是一个悬垂引用，因为它将会在函数结束时离开作用域。尝试考虑这个并不能编译的 

longest

函数实现：

fn longest<'a>(x: &str, y: &str) -> &'a str {
    let result = String::from("really long string");
    result.as_str()
}

    出现的问题是 

result

在 

longest

函数的结尾将离开作用域并被清理，而我们尝试从函数返回一个 

result

的引用。无法指定生命周期参数来改变悬垂引用，而且 Rust 也不允许我们创建一个悬垂引用。在这种情况，最好的解决方案是返回一个有所有权的数据类型而不是一个引用，这样函数调用者就需要负责清理这个值了。

    **综上，生命周期语法是用于将函数的多个参数与其返回值的生命周期进行关联的。一旦它们形成了某种关联，Rust 就有了足够的信息来允许内存安全的操作并阻止会产生悬垂指针亦或是违反内存安全的行为。**

🎯结构体定义中的生命周期标注

    目前为止，我们定义的结构体全都包含拥有所有权的类型。也可以定义包含引用的结构体，不过这需要为结构体定义中的每一个引用添加生命周期注解。

struct ImportantExcerpt<'a> {
    part: &'a str,
}

fn main() {
    let novel = String::from("Call me Ishmael. Some years ago...");
    let first_sentence = novel.split('.').next().expect("Could not find a '.'");
    let i = ImportantExcerpt {
        part: first_sentence,
    };
}

    这个结构体有唯一一个字段 

part

，它存放了一个字符串 slice，这是一个引用。类似于泛型参数类型，必须在结构体名称后面的尖括号中声明泛型生命周期参数，以便在结构体定义中使用生命周期参数。

🎯生命周期的省略

fn first_word(s: &str) -> &str {
    let bytes = s.as_bytes();

    for (i, &item) in bytes.iter().enumerate() {
        if item == b' ' {
            return &s[0..i];
        }
    }

    &s[..]
}

    这个函数没有生命周期注解却能编译是由于一些历史原因：在早期版本（pre-1.0）的 Rust 中，这的确是不能编译的。每一个引用都必须有明确的生命周期。那时的函数签名将会写成这样：

fn first_word<'a>(s: &'a str) -> &'a str {

    被编码进 Rust 引用分析的模式被称为 **生命周期省略规则**（*lifetime elision rules*）。这并不是需要程序员遵守的规则；这些规则是一系列特定的场景，此时编译器会考虑，如果代码符合这些场景，就无需明确指定生命周期。

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

🎃生命周期省略的三个规则

   ** 编译器采用三条规则来判断引用何时不需要明确的注解。第一条规则适用于输入生命周期，后两条规则适用于输出生命周期。**如果编译器检查完这三条规则后仍然存在没有计算出生命周期的引用，编译器将会停止并生成错误。这些规则适用于 

fn

定义，以及 

impl

块。

    **第一条规则是编译器为每一个引用参数都分配一个生命周期参数。**换句话说就是，函数有一个引用参数的就有一个生命周期参数：

fn foo<'a>(x: &'a i32)

，有两个引用参数的函数就有两个不同的生命周期参数，

fn foo<'a, 'b>(x: &'a i32, y: &'b i32)

，依此类推。

    **第二条规则是如果只有一个输入生命周期参数，那么它被赋予所有输出生命周期参数**：

fn foo<'a>(x: &'a i32) -> &'a i32

。

  **  第三条规则是如果方法有多个输入生命周期参数并且其中一个参数是 

&self

或 

&mut self

，说明是个对象的方法 **，那么所有输出生命周期参数被赋予 

self

的生命周期。第三条规则使得方法更容易读写，因为只需更少的符号。

🎯方法定义中的生命周期

    （实现方法时）结构体字段的生命周期必须总是在 

impl

关键字之后声明并在结构体名称之后被使用，因为这些生命周期是结构体类型的一部分。

   impl

块里的方法签名中，引用可能与结构体字段中的引用相关联，也可能是独立的。另外，生命周期省略规则也经常让我们无需在方法签名中使用生命周期注解。

impl<'a> ImportantExcerpt<'a> {
    fn level(&self) -> i32 {
        3
    }
}

  impl

之后和类型名称之后的生命周期参数是必要的，不过因为第一条生命周期规则我们并不必须标注 

self

引用的生命周期。

impl<'a> ImportantExcerpt<'a> {
    fn announce_and_return_part(&self, announcement: &str) -> &str {
        println!("Attention please: {}", announcement);
        self.part
    }
}

这里有两个输入生命周期，所以 Rust 应用第一条生命周期省略规则并给予 

&self

和 

announcement

它们各自的生命周期。接着，因为其中一个参数是 

&self

，返回值类型被赋予了 

&self

的生命周期，这样所有的生命周期都被计算出来了。

🎯静态生命周期

    这里有一种特殊的生命周期值得讨论：

'static

，其生命周期能够存活于整个程序期间。所有的字符串字面值都拥有 

'static

生命周期，我们也可以选择像下面这样标注出来

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

    这个字符串的文本被直接储存在程序的二进制文件中而这个文件总是可用的。因此所有的字符串字面值都是 

'static

的。

    你可能在错误信息的帮助文本中见过使用 

'static

生命周期的建议，不过将引用指定为 

'static

之前，思考一下这个引用是否真的在整个程序的生命周期里都有效，以及你是否希望它存在得这么久。大部分情况中，推荐 

'static

生命周期的错误信息都是尝试创建一个悬垂引用或者可用的生命周期不匹配的结果。在这种情况下的解决方案是修复这些问题而不是指定一个 

'static

的生命周期。

🎯泛型参数类型、Trait Bound、生命周期

use std::fmt::Display;

fn longest_with_an_announcement<'a, T>(
    x: &'a str,
    y: &'a str,
    ann: T,
) -> &'a str
where
    T: Display,
{
    println!("Announcement! {}", ann);
    if x.len() > y.len() {
        x
    } else {
        y
    }
}

    这个是示例中那个返回两个字符串 slice 中较长者的 

longest

函数，不过带有一个额外的参数 

ann

。

ann

的类型是泛型 

T

，它可以被放入任何实现了 

where

从句中指定的 

Display

trait 的类型。这个额外的参数会使用 

{}

打印，这也就是为什么 

Display

trait bound 是必须的。因为生命周期也是泛型，所以生命周期参数 

'a

和泛型类型参数 

T

都位于函数名后的同一尖括号列表中。

标签： rust 开发语言 后端
本文转载自: https://blog.csdn.net/shsjssnn/article/details/136372569
版权归原作者 Y小夜 所有， 如有侵权，请联系我们删除。
登录后发布评论

“【Rust】——生命周期”的评论:

还没有评论
关于作者
...
overfit同步小助手
文章同步
相关阅读

落实算法安全主体责任：全面保障算法合规与安全

Hadoop生态圈框架部署（四）- Hadoop完全分布式部署

毕设项目 基于大数据的b站数据分析

【前端】Bootstrap：栅格系统 (Grid System)

docker部署rustdesk

【PostgreSQL】实战篇——用户管理、角色和权限控制的高级用法及技巧

AI时代：弯道超车的新思维与实践路径

文章导航