每个编程语言都有用一些有效的方式来处理重复的抽象概念,好比先前介绍过的集合,我们可以使用同一种集合结构体来产生出不同的实体,保存不同类型的数据。举例来说,String 和 i32 这两个不同类型的数据都可以被存到 Vec 结构体所创建的实体中,我们不需要特地针对不同数据的类型来分别实作出如 Vec<String> 或是 Vec<i32> 这样的结构体。这就是因为 Vec 结构体使用了「泛型」(generic)。

在「类型论」(type theory)中,「泛型」就是「参数多态」(parametric polymorphism),在定义复合类型或函数的时候不去明确地指定具体的类型,而以参数的形式来传入类型,如此一来这些复合类型或函数只需要实作一次,就可以透过参数传入不同类型的方式来将其应用在各种类型的数据下。先前我们看到的 Option 枚举、Result 枚举、Vec 结构体、HashMap 结构体都有泛型,所以它们可以和任何类型的数据一同使用。

我们就用一个找出数组最大元素值的程序来练习泛型吧!代码如下:

fn largest_i32(list: &[i32]) -> i32 {
    let mut largest = list[0];

    for &item in list.iter() {
        if item > largest {
            largest = item;
        }
    }

    largest
}

fn largest_f64(list: &[f64]) -> f64 {
    let mut largest = list[0];

    for &item in list.iter() {
        if item > largest {
            largest = item;
        }
    }

    largest
}

fn largest_char(list: &[char]) -> char {
    let mut largest = list[0];

    for &item in list.iter() {
        if item > largest {
            largest = item;
        }
    }

    largest
}

fn main() {
    let int_list = vec![34, 50, 25, 100, 65];

    let result = largest_i32(&int_list);
    println!("The largest integer number is {result}");

    let float_list = vec![32f64, 86.3, 96.1, 23.6, 44.8];

    let result = largest_f64(&float_list);
    println!("The largest float number is {result}");

    let char_list = vec!['y', 'm', 'a', 'q'];

    let result = largest_char(&char_list);
    println!("The largest char is {result}");
}

这个程序实作了三个函数 largest_i32、largest_f64、largest_char,可以分别从 32 比特的有号整数数组切片、64 比特的浮点数数组切片以及字符数组切片中找出最大的元素并回传出来。我们可以发现,程序第 2 行到第 10 行、第 14 行到第 22 行、第 26 行到第 34 行是完全一样的程序,这是因为我们需要处理不同类型的数据而重复写了三次,如果要连 i8、i16、i64、u8、u16、u32、u64、f32 等类型的数组切片也都支持的话,那就要再多重复写 8 次!为了一劳永逸解决这个问题,我们可以使用 Rust 编程语言提供的泛型机制,在定义函数名称时,在函数名称右边加上 <> 语法,来定义泛型要使用的参数,接下来的代码就可以使用这个参数来取代明确的类型名称。程序如下:

fn largest<T>(list: &[T]) -> T {
    let mut largest = list[0];

    for &item in list.iter() {
        if item > largest {
            largest = item;
        }
    }

    largest
}

fn main() {
    let int_list = vec![34, 50, 25, 100, 65];

    let result = largest(&int_list);
    println!("The largest integer number is {result}");

    let float_list = vec![32f64, 86.3, 96.1, 23.6, 44.8];

    let result = largest(&float_list);
    println!("The largest float number is {result}");

    let char_list = vec!['y', 'm', 'a', 'q'];

    let result = largest(&char_list);
    println!("The largest char is {result}");
}

在调用 largest<T> 函数时,编译器会在编译阶段时自动判断泛型的参数第一个接触到的值是什么类型,来决定参数 T 究竟是什么类型。如果不想要让编译器自行推定,而是想要在调用函数时直接指定泛型参数的类型的话,可以使用先前已经提到过几次的「turbofish」语法。程序如下:

fn largest<T>(list: &[T]) -> T {
    let mut largest = list[0];

    for &item in list.iter() {
        if item > largest {
            largest = item;
        }
    }

    largest
}

fn main() {
    let int_list = vec![34, 50, 25, 100, 65];

    let result = largest::<i32>(&int_list);
    println!("The largest integer number is {result}");

    let float_list = vec![32f64, 86.3, 96.1, 23.6, 44.8];

    let result = largest::<f64>(&float_list);
    println!("The largest float number is {result}");

    let char_list = vec!['y', 'm', 'a', 'q'];

    let result = largest::<char>(&char_list);
    println!("The largest char is {result}");
}

然而,不论有没有使用「turbofish」语法,以上程序第 5 行都会编译错误。因为若要将值进行大于小于等逻辑判断,该值的类型必须要实作 PartialOrd 特性。由于泛型的参数 T 可以是任意的类型,这个类型不一定会实作 PartialOrd 特性,所以程序无法编译成功。为了要让编译器确定参数 T 有实作 PartialOrd 特性,我们必须事先明确定义泛型的参数 T 传入的类型必须要实作 PartialOrd 特性。就像定义一般函数的参数类型一样,泛型的参数类型也可以使用冒号 : 语法。程序如下:

fn largest<T: PartialOrd>(list: &[T]) -> T {
    let mut largest = list[0];

    for &item in list.iter() {
        if item > largest {
            largest = item;
        }
    }

    largest
}

fn main() {
    let int_list = vec![34, 50, 25, 100, 65];

    let result = largest::<i32>(&int_list);
    println!("The largest integer number is {result}");

    let float_list = vec![32f64, 86.3, 96.1, 23.6, 44.8];

    let result = largest::<f64>(&float_list);
    println!("The largest float number is {result}");

    let char_list = vec!['y', 'm', 'a', 'q'];

    let result = largest::<char>(&char_list);
    println!("The largest char is {result}");
}

再次尝试编译程序后,会发现这个程序还是无法通过编译。这是因为程序第 2 行,我们使用直接透过索引值读取数组元素值的方式将其又指派给了 largest 变量,这里的行为就跟「把变量指派给另一个变量」一样,如果该类型有实作 Copy 特性,就会进行「拷贝」,否则就是「移动」。然而,由于我们只告诉编译器泛型的 T 参数所表示的类型只确定有实作 PartialOrd 特性,而不确定有没有实作 Copy 特性,在这个情况下「把变量指派给另一个变量」就会用「移动」的方式来进行,而复合类型内的数据是无法被移动的,因此在「拷贝」不知道可不可行且又确定「移动」不可行的情况下,就出现编译错误啦!

为了让程序能够编译成功,我们也需要告诉编译器 T 参数所表示的类型,除了有实作 PartialOrd 特性之外,也还有实作 Copy 特性。我们可以直接使用加号 +,来替泛型类型的参数加上更多需要实作的特性。程序如下:

fn largest<T: PartialOrd + Copy>(list: &[T]) -> T {
    let mut largest = list[0];

    for &item in list.iter() {
        if item > largest {
            largest = item;
        }
    }

    largest
}

fn main() {
    let int_list = vec![34, 50, 25, 100, 65];

    let result = largest::<i32>(&int_list);
    println!("The largest integer number is {result}");

    let float_list = vec![32f64, 86.3, 96.1, 23.6, 44.8];

    let result = largest::<f64>(&float_list);
    println!("The largest float number is {result}");

    let char_list = vec!['y', 'm', 'a', 'q'];

    let result = largest::<char>(&char_list);
    println!("The largest char is {result}");
}

程序运行结果如下:

The largest integer number is 100
The largest float number is 96.1
The largest char is y

除了函数能够使用泛型外,枚举、结构体、特性也是可以的。同样都是在名称右边加上 <> 语法,来定义泛型要使用的参数。举例来说:

struct Point<T> {
    x: T,
    y: T
}

fn main() {
    let integer = Point { x: 5, y: 10 };
    let float = Point { x: 1.0, y: 4.0 };
}

在实体化 Point 结构体时,编译器会在编译阶段时自动判断泛型的参数第一个接触到的值是什么类型,来决定参数 T 究竟是什么类型。以上程序第 7 行,泛型参数 T 先接触到 5 这个 i32 类型的值,因此参数 T 被编译器推论为 i32;程序第 8 行,泛型参数 T 先接触到 1.0 这个 f64 类型的值,因此参数 T 被编译器推论为 f64。

再看一个例子:

struct Point<T> {
    x: T,
    y: T
}

fn main() {
    let wont_work = Point { x: 5, y: 4.0 };
}

以上程序,第 7 行会编译错误,因为泛型参数 T 先接触到 5 这个 i32 类型的值,因此参数 T 被编译器推论为 i32,此时 Point 结构体的 x 和 y 字段都是 i32 类型,所以无法保存 4.0 这个 f64 类型的值。

如果要让 Point 结构体的 x 和 y 字段可以是不同类型,就要使用两个泛型参数。举例来说:

struct Point<T, U> {
    x: T,
    y: U,
}

fn main() {
    let both_integer = Point { x: 5, y: 10 };
    let both_float = Point { x: 1.0, y: 4.0 };
    let integer_and_float = Point { x: 5, y: 4.0 };
}

以上程序可以通过编译,因为 x 和 y 字段使用不同的泛型参数,类型不需要一样。

枚举也可以搭配泛型来使用。例如之前我们用过的 Option 枚举和 Result 枚举,其定义如下:

enum Option<T> {
    Some(T),
    None
}

enum Result<T, E> {
    Ok(T),
    Err(E)
}

关联函数和方法也可以使用泛型,在使用 impl 关键字来实作关联函数和方法时,impl 关键字的右边可以直接加上 <> 语法,来定义泛型要使用的参数。举例来说:

struct Point<T> {
    x: T,
    y: T,
}

impl<T> Point<T> {
    fn x(&self) -> &T {
        &self.x
    }
}

fn main() {
    let p = Point { x: 5, y: 10 };

    println!("p.x = {}", p.x());
}

另外 impl 关键字也可以不使用泛型,只针对特定类型来实作关联函数和方法。举例来说:

struct Point<T> {
    x: T,
    y: T,
}

impl<T> Point<T> {
    fn x(&self) -> &T {
        &self.x
    }
}

impl Point<f64> {
    fn distance_from_origin(&self) -> f64 {
        (self.x.powi(2) + self.y.powi(2)).sqrt()
    }
}

impl Point<i32> {
    fn distance_from_origin(&self) -> f64 {
        ((self.x.pow(2) + self.y.pow(2)) as f64).sqrt()
    }
}

fn main() {
    let p = Point { x: 3.0, y: 4.0 };

    println!("distance = {}", p.distance_from_origin());

    let p = Point { x: 5, y: 12 };

    println!("distance = {}", p.distance_from_origin());
}

以上程序利用多个 impl 关键字,分别替 Point<f64> 和 Point<i32> 实作了 distance_from_origin 方法。

Rust 的泛型不会有任何额外的运算性能的耗损,因为编译器在编译泛型的代码时,就会把泛型解开来,将原本的类型变量替换成一个独立的类型。举例来说,我们用 Option 枚举的 Some 变体产生出以下两个实体。

fn main() {
    let integer = Some(5);
    let float = Some(5.0);
}

依照目前我们对 Rust 编程语言的理解,integer 变量的类型应为 Option<i32>,而 float 变量的类型应为 Option<f64>。然而,事实上,Rust 的编译器会自动替 Option<i32> 和 Option<f64> 产生出不一样的枚举,分别是 Option_i32 和 Option_f64。编译器将泛型解开后的代码如下:

enum Option_i32 {
    Some(i32),
    None,
}

enum Option_f64 {
    Some(f64),
    None,
}

fn main() {
    let integer = Option_i32::Some(5);
    let float = Option_f64::Some(5.0);
}

因此,使用泛型的时候,程序在运行阶段完全不需要使用额外的运算资源去进行类型的检查,因为这些工作在编译阶段就已经自动完成了!

接下来来介绍 Rust 编程语言的「特性」吧!

「特性」可以定义一个抽象的类型,这种类型只会定义未经实作的关联函数和方法,可交由其它多个类型来具体实现。之前在使用泛型的时候,我们也学到在定义泛型的参数时,可以限定这些参数所表示的类型必须要实作哪些特性。Rust 的「特性」就像是其它编程语言的「界面」(interface),但仅仅只是很像而已,还是有许多不同的地方。

不同种类的类型可以借由实作同一个特性,来用不同的方式实作同样名称的关联函数和方法。在变量或参数的类型也可以使用特性来定义,在使用这类的变量或参数时,我们在乎的只是该特性所定义的关联函数和方法的签名和回传值类型,而不是其实作的方式,甚至我们也不用去管那些数据到底是属于哪个类型,我们只是很单纯地要去用它们拥有的某个或某些特定的关联函数和方法而已。

定义特性可以使用 trait 关键字。举例来说:

trait Summarizable {
    fn summary(&self) -> String;
}

这里有个地方要注意的是,原先我们实作函数或是方法的时候,都会使用大括号 {} 来创建程序叙述区块,作为函数或是方法的主体。但是使用 trait 关键字定义特性时,其抽象的函数或是方法不需要使用大括号 {} 来实作出来,只要将签名和回传值类型定义出来即可,最后要记得加上分号 ;,才会是一个完整的程序叙述。

假设我们现在要写个程序,来处理不同类型的网络文章。简单将文章分为新闻和推特贴文,我们先分别使用 NewsArticle 和 Tweet 结构体来描述它们。程序如下:

struct NewsArticle {
    headline: String,
    location: String,
    author: String,
    content: String
}

struct Tweet {
    username: String,
    content: String,
    reply: bool,
    retweet: bool
}

再假设 NewsArticle 和 Tweet 结构体所描述的新闻和推特贴文信息,都可以用不同的形式来概括论述。应用我们刚才举例的 Summarizable 特性,再利用之前学到的 impl 关键字,来分别替 NewsArticle 和 Tweet 结构体实作 fn summary(&self) -> String 方法吧!程序如下:

trait Summarizable {
    fn summary(&self) -> String;
}

struct NewsArticle {
    headline: String,
    location: String,
    author: String,
    content: String
}

struct Tweet {
    username: String,
    content: String,
    reply: bool,
    retweet: bool
}

impl NewsArticle {
    fn summary(&self) -> String {
        format!("{}, by {} ({})", self.headline, self.author, self.location)
    }
}

impl Tweet {
    fn summary(&self) -> String {
        format!("{}: {}", self.username, self.content)
    }
}

虽然这样的方式可以让 NewsArticle 和 Tweet 结构体的实体拥有 summary 方法,但是它们都跟 Summarizable 特性没有什么关系,只是 summary 方法的名称、参数和回传值类型一样而已。为了让 NewsArticle 和 Tweet 结构体能够真的实作 Summarizable 特性,我们必须替它们实作 Summarizable 特性,这边还必须再搭配一个 for 关键字来使用。程序如下:

trait Summarizable {
    fn summary(&self) -> String;
}

struct NewsArticle {
    headline: String,
    location: String,
    author: String,
    content: String
}

struct Tweet {
    username: String,
    content: String,
    reply: bool,
    retweet: bool
}

impl Summarizable for NewsArticle {
    fn summary(&self) -> String {
        format!("{}, by {} ({})", self.headline, self.author, self.location)
    }
}

impl Summarizable for Tweet {
    fn summary(&self) -> String {
        format!("{}: {}", self.username, self.content)
    }
}

利用 impl 关键字来替结构体实作特性中所定义的所有抽象函数和方法。如此一来,NewsArticle 和 Tweet 结构体就有了 Summarizable 特性,也就可以使用 summary 方法了!举例来说:

trait Summarizable {
    fn summary(&self) -> String;
}

struct NewsArticle {
    headline: String,
    location: String,
    author: String,
    content: String
}

struct Tweet {
    username: String,
    content: String,
    reply: bool,
    retweet: bool
}

impl Summarizable for NewsArticle {
    fn summary(&self) -> String {
        format!("{}, by {} ({})", self.headline, self.author, self.location)
    }
}

impl Summarizable for Tweet {
    fn summary(&self) -> String {
        format!("{}: {}", self.username, self.content)
    }
}

fn main() {
    let news = NewsArticle {
        headline: String::from("Fearless Concurrency in Firefox Quantum"),
        location: String::from("The Rust Programming Language Blog"),
        author: String::from("Manish Goregaokar"),
        content: String::from("Overall, Firefox Quantum benefits significantly from Stylo, and thus from Rust. Not only does it speed up page load, but it also speeds up interaction times since styling information can be recalculated much faster, making the entire experience smoother.")
    };
    let tweet = Tweet {
        username: String::from("horse_ebooks"),
        content: String::from("of course, as you probably already know, people"),
        reply: false,
        retweet: false
    };

    summarize_and_print(&tweet);
    summarize_and_print(&news);
}

fn summarize_and_print(a: &dyn Summarizable) {
    println!("{}", a.summary());
}

以上程序,summarize_and_print 函数直接使用 Summarizable 特性作为其参数的类型,因此无论是 NewsArticle 结构实体还是 Tweet 结构实体,总之只要是有实作这个 Summarizable 特性的结构体的实体都可以被传入。这边要注意的是,特性无法直接作为变量或参数的类型,a: Summarizable 是个不正确的用法,因为我们在编译阶段的时候并无法明确的知道变量 a 究竟要分配多少空间才可以存放有实作 Summarizable 特性的结构实体,它只能转成参考类型才能被用来定义变量或参数的类型。

程序运行结果如下:

horse_ebooks: of course, as you probably already know, people
Fearless Concurrency in Firefox Quantum, by Manish Goregaokar (The Rust Programming Language Blog)

也可以将 summarize_and_print 函数使用泛型来改写,可以使用法更加灵活。程序如下:

trait Summarizable {
    fn summary(&self) -> String;
}

struct NewsArticle {
    headline: String,
    location: String,
    author: String,
    content: String
}

struct Tweet {
    username: String,
    content: String,
    reply: bool,
    retweet: bool
}

impl Summarizable for NewsArticle {
    fn summary(&self) -> String {
        format!("{}, by {} ({})", self.headline, self.author, self.location)
    }
}

impl Summarizable for Tweet {
    fn summary(&self) -> String {
        format!("{}: {}", self.username, self.content)
    }
}

fn main() {
    let news = NewsArticle {
        headline: String::from("Fearless Concurrency in Firefox Quantum"),
        location: String::from("The Rust Programming Language Blog"),
        author: String::from("Manish Goregaokar"),
        content: String::from("Overall, Firefox Quantum benefits significantly from Stylo, and thus from Rust. Not only does it speed up page load, but it also speeds up interaction times since styling information can be recalculated much faster, making the entire experience smoother.")
    };
    let tweet = Tweet {
        username: String::from("horse_ebooks"),
        content: String::from("of course, as you probably already know, people"),
        reply: false,
        retweet: false
    };

    summarize_and_print(&tweet);
    summarize_and_print(&news);
}

fn summarize_and_print<T: Summarizable>(a: &T) {
    println!("{}", a.summary());
}

程序第 49 行,我们替 summarize_and_print 函数定义了泛型,其 T 参数必须要是有实作 Summarizable 特性的类型。如果我们之后要限制这个类型必须再有其他特性,只要利用加号 +,就能替泛型类型的参数加上更多需要实作的特性。除了使用参考类型或是泛型来指定数据类型必须要实作的特性外,也可以将刚才提到的 a: Summarizable 这样的错误用法,搭配 impl 关键字改成 a: impl Summarizable 来使用。

在定义泛型参数时,由于可能要限制该类型必须实作很多的特性,而使得 <> 内的代码变得很长,导致程序不易阅读,此时我们可以考虑使用 where 关键字,将限定泛型参数所表示的类型必须实作的特性,改写到 where 关键字之后。举例来说:

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

可以用 where 关键字改写成:

fn some_function<T, U>(t: T, u: U) -> i32
    where T: Display + Clone,
          U: Clone + Debug

trait 关键字除了可以替特性定义抽象的函数和方法之外,也可以定义拥有主体的函数和方法。举例来说,若将刚才的 Summarizable 特性改为:

pub trait Summarizable {
    fn summary(&self) -> String {
        String::from("(Read more...)")
    }
}

则其它类型在实作 Summarizable 特性时,若不实作 summary 方法,就会直接使用 Summarizable 特性预设实作的 summary 方法。

我们之前在介绍拥有权的时候,忽略了一个细节,那就是「生命周期」(lifetime)。Rust 编程语言中的每个参考都有生命周期,生命周期就是参考有效的 scope。就像类型推论一样,大多数的生命周期也都不用明确定义,可以交由编译器来自动推论。但是在一些特别的情况下,我们会需要自行定义参考的生命周期。

生命周期主要是要解决悬置参考(dangling reference)的问题,也就是当一个参考指到的内存空间并不是正确的地址,或已经被释放、挪做它用时,所引发的问题。 先来看看这个程序:

fn main() {
    let r;

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

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

以上程序第 6 行会编译失败,因为我们之前学到,当离开 scope 时,属于该 scope 底下的「拥有者」所持有的值都会被消灭,因此不能将 x 变量的值借给位在上层 scope 的变量 r。如果这个程序能够编译成功的话,程序第 8 行之后的 r 变量就会有悬置引用的问题。以生命周期的角度来探讨,我们将 r 变量的生命周期称作 'a,x 变量的生命周期称为 'b,请看以下程序注解的部份:

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

不难发现到生命周期 'b 比生命周期 'a 还要早结束,而第 9 行还会用到 r,因此编译器知道生命周期 'b 的变量不能借给生命周期 'a 的变量使用。

如果把第 4 行和第 7 行的大括号拿掉,生命周期 'b 就会向下延长到 main 函数的结尾。此时虽然生命周期 'a 还是比生命周期 'b 早开始,但编译器只会检查 x 被 r 借用的期间,也就是从 r = &x 到最后一次使用 r 的地方,是否都在生命周期 'b 之内,所以程序就可以编译成功了。若再把变量 r 改在第 6 行才声明,生命周期 'a 和 'b 就会变成:

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

以上程序,由于生命周期 'a 就在生命周期 'b 的范围内,因此程序可以编译成功。

生命周期的问题同样也会在函数和方法上遇到,这边有一个 longest 函数,这个函数可以透过参数输入两个字符串切片,并找出最长的那个将其回传。程序如下:

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

这个程序看起来很合理,但实际上会编译错误。虽然编译器知道函数的回传值有参考类型,但编译器并无法确定回传的参考的生命周期。举例来说:

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

fn main() {
    let x = "123";
    let longest_str;
    {
        let y = String::from("abcd");
        longest_str = longest(x, &y);
    }
    println!("longest_str: {longest_str}");
}

借由以上的方式来调用 longest 函数的话,假设程序可以编译成功,longest_str 变量在第 16 行之后就会有悬置引用的问题。

在稍微复杂条件下,我们必须明确地告诉编译器,函数或方法的参数和回传值如果有参考类型时的生命周期,否则编译器就会不知道怎么安全又正确地处理该函数或方法,而直接产生编译错误。定义生命周期,需要透过泛型参数,且参数名称必须以 ' 开头。要在参考类型名称上加上泛型参数,只需要将生命周期的参数名称接在 & 后面即可。程序如下:

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

我们替 longest 函数定义了泛型,其有一个生命周期的参数 'a。然后将 x 参数,y 参数和其回传值的类型都定义为 &'a str,也就是要将它们的生命周期限制在同样的范围下,也就是 x 参数、y 参数和回传值,都必须在至少 'a 的生命周期中存活。假设传进 x 参数的参考的生命周期为 'i,传进 y 参数的参考的生命周期为 'j,x 参数和 y 参数都是指定要使用泛型 'a 参数所代表的生命周期,则泛型 'a 参数实际所代表的生命周期就要看 'i 和 'j 哪个小,就用哪个。如果要使用可变参考,要把 &'a 改为 &'a mut。定义参考的生命周期不会影响到编译出来的程序,这个是给编译器看的数据,程序在运行阶段不会去做额外的生命周期检查。

将函数的回传值类型定义明确的生命周期,代表着这个回传值一定要使用定义的生命周期。举例来说:

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

以上程序,我们直接让 longest 函数回传从函数主体中产生出来的字符串切片,由于该字符串切片的生命周期不是 'a,因此会编译失败。

但是,如果直接回传字符串定数的话,就可以编译成功。如下:

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

这是因为字符串定数的字符串数据是随着程序本身保存在内存中的某块静态的区块,不会被消灭,因此不会有生命周期的问题。像这种存在于整个程序运行阶段的数据,其生命周期有个特别的名称,那就是 'static。

除了函数和方法有生命周期的问题外,结构体也有。想要在结构体中保存参考类型的值,就必须要替该字段明确定义好生命周期。举例来说:

struct Book<'a> {
    title: &'a mut String
}

fn main() {
    let mut title = String::from("Harry Potter");
    let novel = Book { title: &mut title };
    novel.title.push_str(" 2");
}

注意这边的 novel 变量并没有使用 mut 关键字来声明,程序却依然可以通过编译。如果要在创建实体之后更改字段所保存的参考值,除了保存结构体的变量要使用 mut 关键字来声明之外,新的参考值所参考的数据也必须要存活得够久才行。举例来说:

struct Book<'l> {
    title: &'l mut String
}

fn main() {
    let mut title = String::from("Harry Potter");
    let mut novel = Book { title: &mut title };
    novel.title.push_str(" 2");
    {
        let mut title = String::from("Hurry Peter");
        novel.title = &mut title;
    }
    novel.title.push_str(" 3");
}

以上程序会编译错误,理由是:

struct Book<'l> {
    title: &'l mut String
}

fn main() {
    let mut title = String::from("Harry Potter");     // ---------'a
    let mut novel = Book { title: &mut title };       //           |
    novel.title.push_str(" 2");                       //           |
    {                                                 //           |
        let mut title = String::from("Hurry Peter");  // ----'b    |
        novel.title = &mut title;                     //      |    |
    }                                                 // -----+    |
    novel.title.push_str(" 3");                       //           |
}                                                     // ----------+

泛型参数 'l 所表示的生命周期,必须涵盖 novel 变量会被使用到的范围,也就是至少要到第 13 行。然而,第 10 行的 title 变量的生命周期 'b 在第 12 行就结束了,比 'l 还要短,因此生命周期为 'b 的 title 变量无法指派给 Book 结构实体的 title 字段。如果把第 13 行删掉,或是拿掉第 9 行和第 12 行的大括号,让第 10 行的 title 变量可以存活到 main 函数结束,程序就可以编译成功。

生命周期的观念大概就是这样子,需要多花点心思去思考才能理解。以下的几个规则,可以在定义回传值含有参考类型的函数和方法时,不明确定义出参数和回传值的生命周期,而是交给编译器来自行推论。

1. 函数中没有被明确定义生命周期的参数,每一个参考类型的参数则都有属于自己的泛型生命周期参数。
2. 如果函数只有一个参考类型的参数,且回传值也有参考类型的值(参数和回传值中的参考可以是不同类型),则回传值参考的生命周期就是那唯一参考类型的参数的生命周期。
3. 如果方法除了 &self 外还有其它参考类型的参数,则回传值参考的生命周期就是 &self 的生命周期。

举例来说:

fn first_word(s: &str) -> &str

根据第一个规则,编译器会自动将其加上泛型参数和函数参数的生命周期。如下:

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

再来根据第二个规则,编译器会自动替回传值加上生命周期。如下:

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

Rust 的编译器提供这样的生命周期推论功能,使我们可以不明确写出参数和回传值的生命周期,就能定义出大部份的函数和方法,非常方便!

最后来看一下当泛型的类型参数和生命周期参数混在一起使用的状况,举个例子:

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
    }
}

fn main() {
    let x = "123";
    let y = String::from("abcd");
    let longest_str = longest_with_an_announcement::<&str>(x, &y, "Ha! Ha! Ha!");

    println!("longest_str: {longest_str}");
}

当泛型同时拥有类型参数和生命周期参数时,生命周期的参数要先写,并且在使用「turbofish」语法的时候,只需要替泛型的类型参数指定类型即可。

总结

我们在这个章节中将泛型、特性和生命周期这几个 Rust 编程语言中最复杂的基本观念给初步厘清了,现在我们已经有办法使用 Rust 编程语言来设计出各式各样的程序。在下一章节中,我们会学习如何测试我们写出来的 Rust 程序,以确保程序真的是依照我们想要的方式来运行。

下一章:测试。