关于 Rust 的生命周期,我们在先前的章节中已经先学习了一部份了。在这个章节,我们将会学习如何使用生命周期的子类型,了解如何替泛型类型参数指定生命周期,以及特性对象的生命周期规则。

生命周期的子类型

生命周期的子类型是一种定义一个生命周期比另一个生命周期还要长的方式。我们直接看底下这个例子吧!

struct Context<'a>(&'a str);

struct Parser<'a> {
    context: &'a Context<'a>,
}

impl<'a> Parser<'a> {
    fn parse(&self) -> Result<(), &str> {
        Err(&self.context.0[1..])
    }
}

fn parse_context(context: Context) -> Result<(), &str> {
    Parser { context: &context }.parse()
}

fn main() {
    parse_context(Context("Hello World")).unwrap();
}

这个程序会编译失败,因为程序第 14 行,Parser 结构实体的 context 字段所保存的 Context 元组结构实体的参考的生命周期,与 Context 元组结构实体的字符串切片的生命周期并不相同。如果要利用我们目前掌握的 Rust 相关知识来修改这个程序,使其通过编译的话,可以修改成这样:

struct Context(&'static str);

struct Parser<'a> {
    context: &'a Context,
}

impl<'a> Parser<'a> {
    fn parse(&self) -> Result<(), &'static str> {
        Err(&self.context.0[1..])
    }
}

fn parse_context(context: Context) -> Result<(), &'static str> {
    Parser { context: &context }.parse()
}

fn main() {
    parse_context(Context("Hello World")).unwrap();
}

将字符串切片的生命周期全都改为 'static,就可以成功使程序通过编译。但是这样的话,Context 元组结构就只能保存字符串定数了。如果我们想要让 Context 元组结构真的能够保存任意的字符串切片,那就不能使用 'static 作为字符串定数的生命周期,需用其它的方式来修正。其实仔细想想的话,不难发现,我们只要将原先的代码,parse_context 函数的 context 参数改为 Context 参考类型就可以了。程序改写如下:

struct Context<'a>(&'a str);

struct Parser<'a> {
    context: &'a Context<'a>,
}

impl<'a> Parser<'a> {
    fn parse(&self) -> Result<(), &'a str> {
        Err(&self.context.0[1..])
    }
}

fn parse_context<'a>(context: &'a Context) -> Result<(), &'a str> {
    Parser { context }.parse()
}

fn main() {
    let context = Context("Hello World");

    parse_context(&context).unwrap();
}

但如果我们还是想要让 parse_context 函数能够直接从参数传入一个 Context 元组结构实体呢?试试看用多个泛型生命周期参数吧!

struct Context<'a>(&'a str);

struct Parser<'c, 's> {
    context: &'c Context<'s>,
}

impl<'c, 's> Parser<'c, 's> {
    fn parse(&self) -> Result<(), &'s str> {
        Err(&self.context.0[1..])
    }
}

fn parse_context(context: Context) -> Result<(), &str> {
    Parser { context: &context }.parse()
}

fn main() {
    parse_context(Context("Hello World")).unwrap();
}

以上程序看起来似乎可行,但在 Rust 1.31 之前依然是会编译失败,原因在于我们必须要确定程序第 4 行的 's 生命周期会活得比 'c 生命周期还要久。现在的 Rust 编译器会从程序第 4 行的 &'c Context<'s> 自动推论出这个限制,所以以上程序其实已经可以编译成功。不过,我们还是可以自己明确地定义 's 生命周期比 'c 生命周期还要长,要如何使用生命周期的子类型来控制呢?很简单,就像是在定义变量的类型一样,在一个生命周期的名称后面使用冒号 :,决定其至少要涵盖哪个另外的生命周期。以上程序再改写如下:

struct Context<'a>(&'a str);

struct Parser<'c, 's: 'c> {
    context: &'c Context<'s>,
}

impl<'c, 's: 'c> Parser<'c, 's> {
    fn parse(&self) -> Result<(), &'s str> {
        Err(&self.context.0[1..])
    }
}


fn parse_context(context: Context) -> Result<(), &str> {
    Parser { context: &context }.parse()
}

fn main() {
    parse_context(Context("Hello World")).unwrap();
}

如此一来就可以明确地限制 's 生命周期至少要涵盖 'c 生命周期,这样的程序在 Rust 1.31 之前的版本也可以编译成功。

替泛型类型参数指定生命周期

先举个例子说明。我们之前已经使用过 Ref 结构体了,现在请先忽略它。若我们想要实作出自己的 Ref 结构体,应该要怎么做呢?Ref 结构体应该会需要保存某个任意值的参考,也就是说,我们必须用到泛型来表示任意类型,也需要一个字段来保存参考。在此我们选择使用元组结构体,将其定义如下:

struct Ref<'a, T>(&'a T);

以上程序虽然可以编译(旧版 Rust 不行),但试想一下可以发现,泛型类型 T 可以是一个任意的类型,而这个类型可能也会有参考类型的字段,因此泛型类型 T 的实体,其所保存的参考的生命周期,肯定是比 'a 生命周期还要长的。所以这进程式其实也等同于:

struct Ref<'a, T: 'a>(&'a T);

另外,我们也可以改为使用 'static 生命周期来做为泛型类型的生命周期限制。如此一来,就会限制该类型的实体不能够含有非 'static 生命周期的参考类型字段。

举例来说:

#[derive(Debug)]
struct Ref<'a, T: 'a>(&'a T);

#[derive(Debug)]
struct StaticRef<'a, T: 'static>(&'a T);

#[derive(Debug)]
struct NoRefStruct {
    value: i32,
}

#[derive(Debug)]
struct OneRefStruct<'a> {
    text: &'a String,
}

#[derive(Debug)]
struct StrRefStruct {
    text: &'static str,
}

fn main() {
    let no_ref = NoRefStruct { value: 100 };
    let one_ref = OneRefStruct { text: &String::from("Hello!") };
    let str_ref = StrRefStruct { text: "Hello!" };

    let ref_no_ref = Ref(&no_ref);
    let static_ref_no_ref = StaticRef(&no_ref);
    let ref_one_ref = Ref(&one_ref);
    // let static_ref_one_ref = StaticRef(&one_ref); // compilation error
    let ref_str_ref = Ref(&str_ref);
    let static_ref_str_ref = StaticRef(&str_ref);

    println!("{ref_no_ref:?}");
    println!("{static_ref_no_ref:?}");
    println!("{ref_one_ref:?}");
    println!("{ref_str_ref:?}");
    println!("{static_ref_str_ref:?}");
}

以上程序,OneRefStruct 结构实体无法产生出 StaticRef 结构实体,因为其含有非 'static 生命周期的参考类型字段。

推论特性对象的生命周期

先看看以下代码吧!

struct OneRefStruct<'a> {
    text: &'a String,
}

trait MyTrait {}

impl<'a> MyTrait for OneRefStruct<'a> {}

struct MyStruct<'a> {
    obj: Box<OneRefStruct<'a>>,
}

fn main() {
    let one_ref = OneRefStruct { text: &String::from("Hello!") };

    let s = MyStruct { obj: Box::new(one_ref) };
}

以上程序可以通过编译。OneRefStruct 结构体有一个 text 字段,可以存放一个 String 结构实体的参考。MyStruct 结构体有一个 obj 字段,可以存放一个 Box 结构实体。

如果我们修改 MyStruct 结构体的 obj 字段,使其保存 MyTrait 特性的特性对象的话。程序如下:

struct OneRefStruct<'a> {
    text: &'a String,
}

trait MyTrait {}

impl<'a> MyTrait for OneRefStruct<'a> {}

struct MyStruct {
    obj: Box<dyn MyTrait>,
}

fn main() {
    let one_ref = OneRefStruct { text: &String::from("Hello!") };

    let s = MyStruct { obj: Box::new(one_ref) };
}

在进行修改的时候,我们就会发现到一个奇怪的地方,原本的 'a 生命周期好像没有必要加进去了!?然而,虽然我们修改的部份(程序第 9 行到第 11 行)可以通过编译,但是在程序第 16 行却编译失败了。

虽然我们没有替 MyStruct 结构体的 Box<dyn MyTrait> 类型定义生命周期,但 Rust 的编译器会自动依照以下的规则进行特性对象所指到的实体的生命周期推论:

1. 智能型指针的特性对象,如 Box<dyn T>,其 T 预设的生命周期为 'static。
2. 参考的特性对象,如 &'a dyn T 或 &'a mut dyn T,其 T 预设的生命周期为 'a。

以这个例子来说,由于 MyTrait 没有泛型参数,所以 Box<dyn MyTrait> 这种特性对象所指到的有实作 MyTrait 特性的实体,其生命周期为 'static。换句话说,Box<dyn MyTrait> 会被推论为 Box<dyn MyTrait + 'static>。由于 &String::from("Hello!") 的生命周期并不是 'static,因此 one_ref 所保存的 OneRefStruct 结构实体,无法被用来产生 Box<dyn MyTrait> 特性对象。

如果要让程序顺利通过编译,我们依然会需要替 MyStruct 结构体加上泛型生命周期参数,来让 Box<dyn MyTrait> 特性对象能够明确地指定生命周期,而不会被编译器自动推论为 Box<dyn MyTrait + 'static>。修改后的代码如下:

struct OneRefStruct<'a> {
    text: &'a String,
}

trait MyTrait {}

impl<'a> MyTrait for OneRefStruct<'a> {}

struct MyStruct<'a> {
    obj: Box<dyn MyTrait + 'a>,
}

fn main() {
    let one_ref = OneRefStruct { text: &String::from("Hello!") };

    let s = MyStruct { obj: Box::new(one_ref) };
}

以上程序也可以改写成:

struct OneRefStruct<'a> {
    text: &'a String,
}

trait MyTrait {}

impl<'a> MyTrait for OneRefStruct<'a> {}

struct MyStruct<'a> {
    obj: &'a dyn MyTrait,
}

fn main() {
    let one_ref = OneRefStruct { text: &String::from("Hello!") };

    let s = MyStruct { obj: &one_ref };
}

结论

这个章节中,我们学到了利用「生命周期的子类型」和「替泛型类型参数指定生命周期」来限制生命周期的长短,以及特性对象搭配生命周期的使用方式。

下一章节,我们将会学习高级的特性用法。

下一章:高级的特性用法。