Rust生命周期基础教程：从入门到实践-优快云博客

Rust生命周期基础教程：从入门到实践

rust-by-practice Learning Rust By Practice, narrowing the gap between beginner and skilled-dev through challenging examples, exercises and projects. 项目地址: https://gitcode.com/gh_mirrors/ru/rust-by-practice

生命周期（Lifetime）是Rust中确保引用安全性的核心机制，它帮助编译器在编译时验证所有借用（borrow）的有效性。本文将深入浅出地讲解生命周期的基本概念、使用场景和常见模式。

生命周期基础概念

什么是生命周期

生命周期是指变量从创建到销毁的整个存在期间。在Rust中，编译器通过生命周期来确保：

引用不会比它们所引用的数据存活得更久
不存在悬垂引用（dangling references）

生命周期作用域示例

fn main() {
    let i = 3;  // i的生命周期开始
    {
        let borrow1 = &i;  // borrow1的生命周期开始
        println!("borrow1: {}", borrow1);
    }  // borrow1的生命周期结束
    
    {
        let borrow2 = &i;  // borrow2的生命周期开始
        println!("borrow2: {}", borrow2);
    }  // borrow2的生命周期结束
}  // i的生命周期结束

在这个例子中：

i拥有最长的生命周期
borrow1和borrow2的生命周期互不重叠
两个借用都在i的有效期内结束

生命周期注解

当编译器无法自动推断引用的有效范围时，我们需要手动添加生命周期注解。

函数中的生命周期

函数签名中的生命周期注解需要遵循以下规则：

每个引用参数都必须有明确的生命周期注解
返回的引用必须与某个输入参数的生命周期相同或者是'static

// 单个生命周期注解
fn print_one<'a>(x: &'a i32) {
    println!("`print_one`: x is {}", x);
}

// 可变引用
fn add_one<'a>(x: &'a mut i32) {
    *x += 1;
}

// 多个生命周期
fn print_multi<'a, 'b>(x: &'a i32, y: &'b i32) {
    println!("`print_multi`: x is {}, y is {}", x, y);
}

// 返回与输入相同的生命周期
fn pass_x<'a, 'b>(x: &'a i32, _: &'b i32) -> &'a i32 { x }

常见问题解决

问题1：返回较长字符串的引用

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

这里需要为输入和输出添加相同的生命周期注解'a，表示返回的引用与输入参数具有相同的生命周期。

问题2：避免返回局部变量的引用

// 错误示例
fn invalid_output<'a>() -> &'a String {
    &String::from("foo")  // 返回局部String的引用
}

// 解决方案1：返回静态引用
fn valid_output1() -> &'static str {
    "foo"
}

// 解决方案2：返回拥有的值
fn valid_output2() -> String {
    String::from("foo")
}

// 解决方案3：接受外部引用
fn valid_output3<'a>(s: &'a String) -> &'a String {
    s
}

结构体中的生命周期

当结构体包含引用时，必须显式声明生命周期：

#[derive(Debug)]
struct Borrowed<'a>(&'a i32);

#[derive(Debug)]
struct NamedBorrowed<'a> {
    x: &'a i32,
    y: &'a i32,
}

#[derive(Debug)]
enum Either<'a> {
    Num(i32),
    Ref(&'a i32),
}

结构体生命周期实践

#[derive(Debug)]
struct Example<'a, 'b> {
    a: &'a u32,
    b: &'b NoCopyType
}

fn main() {
    let var_a = 35;
    let example: Example;
    
    {
        let var_b = NoCopyType {};
        example = Example { a: &var_a, b: &var_b };
        // 这里var_b的生命周期必须至少持续到example使用结束
    }
    
    println!("(Success!) {:?}", example);
}

方法中的生命周期

为带有生命周期的结构体实现方法时，也需要正确注解生命周期：

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

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

生命周期省略规则

Rust编译器在某些常见模式中可以自动推断生命周期，称为"生命周期省略"。省略规则包括：

每个引用参数都有自己的生命周期
如果只有一个输入生命周期，它被赋给所有输出生命周期
如果有多个输入生命周期，但其中一个是&self或&mut self，则self的生命周期被赋给所有输出生命周期

省略示例

// 省略前
fn input<'a>(x: &'a i32) {
    println!("`annotated_input`: {}", x);
}

// 省略后
fn input(x: &i32) {
    println!("`annotated_input`: {}", x);
}

// 省略前
fn longest<'a, 'b>(x: &'a str, y: &'b str) -> &'a str {
    x
}

// 不能省略，因为有两个输入生命周期