1
2
3
4
5
6
7
8

// 这是一个带生命周期标注的函数签名
fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
    if x.len() > y.len() {
        x
    } else {
        y
    }
}

1
2
3
4
5
6
7
8
9

fn mix_and_match<'a, 'b>(x: &'a str, y: &'b str) -> &'a str {
    println!("混搭一下：{} 和 {}", x, y); // 混搭一下：hello 和 world
    x // 返回 x，所以返回类型只需要 'a
}

fn main() {
    let result = mix_and_match("hello", "world");
    println!("结果是：{}", result); // 结果是：hello
}

1
2
3
4
5
6
7
8

// 三个独立的生命周期，各玩各的
fn three_some<'a, 'b, 'c>(s1: &'a str, s2: &'b str, s3: &'c str) {
    println!("三个独立生命周期：{} / {} / {}", s1, s2, s3);
}

fn main() {
    three_some("a", "b", "c"); // 三个独立生命周期：a / b / c
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

// T: 'a 意味着类型 T 中不能有任何生命周期短于 'a 的引用
// ⭐ 注意：'a 必须在泛型参数表里先声明出来，否则编译器会报
//    error[E0261]: use of undeclared lifetime name `'a`
fn requires_outlives<'a, T>(value: &'a T) -> &'a T
where
    T: 'a,
{
    value
}

fn main() {
    let n = 42;
    println!("{}", requires_outlives(&n)); // 42

    // 下面这种才是 T: 'a 真正想拦下来的情况：
    // 局部字符串活不过 'a，编译器不会放行
    // let short = String::from("短命");
    // let r = requires_outlives(&short.as_str());
}

1
2
3
4
5
6
7
8
9

// 返回第一个参数，不关心第二个参数的生命周期
fn first_one<'a, 'b>(s1: &'a str, _s2: &'b str) -> &'a str {
    s1
}

fn main() {
    let result = first_one("hello", "world");
    println!("第一个是：{}", result); // 第一个是：hello
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

// 返回值的生命周期跟第二个参数 'b 绑定（因为我们返回的是 y）
fn combine<'a, 'b>(_x: &'a str, y: &'b str) -> &'b str {
    // 注意：这里我们实际上返回的是 y，不是 x
    // 所以返回类型是 &'b，不是 &'a
    y
}

fn main() {
    let result = combine("first", "second");
    println!("结果是：{}", result); // 结果是：second
}

1
2
3
4
5
6
7
8
9

// 你写的：
fn two_inputs(x: &str, y: &str) { }

// 编译器眼里等价于（'a 和 'b 是两个不同的生命周期）：
fn two_inputs<'a, 'b>(x: &'a str, y: &'b str) { }

// ⭐ 这一条是"分成两个"，不是"共用同一个"，
//    所以下面这种签名照样编译不过（返回类型不知道该用哪个）：
// fn pick(x: &str, y: &str) -> &str { x }   // error[E0106]

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

// 只有一个输入引用 → 输出自动取它的生命周期
fn first_word(s: &str) -> &str {
    s.split_whitespace().next().unwrap_or("")
}
// 等价于 fn first_word<'a>(s: &'a str) -> &'a str

// 显式标注（没有省略）时，这条规则同样适用：
// 只要"有效的输入生命周期"只有一个，输出省略后也取它
fn first_word2<'a>(s: &'a str) -> &str {
    first_word(s)
}
// ⚠️ 不过较新的 rustc 会对这种"输入写了 'a、输出又省略"的写法给出
//    mismatched_lifetime_syntaxes 警告（说的是同一个生命周期，却用了两种写法）。
//    能编译，但为了可读性，实际项目里建议写全：-> &'a str

1
2
3
4
5
6
7
8

struct X;

impl X {
    // 编译器自动推断为 fn bar<'a>(&'a self) -> &'a str
    fn bar(&self) -> &str {
        "hello"
    }
}

1
2
3
4
5
6
7
8
9

// 等价于 fn first_char<'a>(s: &'a str) -> &'a str
fn first_char(s: &str) -> &str {
    &s[..1]
}

fn main() {
    let result = first_char("hello");
    println!("第一个字符是：{}", result); // 第一个字符是：h
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

// 这个函数无法省略生命周期标注
// 编译器报错：E0106
fn ambiguous<'a, 'b>(x: &'a str, y: &'b str) -> &str {
    // 编译器不知道返回的是 x 还是 y
    // 所以无法确定返回引用的生命周期
    if x.len() > y.len() {
        x
    } else {
        y
    }
}

1
2
3
4
5
6
7
8
9

fn ambiguous<'a, 'b>(x: &'a str, y: &'b str) -> &'a str {
    // 明确告诉编译器，我们返回的是 x，所以生命周期是 'a
    if x.len() > y.len() {
        x
    } else {
        y // 等等，这里返回的是 y，它的生命周期是 'b，不是 'a！
           // 编译器会报错！因为你承诺了返回 'a，但实际可能返回 'b
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

fn longest_with_announcement<'a, T>(
    x: &'a str,
    y: &'a str,
    ann: T,
) -> &'a str
where
    T: std::fmt::Display,
{
    println!("公告：{}", ann); // 公告：这是一个比较
    if x.len() > y.len() {
        x
    } else {
        y
    }
}

fn main() {
    let result = longest_with_announcement("short", "very_long", "这是一个比较");
    println!("更长的那个是：{}", result); // 更长的那个是：very_long
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

// 这里 'long 至少要活得跟 'short 一样久
fn longest<'long: 'short, 'short>(
    x: &'long str,
    y: &'short str,
) -> &'short str {
    if x.len() > y.len() {
        x // ✅ 这行是完全合法的，不会报错！
    } else {
        y
    }
}

fn main() {
    println!("{}", longest("aa", "b")); // aa
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

// 把两个参数的约束关系写反，编译器立刻不答应
fn bad_return<'long, 'short: 'long>(
    x: &'long str,
    _y: &'short str,
) -> &'short str {
    x // ❌ 编译不通过
      // 因为此时并没有 "x 比返回值活得久" 的保证
}

fn main() {}

1
2
3
4
5
6
7
8

// 'a: 'b 意味着 'a 必须活得比 'b 久（或一样久）
struct Wrapper<'a, 'b>
where
    'a: 'b,
{
    data: &'a str,           // 这个引用活得久
    maybe_shorter: &'b str, // 这个引用可以活得短
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

// ✓ 正确：返回的生命周期来自输入参数
fn first_word(s: &str) -> &str {
    s.split_whitespace().next().unwrap_or("")
}

// ✗ 错误：制造悬空引用
fn dangling() -> &str {
    let s = String::from("hello");
    &s // 错误！s 是局部变量，函数结束就被销毁了
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

// 返回第一个参数的生命周期
fn first<'a>(x: &'a str, _y: &str) -> &'a str {
    x
}

// 返回两个参数中较短的生命周期（因为我们不确定返回哪个）
fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
    if x.len() > y.len() {
        x
    } else {
        y
    }
}

fn main() {
    let s1 = String::from("long string");
    let result;
    {
        let s2 = String::from("xyz");
        result = longest(s1.as_str(), s2.as_str());
        println!("最长的是：{}", result); // 最长的是：long string
    }

    // ⚠️ 这里如果把 result 拿到 s2 的作用域之外使用，会编译失败！
    // println!("{}", result);   // ❌ error[E0597]: `s2` does not live long enough
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

// 返回值只来自 x，y 的生命周期与返回值无关
fn first<'a>(x: &'a str, _y: &str) -> &'a str {
    x
}

fn main() {
    let s1 = String::from("long string");
    let result;
    {
        let s2 = String::from("xyz");
        result = first(s1.as_str(), s2.as_str());
    } // s2 在这里被 drop，但已经没关系了
    println!("{}", result); // ✅ 编译通过：long string
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

// 编译器自动推断：
// - 返回值来自 x，所以返回生命周期 = x 的生命周期
// - y 跟返回生命周期无关
fn get_x<'a>(x: &'a str, y: &str) -> &'a str {
    x // 明确返回 x
}

fn main() {
    let result = get_x("hello", "world");
    println!("{}", result); // hello
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

// 经典例子：ImportantExcerpt 结构体
struct ImportantExcerpt<'a> {
    part: &'a str, // 必须标注生命周期 'a
}

fn main() {
    let novel = String::from("_call me Ishmael. Years ago...");
    let first_sentence = novel.split('.').next().unwrap();
    
    let excerpt = ImportantExcerpt {
        part: first_sentence,
    };
    
    println!("摘录：{}", excerpt.part); // 摘录：_call me Ishmael
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

struct Holder<'a> {
    data: &'a str,
}

fn main() {
    // 正确：提供活得够久的引用
    let static_string = "我活得很久很久";
    let holder1 = Holder { data: static_string };
    println!("holder1: {}", holder1.data); // holder1: 我活得很久很久
    
    // 错误示范：
    let local_string = String::from("我马上就要被销毁了");
    // let holder2 = Holder { data: &local_string }; // 编译错误！
    // local_string 是局部变量，函数结束就 drop 了
    // 但 Holder 的生命周期不知道有多长，编译器不让你冒险
    
    // 正确示范：在同一个作用域内使用
    {
        let short_lived = String::from("我活不长");
        let holder2 = Holder { data: &short_lived };
        println!("holder2: {}", holder2.data); // holder2: 我活不长
    } // short_lived 和 holder2 在这里一起 drop
    
    println!("holder1 还在：{}", holder1.data); // holder1 还在：我活得很久很久
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

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

impl<'a> Excerpt<'a> {
    // 这个方法只使用了 self 的引用
    // 编译器自动推断返回生命周期 = self 的生命周期
    fn announce_and_return(&self, announcement: &str) -> &str {
        println!("公告：{}", announcement); // 公告：即将返回
        self.part
    }
}

fn main() {
    let text = String::from("call me Ishmael...");
    let excerpt = Excerpt { part: &text };
    let result = excerpt.announce_and_return("即将返回");
    println!("返回的内容是：{}", result); // 返回的内容是：call me Ishmael...
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56

struct Parser<'a> {
    input: &'a str,
    position: usize,
}

impl<'a> Parser<'a> {
    // 构造函数
    fn new(input: &'a str) -> Self {
        Parser {
            input,
            position: 0,
        }
    }
    
    // 解析下一个单词
    // ⭐ 返回的是 &'a str（绑定在 input 上），而不是 &self，
    //    所以返回之后 self 的借用就结束了，调用方可以接着 &mut self。
    fn next_word(&mut self) -> Option<&'a str> {
        let bytes = self.input.as_bytes();

        // 第一步：跳过前导空白（少了这一步，第二次调用就会立刻返回 None）
        while self.position < bytes.len() && bytes[self.position].is_ascii_whitespace() {
            self.position += 1;
        }

        // 第二步：扫到下一个空白为止
        let start = self.position;
        while self.position < bytes.len() && !bytes[self.position].is_ascii_whitespace() {
            self.position += 1;
        }

        if start == self.position {
            None // 已经到结尾了
        } else {
            Some(&self.input[start..self.position])
        }
    }
    
    // 重置解析器
    fn reset(&mut self) {
        self.position = 0;
    }
}

fn main() {
    let text = "hello world rust";
    let mut parser = Parser::new(text);
    
    println!("第一个词：{:?}", parser.next_word()); // 第一个词：Some("hello")
    println!("第二个词：{:?}", parser.next_word()); // 第二个词：Some("world")
    println!("第三个词：{:?}", parser.next_word()); // 第三个词：Some("rust")
    println!("第四个词：{:?}", parser.next_word()); // 第四个词：None
    
    parser.reset();
    println!("重置后第一个词：{:?}", parser.next_word()); // 重置后第一个词：Some("hello")
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

// 定义一个带生命周期参数的 trait
trait Printable<'a> {
    fn print_content(&self, content: &'a str);
}

// 为 i32 实现这个 trait
impl<'a> Printable<'a> for i32 {
    fn print_content(&self, content: &'a str) {
        println!("数字 {} 说：{}", self, content); // 数字 42 说：Hello, Rust!
    }
}

fn main() {
    let num: i32 = 42;
    num.print_content("Hello, Rust!");
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

trait Runner {
    // 返回值的生命周期跟 self 绑定
    fn get_name(&self) -> &str;
}

struct Athlete {
    name: String,
}

impl Runner for Athlete {
    fn get_name(&self) -> &str {
        &self.name
    }
}

fn main() {
    let athlete = Athlete {
        name: String::from("博尔特"),
    };
    println!("运动员名字：{}", athlete.get_name()); // 运动员名字：博尔特
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

trait Formatter<'a> {
    fn format(&self, input: &'a str) -> String;
}

struct Uppercase;

impl<'a> Formatter<'a> for Uppercase {
    fn format(&self, input: &'a str) -> String {
        input.to_uppercase()
    }
}

struct Reverse;

impl<'a> Formatter<'a> for Reverse {
    fn format(&self, input: &'a str) -> String {
        input.chars().rev().collect()
    }
}

fn main() {
    let upper = Uppercase;
    let reverse = Reverse;
    
    let text = "hello world";
    
    println!("大写：{}", upper.format(text)); // 大写：HELLO WORLD
    println!("反转：{}", reverse.format(text)); // 反转：dlrow olleh
}

1
2
3
4
5

fn main() {
    // 字符串字面量是 'static 的，因为它们被硬编码到二进制里
    let s: &'static str = "我是在程序诞生时就存在的！";
    println!("{}", s); // 我是在程序诞生时就存在的！
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

// 这个函数接受任何不包含短生命周期引用的类型
fn print_static<T>(value: T)
where
    T: std::fmt::Debug + 'static,
{
    println!("{:?}", value);
}

fn main() {
    // OK：i32 是 'static 的
    print_static(42_i32); // 42
    
    // OK：String 拥有自己的数据，不包含短生命周期引用
    print_static(String::from("hello")); // "hello"
    
    // 错误：&str 可能是非 'static 的（如果是来自局部 String 的引用）
    // let local = String::from("local");
    // print_static(&local); // 编译错误！
    
    // OK：字符串字面量是 'static 的
    print_static(&"可以，因为是字面量"); // "可以，因为是字面量"
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

use std::fmt::Display;

fn print_if_static<T>(value: &T)
where
    T: Display + 'static,
{
    println!("这是一个 'static 类型：{}", value);
}

fn main() {
    print_if_static(&42); // 这是一个 'static 类型：42
    print_if_static(&"字符串字面量"); // 这是一个 'static 类型：字符串字面量
    
    // 注意：如果你传入一个局部变量的引用，编译会失败
    // let s = String::from("hello");
    // print_if_static(&s); // 错误！因为 &s 不是 'static
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

use std::marker::PhantomData;

// 这是一个"拥有" T 的结构体，但实际上 T 并不被存储
// PhantomData<T> 告诉编译器："把这个结构体当作拥有 T 来对待"
struct Owned<T> {
    _marker: PhantomData<T>, // _marker 下划线前缀表示"不会被使用"
}

fn main() {
    let _owned_i32 = Owned::<i32> { _marker: PhantomData };
    let _owned_string = Owned::<String> { _marker: PhantomData };
    println!("幽灵数据创建成功！");
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

use std::marker::PhantomData;

// 自定义 Box，只用于演示 PhantomData 的用法
struct MyBox<T> {
    data: *mut T, // 裸指针，不受借用检查器约束
    _marker: PhantomData<T>, // 标记我们"拥有" T
}

impl<T> MyBox<T> {
    fn new(value: T) -> Self {
        MyBox {
            data: Box::into_raw(Box::new(value)),
            _marker: PhantomData,
        }
    }
    
    fn as_ref(&self) -> &T {
        // 安全：因为 MyBox 拥有 T 的所有权，所以我们可以解引用
        unsafe { &*self.data }
    }
}

impl<T> Drop for MyBox<T> {
    fn drop(&mut self) {
        // 安全释放内存
        // ⭐ 用 drop(...) 包一层而不是直接丢弃返回值：
        //    Box::from_raw 的返回值带 #[must_use]，
        //    直接写 `Box::from_raw(self.data);` 虽然也会释放内存，
        //    但编译器会给出 unused_must_use 警告。
        unsafe {
            drop(Box::from_raw(self.data));
        }
    }
}

fn main() {
    let box_i32 = MyBox::new(42);
    println!("MyBox 里的值：{}", box_i32.as_ref()); // MyBox 里的值：42
    // drop(box_i32) 会在作用域结束时自动调用 Drop
    println!("作用域结束，MyBox 被正确 drop");
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

use std::marker::PhantomData;

struct RefOwner<'a, T> {
    _marker: PhantomData<&'a T>, // 标记我们持有一个 &T
}

fn main() {
    let value = 42;
    let owner = RefOwner::<i32> { _marker: PhantomData };
    println!("RefOwner 创建成功");
    println!("值还在：{}", value); // 值还在：42
}

1
2
3
4

let mut v = vec![1, 2, 3];
let first = &v[0]; // 借用开始
println!("{}", first); // 使用引用
v.push(4); // 这里会报错，即使 first 后面不再使用了

1
2
3
4
5
6
7

fn main() {
    let mut v = vec![1, 2, 3];
    let first = &v[0]; // 借用开始
    println!("{}", first); // 使用引用
    v.push(4); // NLL: 编译器知道 first 在这之后不再使用，所以允许
    println!("vec 现在是：{:?}", v); // vec 现在是：[1, 2, 3, 4]
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

fn main() {
    let mut map = std::collections::HashMap::new();
    map.insert("a", 1);
    
    // 在 NLL 之前，这里的借用会持续到作用域结束
    // 在 NLL 之后，编译器知道 get 返回的引用只在这个 if 块里使用
    if let Some(value) = map.get("a") {
        println!("找到了：{}", value); // 找到了：1
    } // 借用在这里结束
    
    // 所以这里可以继续修改 map
    map.insert("b", 2);
    println!("map: {:?}", map); // map: {"a": 1, "b": 2}
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

use std::collections::HashMap;

// 想要：有就返回已有值的可变引用，没有就插入默认值再返回它
fn get_or_insert<'r, K, V>(
    map: &'r mut HashMap<K, V>,
    key: K,
    default: V,
) -> &'r mut V
where
    K: std::hash::Hash + Eq + Clone,
{
    match map.get_mut(&key) {
        Some(v) => v,
        None => {
            // ❌ 这里会报错：map 已经被上面的 get_mut 借走了
            map.insert(key.clone(), default);
            map.get_mut(&key).unwrap()
        }
    }
}

fn main() {}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

use std::collections::HashMap;

fn get_or_insert<'r, K, V>(map: &'r mut HashMap<K, V>, key: K, default: V) -> &'r mut V
where
    K: std::hash::Hash + Eq + Clone,
{
    // 绕法一：先用不可变借用判断存在性，把"是否插入"决定完，再去做可变借用
    if !map.contains_key(&key) {
        map.insert(key.clone(), default);
    }
    map.get_mut(&key).unwrap()

    // 绕法二：用 entry API（标准库专门为这个场景设计的，最推荐）
    // map.entry(key).or_insert(default)
}

fn main() {
    let mut m: HashMap<&str, i32> = HashMap::new();
    println!("{}", get_or_insert(&mut m, "a", 1)); // 1
    println!("{}", get_or_insert(&mut m, "a", 99)); // 1（已存在，不会被覆盖）
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

// 注意：Polonius 还在开发中，你需要使用 nightly 版本的 Rust
// 并通过 -Z 参数（只有 nightly 才接受）来启用它

// ⚠️ 注意 -Zpolonius 是传给 rustc 的，不是 cargo 的子命令参数。
// 正确做法是通过 RUSTFLAGS 转发：
// RUSTFLAGS="-Zpolonius" cargo +nightly build
//
// 或者直接调用 cargo rustc 把参数交给 rustc：
// cargo +nightly rustc -- -Zpolonius

fn main() {
    println!("等待 Polonius 稳定...");
}