Rust 泛型、Trait 和生命周期

本文在原文基础上有删减，原文参考泛型、Trait 和生命周期。

目录

• 泛型数据类型
  
  
  
  • 在函数定义中使用泛型
    
  • 结构体定义中的泛型
    
  • 枚举定义中的泛型
    
  • 方法定义中的泛型
    
  • 泛型代码的性能
    
  
  
• Trait：定义共同行为
  
  
  
  • 定义 trait
    
  • 为类型实现 trait
    
  • 默认实现
    
  • trait 作为参数
    
    
    
    • Trait Bound 语法
      
    • 通过 + 指定多个 trait bound
      
    • 通过 where 简化 trait bound
      
    
    
  • 返回实现了 trait 的类型
    
  • 使用 trait bound 有条件地实现方法
    
  
  
• 生命周期确保引用有效
  
  
  
  • 生命周期避免了悬垂引用
    
    
    
    • 借用检查器
      
    
    
  • 函数中的泛型生命周期
    
  • 生命周期注解语法
    
  • 函数签名中的生命周期注解
    
  • 深入理解生命周期
    
  • 结构体定义中的生命周期注解
    
  • 生命周期省略（Lifetime Elision）
    
  • 方法定义中的生命周期注解
    
  • 静态生命周期
    
  • 结合泛型类型参数、trait bounds 和生命周期
    
  
  

泛型数据类型

可以使用泛型为像函数签名或结构体这样的项创建定义，这样它们就可以用于多种不同的具体数据类型。
在函数定义中使用泛型

当使用泛型定义函数时，本来在函数签名中指定参数和返回值的类型的地方，会改用泛型来表示。
两个函数都是寻找 slice 中最大值，不同点只是名称和签名类型：

1. fn largest_i32(list: &[i32]) -> &i32 {
2.     let mut largest = &list[0];
4.     for item in list {
5.         if item > largest {
6.             largest = item;
7.         }
8.     }
10.     largest
11. }
13. fn largest_char(list: &[char]) -> &char {
14.     let mut largest = &list[0];
16.     for item in list {
17.         if item > largest {
18.             largest = item;
19.         }
20.     }
22.     largest
23. }
25. fn main() {
26.     let number_list = vec![34, 50, 25, 100, 65];
28.     let result = largest_i32(&number_list);
29.     println!("The largest number is {}", result);
31.     let char_list = vec!['y', 'm', 'a', 'q'];
33.     let result = largest_char(&char_list);
34.     println!("The largest char is {}", result);
35. }

复制代码

为了定义泛型版本的 largest 函数，类型参数声明位于函数名称与参数列表中间的尖括号  中，像这样：

1. fn largest<T>(list: &[T]) -> &T {

复制代码

一个使用泛型参数的 largest 函数定义：

1. //函数 largest 有泛型类型 T，//有个参数 list，其类型是元素为 T 的 slice//largest 函数会返回一个与 T 相同类型的引用fn largest<T>(list: &[T]) -> &T {    let mut largest = &list[0];    for item in list {        if item > largest {            largest = item;        }    }    largest}fn main() {    //标准库为 i32 和 char 实现了 PartialOrd    let number_list = vec![34, 50, 25, 100, 65];    let result = largest(&number_list);    println!("The largest number is {}", result);    let char_list = vec!['y', 'm', 'a', 'q'];    let result = largest(&char_list);    println!("The largest char is {}", result);}

复制代码

为了开启比较功能，标准库中定义的 std::cmp:artialOrd trait 可以实现类型的比较功能，限制 T 只对实现了 PartialOrd 的类型有效否则代码会编译错误。
结构体定义中的泛型

可以用  语法来定义结构体，它包含一个或多个泛型参数类型字段。
Point 结构体存放了两个 T 类型的值 x 和 y：

1. struct Point<T> {
2.     x: T,
3.     y: T,
4. }
6. fn main() {
7.     let integer = Point { x: 5, y: 10 };
8.     let float = Point { x: 1.0, y: 4.0 };
9. }

复制代码

字段 x 和 y 的类型必须相同，因为它们都有相同的泛型类型 T：

1. struct Point<T> {
2.     x: T,
3.     y: T,
4. }
6. fn main() {
7.     //代码不能编译
8.     let wont_work = Point { x: 5, y: 4.0 };
9. }

复制代码

使用两个泛型的 Point，x 和 y 可以是不同类型

1. struct Point<T, U> {
2.     x: T,
3.     y: U,
4. }
6. fn main() {
7.     let both_integer = Point { x: 5, y: 10 };
8.     let both_float = Point { x: 1.0, y: 4.0 };
9.     let integer_and_float = Point { x: 5, y: 4.0 };
10. }

复制代码

可以在定义中使用任意多的泛型类型参数，不过太多的话代码将难以阅读和理解。当代码中需要很多泛型时，这表明代码需要重构分解成更小的结构。
枚举定义中的泛型

枚举也可以在成员中存放泛型数据类型，如 Option 枚举：

1. enum Option<T> {
2.     Some(T),
3.     None,
4. }

复制代码

枚举也可以拥有多个泛型类型，如 Result 枚举：

1. enum Result<T, E> {
2.     Ok(T),
3.     Err(E),
4. }

复制代码

Result 有两个成员：Ok，它存放一个类型 T 的值，而 Err 则存放一个类型 E 的值。
方法定义中的泛型

在为结构体和枚举实现方法时，一样也可以用泛型。在 Point 结构体上实现方法 x，它返回 T 类型的字段 x 的引用：

1. struct Point<T> {
2.     x: T,
3.     y: T,
4. }
5. //必须在 impl 后面声明 T，可以选择不同的名称
6. impl<T> Point<T> {
7.     fn x(&self) -> &T {
8.         &self.x
9.     }
10. }
12. fn main() {
13.     let p = Point { x: 5, y: 10 };
15.     println!("p.x = {}", p.x());
16. }

复制代码

定义方法时也可以为泛型指定限制（constraint），构建一个只用于拥有泛型参数 T 的结构体的具体类型的 impl 块：

1. //其他 T 不是 f32 类型的 Point<T> 实例没有定义此方法
2. impl Point<f32> {
3.     fn distance_from_origin(&self) -> f32 {
4.         (self.x.powi(2) + self.y.powi(2)).sqrt()
5.     }
6. }

复制代码

结构体定义中的泛型类型参数并不总是与结构体方法签名中使用的泛型是同一类型，以下方法使用了与结构体定义中不同类型的泛型：

1. struct Point<X1, Y1> {
2.     x: X1,
3.     y: Y1,
4. }
5. //用 self 的 Point 类型的 x 值（类型 X1）和参数的 Point 类型的 y 值（类型 Y2）来创建一个新 Point 类型的实例
6. impl<X1, Y1> Point<X1, Y1> {
7.     fn mixup<X2, Y2>(self, other: Point<X2, Y2>) -> Point<X1, Y2> {
8.         Point {
9.             x: self.x,
10.             y: other.y,
11.         }
12.     }
13. }
15. fn main() {
16.     let p1 = Point { x: 5, y: 10.4 };
17.     let p2 = Point { x: "Hello", y: 'c' };
19.     //p3拥有一个 i32 类型的 x，因为 x 来自 p1
20.     //p3拥有一个 char 类型的 y，因为 y 来自 p2
21.     let p3 = p1.mixup(p2);
23.     //会打印出 p3.x = 5, p3.y = c
24.     println!("p3.x = {}, p3.y = {}", p3.x, p3.y);
25. }

复制代码

泛型代码的性能

Rust 通过在编译时进行泛型代码的 单态化（monomorphization）来保证效率。单态化是一个通过填充编译时使用的具体类型，将通用代码转换为特定代码的过程。在这个过程中，编译器寻找所有泛型代码被调用的位置并使用泛型代码针对具体类型生成代码。
标准库中的 Option 枚举：

1. let integer = Some(5);
2. let float = Some(5.0);

复制代码

编译器生成的单态化版本的代码类如下（命名可能不同）：

1. enum Option_i32 {
2.     Some(i32),
3.     None,
4. }
6. enum Option_f64 {
7.     Some(f64),
8.     None,
9. }
11. fn main() {
12.     let integer = Option_i32::Some(5);
13.     let float = Option_f64::Some(5.0);
14. }

复制代码

Rust 会将每种情况下的泛型代码编译为具体类型，使用泛型没有运行时开销。、
Trait：定义共同行为

trait 定义了某个特定类型拥有可能与其他类型共享的功能，可以通过 trait 以一种抽象的方式定义共同行为，可以使用 trait bounds 指定泛型是任何拥有特定行为的类型。

注意：trait 类似于其他语言中的常被称为 接口（interfaces）的功能，虽然有一些不同。

定义 trait

Summary trait 定义，它包含由 summarize 方法提供的行为：

1. //声明 trait 为 pub 以便依赖这个 crate 的 crate 也可以使用这个 trait
2. pub trait Summary {
3.     //声明描述实现这个 trait 的类型所需要的行为的方法签名
4.     fn summarize(&self) -> String;
5. }

复制代码

trait 体中可以有多个方法：一行一个方法签名且都以分号结尾。
为类型实现 trait

在 NewsArticle 和 Tweet 类型上实现 Summary trait：

1. pub struct NewsArticle {
2.     pub headline: String,
3.     pub location: String,
4.     pub author: String,
5.     pub content: String,
6. }
8. impl Summary for NewsArticle {
9.     fn summarize(&self) -> String {
10.         //使用标题、作者和创建的位置作为返回值
11.         format!("{}, by {} ({})", self.headline, self.author, self.location)
12.     }
13. }
15. pub struct Tweet {
16.     pub username: String,
17.     pub content: String,
18.     pub reply: bool,
19.     pub retweet: bool,
20. }
22. impl Summary for Tweet {
23.     fn summarize(&self) -> String {
24.         //用户名后跟推文的全部文本作为返回值
25.         format!("{}: {}", self.username, self.content)
26.     }
27. }

复制代码

trait 必须和类型一起引入作用域以便使用额外的 trait 方法：

1. use aggregator::{Summary, Tweet};
3. fn main() {
4.     let tweet = Tweet {
5.         // 初始化 Tweet 实例...
6.     };
8.     println!("1 new tweet: {}", tweet.summarize());
9. }

复制代码

需要注意的限制是，只有在 trait 或类型至少有一个属于当前 crate 时才能对类型实现该 trait，不能为外部类型实现外部 trait。
这个限制是被称为 相干性（coherence）的程序属性的一部分，或者更具体的说是 孤儿规则（orphan rule），其得名于不存在父类型。
默认实现

有时为 trait 中的某些或全部方法提供默认的行为，而不是在每个类型的每个实现中都定义自己的行为是很有用的。
Summary trait 的定义，带有一个 summarize 方法的默认实现：

1. pub trait Summary {
2.     fn summarize(&self) -> String {
3.         String::from("(Read more...)")
4.     }
5. }

复制代码

想要对 NewsArticle 实例使用这个默认实现，可以通过 impl Summary for NewsArticle {} 指定一个空的 impl 块，然后对 NewsArticle 实例调用 summarize 方法：

1. let article = NewsArticle {
2.     // 初始化 NewsArticle 实例...
3. };
4. //会打印 New article available! (Read more...)
5. println!("New article available! {}", article.summarize());

复制代码

默认实现允许调用相同 trait 中的其他方法，哪怕这些方法没有默认实现，重新定义 Summary trait：

1. pub trait Summary {
2.     //一个需要实现的 summarize_author 方法
3.     fn summarize_author(&self) -> String;
4.     //此方法的默认实现调用 summarize_author 方法
5.     fn summarize(&self) -> String {
6.         format!("(Read more from {}...)", self.summarize_author())
7.     }
8. }

复制代码

只需在实现 trait 时定义 summarize_author 即可：

1. impl Summary for Tweet {
2.     fn summarize_author(&self) -> String {
3.         format!("@{}", self.username)
4.     }
5. }

复制代码

一旦定义了 summarize_author 就可以对 Tweet 结构体的实例调用 summarize 了：

1. let tweet = Tweet {
2.     username: String::from("horse_ebooks"),
3.     content: String::from(
4.         "of course, as you probably already know, people",
5.     ),
6.     reply: false,
7.     retweet: false,
8. };
9. //会打印出 1 new tweet: (Read more from @horse_ebooks...)
10. println!("1 new tweet: {}", tweet.summarize());

复制代码

trait 作为参数

定义一个函数 notify 来调用其参数 item 上的 summarize 方法，该参数是实现了 Summary trait 的某种类型:

1. //使用 impl Trait 语法
2. pub fn notify(item: &impl Summary) {
3.     println!("Breaking news! {}", item.summarize());
4. }

复制代码

item 参数指定了 impl 关键字和 trait 名称，而不是具体的类型，该参数支持任何实现了指定 trait 的类型。
Trait Bound 语法

impl Trait 语法实际上是一种较长形式语法的语法糖，称为 trait bound：

1. pub fn notify<T: Summary>(item: &T) {
2.     println!("Breaking news! {}", item.summarize());
3. }

复制代码

impl Trait 适用于短小的例子，更长的 trait bound 则适用于更复杂的场景：

• item1 和 item2 允许是不同类型的情况：
  

1. pub fn notify(item1: &impl Summary, item2: &impl Summary) {

复制代码

• item1 和 item2 值的具体类型必须一致的情况：
  

1. pub fn notify<T: Summary>(item1: &T, item2: &T) {

复制代码

通过 + 指定多个 trait bound

如果 item 需要同时实现两个不同的 trait：Display 和 Summary，可以通过 + 语法实现：

1. pub fn notify(item: &(impl Summary + Display)) {

复制代码

• 语法也适用于泛型的 trait bound：
  

1. pub fn notify<T: Summary + Display>(item: &T) {

复制代码

通过指定这两个 trait bound，notify 的函数体可以调用 summarize 并使用 {} 来格式化 item。
通过 where 简化 trait bound

过多的 trait bound 使得函数签名难以阅读：

1. fn some_function<T: Display + Clone, U: Clone + Debug>(t: &T, u: &U) -> i32 {

复制代码

Rust 有另一个在函数签名之后的 where 从句中指定 trait bound 的语法：

1. fn some_function<T, U>(t: &T, u: &U) -> i32
2. where
3.     T: Display + Clone,
4.     U: Clone + Debug,
5. {

复制代码

返回实现了 trait 的类型

在返回值中使用 impl Trait 语法来返回实现了某个 trait 的类型：

1. fn returns_summarizable() -> impl Summary {
2.     Tweet {
3.         username: String::from("horse_ebooks"),
4.         content: String::from(
5.             "of course, as you probably already know, people",
6.         ),
7.         reply: false,
8.         retweet: false,
9.     }
10. }

复制代码

不过这只适用于返回单一类型的情况，尝试返回 NewsArticle 或 Tweet 会编译错误：

1. fn returns_summarizable(switch: bool) -> Summarizable {
2.     if switch {
3.         Summarizable::NewsArticle(NewsArticle {
4.             // 初始化 NewsArticle 实例...
5.         })
6.     } else {
7.         Summarizable::Tweet(Tweet {
8.             // 初始化 Tweet 实例...
9.         })
10.     }
11. }

复制代码

使用 trait bound 有条件地实现方法

通过使用带有 trait bound 的泛型参数的 impl 块，可以有条件地只为那些实现了特定 trait 的类型实现方法。
根据 trait bound 在泛型上有条件的实现方法:

1. use std::fmt::Display;
3. struct Pair<T> {
4.     x: T,
5.     y: T,
6. }
8. impl<T> Pair<T> {
9.     fn new(x: T, y: T) -> Self {
10.         Self { x, y }
11.     }
12. }
13. //只有那些为 T 类型实现了 PartialOrd trait（来允许比较） 和 Display trait（来启用打印）的 Pair<T> 才会实现 cmp_display 方法
14. impl<T: Display + PartialOrd> Pair<T> {
15.     fn cmp_display(&self) {
16.         if self.x >= self.y {
17.             println!("The largest member is x = {}", self.x);
18.         } else {
19.             println!("The largest member is y = {}", self.y);
20.         }
21.     }
22. }

复制代码

对任何满足特定 trait bound 的类型实现 trait 被称为 blanket implementations，如标准库为任何实现了 Display trait 的类型实现了 ToString trait：

1. impl<T: Display> ToString for T {
2.     // --snip--
3.     // to_string 方法
4. }
5. ```rust
6. 整型实现了 Display：
7. ```rust
8. let s = 3.to_string();

复制代码

生命周期确保引用有效

Rust 中的每一个引用都有其 生命周期（lifetime），也就是引用保持有效的作用域。大部分时候生命周期是隐含并可以推断的，也会出现引用的生命周期以一些不同方式相关联的情况，所以 Rust 需要我们使用泛型生命周期参数来注明它们的关系。
生命周期避免了悬垂引用

生命周期的主要目标是避免悬垂引用（dangling references），后者会导致程序引用了非预期引用的数据。
尝试使用离开作用域的值的引用，代码会编译错误：

1. fn main() {
2.     let r;
3.     //如果尝试在给它一个值之前使用这个变量会出现一个编译时错误，Rust 不允许空值。
5.     {
6.         let x = 5;
7.         r = &x;
8.     }
9.    
10.     // 编译错误，r 引用的值在尝试使用之前就离开了作用域
11.     println!("r: {}", r);
12. }

复制代码

借用检查器

Rust 编译器有一个 借用检查器（borrow checker），它比较作用域来确保所有的借用都是有效的。
r 和 x 的生命周期注解，分别叫做 'a 和 'b：

1. fn main() {
2.     let r;                // ---------+-- 'a
3.                           //          |
4.     {                     //          |
5.         let x = 5;        // -+-- 'b  |
6.         r = &x;           //  |       |
7.     }                     // -+       |
8.                           //          |
9.     println!("r: {}", r); //          |
10. }                         // ---------+

复制代码

在编译时，Rust 比较这两个生命周期的大小，并发现 r 拥有生命周期 'a，不过它引用了一个拥有生命周期 'b 的对象。程序被拒绝编译，因为生命周期 'b 比生命周期 'a 要小：被引用的对象比它的引用者存在的时间更短。
一个有效的引用，因为数据比引用有着更长的生命周期：

1. fn main() {
2.     let x = 5;            // ----------+-- 'b
3.                           //           |
4.     let r = &x;           // --+-- 'a  |
5.                           //   |       |
6.     println!("r: {}", r); //   |       |
7.                           // --+       |
8. }                         // ----------+

复制代码

这里 x 拥有生命周期 'b，比 'a 要大，这就意味着 r 可以引用 x：Rust 知道 r 中的引用在 x 有效的时候也总是有效的。
函数中的泛型生命周期

main 函数调用 longest 函数来寻找两个字符串 slice 中较长的一个：

1. fn main() {
2.     let string1 = String::from("abcd");
3.     let string2 = "xyz";
5.     let result = longest(string1.as_str(), string2);
6.     //会打印出 The longest string is abcd
7.     println!("The longest string is {}", result);
8. }

复制代码

实现 longest 函数的错误示例，它并不能编译：

1. fn longest(x: &str, y: &str) -> &str {
2.     if x.len() > y.len() {
3.         x
4.     } else {
5.         y
6.     }
7. }

复制代码

返回值需要一个泛型生命周期参数，因为 Rust 并不知道将要返回的引用是指向 x 或 y。
生命周期注解语法

生命周期注解并不改变任何引用的生命周期的长短，相反它们描述了多个引用生命周期相互的关系，而不影响其生命周期。与当函数签名中指定了泛型类型参数后就可以接受任何类型一样，当指定了泛型生命周期后函数也能接受任何生命周期的引用。
生命周期注解有着一个不太常见的语法：生命周期参数名称必须以撇号（'）开头，其名称通常全是小写，类似于泛型其名称非常短。生命周期参数注解位于引用的 & 之后，并有一个空格来将引用类型与生命周期注解分隔开。
大多数人使用 'a 作为第一个生命周期注解：

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

复制代码

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

为了在函数签名中使用生命周期注解，需要在函数名和参数列表间的尖括号中声明泛型生命周期（lifetime）参数，就像泛型类型（type）参数一样。
longest 函数定义指定了签名中所有的引用必须有相同的生命周期 'a，也就是这两个参数和返回的引用存活的一样久：

1. fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
2.     if x.len() > y.len() {
3.         x
4.     } else {
5.         y
6.     }
7. }

复制代码

记住通过在函数签名中指定生命周期参数时，并没有改变任何传入值或返回值的生命周期，而是指出任何不满足这个约束条件的值都将被借用检查器拒绝。
注意： longest 函数并不需要知道 x 和 y 具体会存在多久，而只需要知道有某个可以被 'a 替代的作用域将会满足这个签名。
当具体的引用被传递给 longest 时，泛型生命周期 'a 的具体生命周期等同于 x 和 y 的生命周期中较小的那一个。
通过拥有不同的具体生命周期的 String 值调用 longest 函数：

1. fn main() {
2.     let string1 = String::from("long string is long");
4.     {
5.         let string2 = String::from("xyz");
6.         let result = longest(string1.as_str(), string2.as_str());
7.         //能够编译和运行，并打印出 The longest string is long string is long
8.         println!("The longest string is {}", result);
9.     }
10. }

复制代码

尝试在 string2 离开作用域之后使用 result，不能编译：

1. fn main() {
2.     let string1 = String::from("long string is long");
3.     let result;
4.     {
5.         let string2 = String::from("xyz");
6.         result = longest(string1.as_str(), string2.as_str());
7.     }
8.     //编译错误，result 的引用的生命周期必须是两个参数中较短的那个
9.     println!("The longest string is {}", result);
10. }

复制代码

深入理解生命周期

指定生命周期参数的正确方式依赖函数实现的具体功能，如下代码将能够编译：

1. //y 的生命周期与参数 x 和返回值的生命周期没有任何关系，不用指定
2. fn longest<'a>(x: &'a str, y: &str) -> &'a str {
3.     x
4. }

复制代码

当从函数返回一个引用，返回值的生命周期参数需要与一个参数的生命周期参数相匹配。
一个不能编译的 longest 函数实现：

1. fn longest<'a>(x: &str, y: &str) -> &'a str {
2.     let result = String::from("really long string");
3.     //编译错误：result 在 longest 函数的结尾将离开作用域并被清理
4.     result.as_str()
5. }

复制代码

在早期版本，每一个引用都必须有明确的生命周期，接着 Rust 团队把一些可预测的模式编码进了 Rust 编译器中，如此借用检查器在这些情况下就能推断出生命周期而不再强制程序员显式的增加注解。未来只会需要更少的生命周期注解。
被编码进 Rust 引用分析的模式被称为 生命周期省略规则（lifetime elision rules），并不是需要程序员遵守的规则，而是一系列特定的场景：

• 如果代码符合这些场景，就无需明确指定生命周期。
  
• 如果 Rust 在明确遵守这些规则的前提下变量的生命周期仍然是模棱两可的话，编译器会给出一个错误提示。
  

函数或方法的参数的生命周期被称为 输入生命周期（input lifetimes），而返回值的生命周期被称为 输出生命周期（output lifetimes）。
编译器采用三条规则来判断引用何时不需要明确的注解，第一条规则适用于输入生命周期，后两条规则适用于输出生命周期，这些规则适用于 fn 定义，以及 impl 块：
<ul>第一条规则是编译器为每一个引用参数都分配一个生命周期参数。

• 函数有一个引用参数的就有一个生命周期参数：fn foo &'a i32。</p>
  
• 第三条规则是如果方法有多个输入生命周期参数并且其中一个参数是 &self 或 &mut self，说明是个对象的方法 (method)，那么所有输出生命周期参数被赋予 self 的生命周期。
  

应用这些规则来计算上面示例中 first_word 函数签名中的引用的生命周期：

1. struct ImportantExcerpt<'a> {
2.     part: &'a str,
3. }
5. fn main() {
6.     let novel = String::from("Call me Ishmael. Some years ago...");
7.     let first_sentence = novel.split('.').next().expect("Could not find a '.'");
8.     let i = ImportantExcerpt {
9.         part: first_sentence,
10.     };
11. }

复制代码

再看看另一个例子，没有生命周期参数的 longest 函数：

1. fn first_word(s: &str) -> &str {
2.     let bytes = s.as_bytes();
4.     for (i, &item) in bytes.iter().enumerate() {
5.         if item == b' ' {
6.             return &s[0..i];
7.         }
8.     }
10.     &s[..]
11. }

复制代码

方法定义中的生命周期注解

（实现方法时）结构体字段的生命周期必须总是在 impl 关键字之后声明并在结构体名称之后被使用，因为这些生命周期是结构体类型的一部分。
方法 level 唯一的参数是 self 的引用，而且返回值只是一个 i32，并不引用任何值：

1. //开始时签名中的引用并没有关联任何生命周期
2. fn first_word(s: &str) -> &str {
3. //接着编译器应用第一条规则，签名看起来像这样
4. fn first_word<'a>(s: &'a str) -> &str {
5. //第二条规则表明输入参数的生命周期将被赋予输出生命周期参数，签名看起来像这样
6. fn first_word<'a>(s: &'a str) -> &'a str {
7. //现在这个函数签名中的所有引用都有了生命周期

复制代码

一个适用于第三条生命周期省略规则的例子：

1. fn longest(x: &str, y: &str) -> &str {
2. //第一条规则：有两个参数就有两个（不同的）生命周期
3. fn longest<'a, 'b>(x: &'a str, y: &'b str) -> &str {
4. //第二条规则：函数存在多个输入生命周期，不适用
5. //第三条规则：没有 self 参数，不适用
6. //编译出现错误：编译器使用所有已知的生命周期省略规则，仍不能计算出签名中所有引用的生命周期。

复制代码

静态生命周期

有一种特殊的生命周期值得讨论：'static，其生命周期能够存活于整个程序期间，所有的字符串字面值都拥有 'static 生命周期：

1. //impl 之后和类型名称之后的生命周期参数是必要的
2. impl<'a> ImportantExcerpt<'a> {
3.     //因为第一条生命周期规则，不是必须标注 self 引用的生命周期
4.     fn level(&self) -> i32 {
5.         3
6.     }
7. }

复制代码

这个字符串的文本被直接储存在程序的二进制文件中而这个文件总是可用的，因此所有的字符串字面值都是 'static 的。
结合泛型类型参数、trait bounds 和生命周期

简要的看一下在同一函数中指定泛型类型参数、trait bounds 和生命周期的语法：

1. impl<'a> ImportantExcerpt<'a> {
2.     //Rust 应用第一条生命周期省略规则并给予 &self 和 announcement 它们各自的生命周期
3.     //其中一个参数是 &self，返回值类型被赋予了 &self 的生命周期
4.     fn announce_and_return_part(&self, announcement: &str) -> &str {
5.         println!("Attention please: {}", announcement);
6.         self.part
7.     }
8. }

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！