Rust 生命周期的学习过程中，感觉总是道理讲得很多，但例子很少

网上有很多教学，包括 rust course 里对引用生命周期的各种自动添加规则讲了很多，但是看起来总让人感觉云里雾里，感觉总是告诉你说某某情况会编译报错，但只知道会错，教学也并未提供一种推荐的解决方案，导致最终解决问题的时候要不然是无脑注释'a 让编译器过了，要不然就是到处 copy()，重复着低水平代码。

像以下描述一个最简场景

use std::collections::HashMap;

fn index_t_words(sentence: &String) -> HashMap<&str, usize> {
    let mut result: HashMap<&str, usize> = HashMap::new();
    for (idx, word) in sentence.split(' ').enumerate() {
        if word.chars().nth(0).unwrap() == 't' {
            result.insert(word, idx);
        }
    }; result
}

fn main() {
    let sentence: String = String::from("magic happens in the test statement");
    println!("{:?}", index_t_words(&sentence))
}

它实现一个非常简单的需求，输入字符串"magic happens in the test statement"，查找其中以 t 开头的单词的位置（理论返回结果 {"the": 3, "test": 4}），上述代码编译器能通过，倒是没什么难理解的地方。但是如果再加入一个引用作为函数的参数，不参与任何逻辑执行，仅改变函数签名，此时按照经验编译器就会报错了，因为无法应用自动生命周期标注的规则，提示你需要人工解决。

实际生产中总是不可避免地出现这种情况，我们不可能总是保证函数或方法只有单一输入。

use std::collections::HashMap;

fn index_t_words(sentence: &String, bias: &str) -> HashMap<&str, usize> {
    let mut result: HashMap<&str, usize> = HashMap::new();
    for (idx, word) in sentence.split(' ').enumerate() {
        if word.chars().nth(0).unwrap() == 't' {
            result.insert(word, idx);
        }
    }; result
}

fn main() {
    let sentence: String = String::from("magic happens in the test statement");
    let bias = "spoiler";
    println!("{:?}", index_t_words(&sentence, &bias))
}

此时如果给函数签名无脑全标'a 就又能编译通过，

fn index_t_words<'a>(sentence: &'a String, bias: &'a str) -> HashMap<&'a str, usize> {}

说实话看完 rust course 也搞不太清楚发生了什么，理论上标注和资源释放不发生任何联系，为什么这么手动标了一下编译器就过了？

以至于再进阶一种情况，如果需要返回的变量所有权在函数内部，比如下面这种情况，在生产中也不少见，有时不可避免地资源的所有权在被调用的函数内部产生。因为函数结束时要释放资源，引用当然是无法带到函数外面的，会报错可以理解，一般来说解决方案也是通过 copy 把所有权转移出去。但是如果我们需要面临输出到多个位置（比如函数签名不光输出一个 HashMap ，还有另一个 Vec ，也同样引用&str ），如果不想每输出到一个结构就新拷贝一份的话，应该采用什么样的解决方案呢？

fn index_t_words() -> HashMap<&str, usize> {
    let sentence: String = String::from("magic happens in the test statement");
    let mut result: HashMap<&str, usize> = HashMap::new();
    for (idx, word) in sentence.split(' ').enumerate() {
        if word.chars().nth(0).unwrap() == 't' {
            result.insert(word, idx);
        }
    }; result
}

fn main() { println!("{:?}", index_t_words()) }

最后吐槽一下都说 rust 学习曲线比较陡峭，刚开始特别难，后面慢慢变简单。我个人体验上倒是感觉刚开始特别简单，越看感觉越难。。

GTim

2022-05-02 09:56:50 +08:00

Rust 的生命周期，只要牢记以下几点就可以了：

0. 重要的事情说三遍：生命周期标注只是帮助编译器检查，而不影响实际的程序运行。
1. 所有引用类型的参数都有独立的生命周期 'a 、'b 等。比如方法 /函数的参数，比如结构体的引用参数
2. 入参的生命周期决定了出参的生命周期，这是编辑器自动推测生命周期的基础。
2. 自动推测规则 1: 如果只有一个引用型输入，它的生命周期会赋给所有输出。
3. 自动推测规则 2: 如果有多个引用类型的参数，其中一个是 self ，那么它的生命周期会赋给所有输出。
4. 自动推测规则 3: 如果有多个引用，编译器无法知道开发者到底怎么使用出参，也就无法为出参指定生命周期。其实编译器能做到，如果那样，还不如上自动 GC.

第一条规则有一个重要的说明，就是引用类型的入参决定了整体的函数或结构体的生命周期。rust 结构体如果有构造函数，那么其实就是构造函数的入参的生命周期决定了结构体里引用成员的的生命周期，可惜的是，rust 没有，那么只能标注在结构体成员变量上

stein42

2022-05-02 10:15:15 +08:00

result 的 key 指向 sentence 的子字符串，所以 result 的生命周期不长于 sentence 。

result 的生命周期与 bias 无关，无脑加 'a 是有问题的，例如：

'''
use std::collections::HashMap;

fn index_t_words<'a>(sentence: &'a String, bias: &'a str) -> HashMap<&'a str, usize> {
let mut result: HashMap<&str, usize> = HashMap::new();
for (idx, word) in sentence.split(' ').enumerate() {
if word.chars().nth(0).unwrap() == 't' {
result.insert(word, idx);
}
};
result
}

fn main() {
let sentence: String = String::from("magic happens in the test statement");
let result = {
let bias: String = String::from("spoiler");
index_t_words(&sentence, &bias) // 错误!
};
println!("{:?}", result);
}
'''

正确的做法是：

'''
use std::collections::HashMap;

fn index_t_words<'a>(sentence: &'a String, bias: &str) -> HashMap<&'a str, usize> {
let mut result: HashMap<&str, usize> = HashMap::new();
for (idx, word) in sentence.split(' ').enumerate() {
if word.chars().nth(0).unwrap() == 't' {
result.insert(word, idx);
}
};
result
}

fn main() {
let sentence: String = String::from("magic happens in the test statement");
let result = {
let bias: String = String::from("spoiler");
index_t_words(&sentence, &bias)
};
println!("{:?}", result);
}
'''

只有一个参数时可以省略生命周期标注。

如果没有搞懂所有权、借用、生命周期这些概念，那还处于开始特别难的阶段。

stein42

2022-05-02 11:47:49 +08:00

Rust 的定位是和 C/C++ 一样运行效率高、没有垃圾回收，同时避免了 C/C++ 的很多错误，例如访问已释放的内存。

result 的 key 指向 sentence 的子字符串，所以 result 的生命周期应该不长于 sentence 。
否则先释放 sentence ，再访问 result ，就访问了已释放的内存，而这部分内存可能已经写入了其它数据。
C/C++ 这样做的话，可以通过编译，但运行时可能会出现莫名其妙的错误。
Rust 通过生命周期检查，可以避免这种错误。

'''
use std::collections::HashMap;

fn index_t_words<'a>(sentence: &'a String, bias: &str) -> HashMap<&'a str, usize> {
let mut result: HashMap<&str, usize> = HashMap::new();
for (idx, word) in sentence.split(' ').enumerate() {
if word.chars().nth(0).unwrap() == 't' {
result.insert(word, idx);
}
};
result
}

fn main() {
{
// 正确
let sentence: String = String::from("magic happens in the test statement");
let bias: String = String::from("spoiler");
let result = index_t_words(&sentence, &bias);
println!("{:?}", result);
}

{
// 错误，sentence 已经提前释放
let result = {
let sentence: String = String::from("magic happens in the test statement");
let bias: String = String::from("spoiler");
index_t_words(&sentence, &bias)
};
println!("{:?}", result);
}
}
'''