advance/lifetime/basic

[sunface]

https://course.rs/advance/lifetime/basic.html

[brelance]

谢谢大佬，这本书真的写的很好😉

[sunface]

谢谢大佬，这本书真的写的很好😉

感谢鼓励 ：）

[stupidodie]

感谢大佬 收获好大 弄明白了很多以前糊里糊涂的概念

[fivestrong]

感谢大佬，写的通俗易懂，比什么心智模型balabala一堆术语好太多了。

[sunface]

感谢大佬，写的通俗易懂，比什么心智模型balabala一堆术语好太多了。

通俗易懂是我们的第二写作目标，仅次于全面深入 😋

[stanhangzhou]

可惜本人文采不高！ NB 克拉斯！

[zzps]

我在想结构体上的生命周期为什么不能省略，在例子中结构体只有一个引用的时候，这个引用的有效性其实编译器是可以推断出来的啊

[sunface]

好问题！

有些问题其实技术原因并不是最主要的，更重要的是开发者和项目工程上的考虑

如果编译器要支持各种情况，那实现代码注定会非常复杂，这个会让编译器变得越来越难以开发维护，更不用说新入团队的成员，没有谁愿意看到这样的代码:)

因此，编译器团队会严格控制新特性的边界性。

[yuhao00]

生命周期也是签名的一部分，不希望省略吧。哪怕用’_也要把它写出来

[watsonsong]

感觉即使结构体只有一个引用，自动推断没法判断是不是static引用吧？

struct Foo<'a> {
    foo: &'a str,
}

struct Bar {
    bar: &'static str,
}

[starrys147]

‘a应该可以匹配’static的吧

[haobohuiying]

1. 明确声明引用的生命周期是编译器解决悬垂指针的默认方案
2. 生命周期消除，是为“明确声明引用” 一些便捷性增强
3. 结构体的声明周期可以生命周期消除，可能还没有实现。也能是工程复杂度问题，像@sunface说的。

[yunfengzh]

大佬，能不能写些实际的例子？比如

teacher {vector<student&>}
student{teacher&}
teacher实现几个方法add,remove,query
student实现get,set

另外所有的方法和结构体的生命周期均要求teacher大于student
teacher的一些方法可能会向下传递student引用或者涉及线程共享

[sunface]

好的，建议收到～感谢

[yunfengzh]

大佬，我还想补充几点
1)我看过你的链表文档的例子了，但是现实往往不是这样啊，就是我希望实现下面的样例
list_head{prev&, next&}
teacher {..., list_head classroom,}
2)对于linux源码，往往要求从一个成员地址反求所在对象的地址，就是已知
ateacher.classroom的地址求ateacher的地址，这个rust怎么办？

[ssbunny]

“借用检查”上面那段，写成“垂悬”了

[sunface]

额。。看到了，感谢提醒

[Jesse-666]

辛苦了大佬 没有你的文章我估计还要在 rust学习路上撞得头破血流

[SifungLei]

写得挺好。谢谢分享。

[Joneyao]

谢谢大佬，这本书真的写的很好😉

[ghostant-1017]

首先感谢下作者，一直看这本书学习，第一次发评论。
看到这一章，自己对Rust中的生命周期也做了一些思考，有一段我觉得作者对生命周期的解释不完全正确？

需要注意的是，编译器不知道 announcement 的生命周期到底多长，因此它无法简单的给予它生命周期 'a，而是重新声明了一个全新的生命周期 'b。
这里是可以声明announcement的生命周期为'a的，甚至不用注解。
理由就是书中提到的 “生命周期注解不改变其真正的生命周期”，全都标注成'a 只是意味着这些借用都会有一段'a 的存活时间。

以下代码可运行。
struct ImportantExcerpt<'a> {
part: &'a str,
}
impl<'a> ImportantExcerpt<'a> {
fn announce_and_return_part(&self, announcement: &str) -> &str {
println!("Attention please: {}", announcement);
self.part
}
}

fn main() {
let a = ImportantExcerpt{
part: "part",
};
let res = a.announce_and_return_part("hello world");
println!("{}",res);
}

以下代码也可运行：
struct ImportantExcerpt<'a> {
part: &'a str,
}
impl<'a> ImportantExcerpt<'a> {
fn announce_and_return_part(&'a self, announcement: &'a str) -> &'a str {
println!("Attention please: {}", announcement);
self.part
}
}

fn main() {
let a = ImportantExcerpt{
part: "part",
};
let res = a.announce_and_return_part("hello world");
println!("{}",res);
}

[TsGanT]

我理解注解成a是肯定没问题的，作者特地搞了一个b出来，就是为了解释，当我想要以b为生命周期返回时，那我门该怎么做？然后作者指出，我们必须必须要求a的生命周期比b长，那要做到a比b活的久，我们可以这样编写代码：这也就是作者提出了 'a: 'b的原因；

[ghost]

你知道为啥吗，因为你传进去的 "hello world" 是一个 'static 生命周期，在你举的这个例子里面，就算全部都标注为 'a ，编译器只选最短的那一个，而最短的那一个不是 announcement ，而是 &self ，因为 announcement 的生命周期是 'static

[ghost]

试试这个就知道了：

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

fn main() {
    let a = ImportantExcerpt { part: "part" };
    let res;
    {
        let announcement = "hello world".to_string();
        res = a.announce_and_return_part(&announcement);
    }
    println!("{}", res);
}

在这个例子里面，也是全部都标注为 'a ，编译器只选最短的那一个，很明显，announcement 活得最短，编译器选了 announcement 的生命周期，但是 announcement 活的时间没有返回值 res 的时间长，编译器就直接报错了：announcement does not live long enough

[cnsource]

let announcement = "hello world".to_string();
to_string()以后就不是字符串切片了，生命周期就不是static了，是这种写法降低了announcement 的生命周期长度，如果是字符串切片，即便这样写也是能够运行的，不知道这样理解对不对

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

fn main() {
    let a = ImportantExcerpt { part: "part" };
    let res;
    {
        res = a.announce_and_return_part("hello world");
    }
    println!("{}", res);
}

[w123ok]

能否请教一下，这个例子中b的生命周期是否大于a，是否与作者说的相反：
struct ImportantExcerpt<'a> {
part: &'a str,
}
impl<'a:'b, 'b> ImportantExcerpt<'a> {
fn announce_and_return_part(&'a self, announcement: &'b str) -> &'b str {
println!("Attention please: {}", announcement);
&self.part
}
}

fn main() {
let announcement = "hello world".to_string();
let res;
{
let zz = String::from("value");
let data = ImportantExcerpt { part: zz.as_str() };
res = data.announce_and_return_part(&announcement);
println!("{}", res);
}
let x = &announcement;
println!("-- {}", x);
}

[SethWen]

哈哈哈哈，rust 编译器还真是个磨人的小妖精~
感谢作者，写得真好~

[zhengtong0898]

感谢作者，这个例子举的很好，帮助我更好的理解了生命周期。

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

[caoxiemeihao]

谢谢大佬，写的真好 ❤️

[AllenWu233]

写得很好！

[sohide]

longest函数编译器完全可以做出判断返回值的生命周期，为什么不自动加上非要人去写

[Laplace825]

感觉这个例子可能更好

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

从返回值来看，这个函数的返回值的生命周期应该由self来决定，而不一定是announcement。
'b 不能比'a生命周期长，否则当'a的self被销毁时，'b仍然存在，从而导致悬垂引用, 是正确的。
但是实际上也让返回值的生命周期变相缩短到和announcement一样了，不信你可以将announcement的生命周期继续改为'b，然后尝试下面这段代码。

        let i = ImportantExcerpt { part: "part" };
        let s;
        {
            let novel = "Hello, What's your name?".to_string();
            s = i.announce_and_return_part(&novel);
        };
        println!("{:?}", s);

编译器当然要报错，毕竟s的生命周期和novel一样，而novel离开内部作用域后就销毁了。
而增加另一个'c且不显式约束指定他的生命周期长度，而是特意让返回值的生命周期和announcement不一样则可以避免掉这个问题。

[aakejiang]

'''struct ImportantExcerpt<'a> {
part: &'a str,
}
该生命周期标注说明，结构体 ImportantExcerpt 所引用的字符串 str 必须比该结构体活得更久。
'''
我觉得应该这样描述：ImportantExcerpt 结构体具有一个生命周期标注 'a。这意味着结构体中的字段 part 是一个对 'a 生命周期的字符串的引用。它告诉 Rust 编译器 part 字段中的字符串引用与创建 ImportantExcerpt 实例时提供的字符串切片的生命周期相同。

[leaf-potato]

静态生命周期举一个这样的例子，感觉会更加生动：

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

fn main() {
    let str1 = String::from("abcd");
    let result;
    {
        let str2 = String::from("xyz");
        result = longest(&str1, &str2);
    }
    // 编译错误，result可能会引用销毁的变量str2
    println!("The longest string is {}", result);
}

但将变量str2的类型改成&str后可以编译成功：

fn main() {
    let str1 = String::from("a");
    let result;
    {
        let str2 = "xyz"; // 关键改动
        result = longest(&str1, &str2);
    }
    println!("The longest string is {}", result);
}

这是因为str2是'static静态生命周期，从而变量result的生命周期与变量str1相同，最终调用println!会成功。

[nanjingfm]

鲁迅有点忙

[PigsyAK]

理解生命周期的基础概念：

• Lifetimes are another kind of generic that we’ve already been using.
• 生命周期是我们已经使用过的另一种泛型。

[jasperwanglin]

生命周期的标注像极了iOS的约束布局。
生命周期标注缺失或者标注不足 = iOS布局约束缺失或者不足;
生命周期标注计算 = iOS布局约束计算，有两个结果，无解和唯一解；
简单说就是多元一次方程组解的问题。
强行类比，让自己好理解 ：）

[jasperwanglin]

当然，Rust的生命周期不会改变引用对象的生命周期，但iOS的布局约束（autolayout）会影响视图的位置和大小。

[OldSaltFish]

个人认为函数的生命周期标注，是为了解决Rust的所有权特性引发的问题。当所有者不在作用域时，该值被删除。
在c++中，如果在函数内new一个对象，那么这个对象在函数结束后并不会被删除，而在Rust里面，由于这个对象离开了作用域，因此会被删除。而假如这个对象是函数的返回值，其外部很有可能使用变量来引用这个返回值，从而产生悬垂引用问题。而Rust编译器在一些方面不太智能，会让初学者产生这里为什么要写标注的疑惑。

[ShyunnY]

其实也不完全是rust不聪明，在runtime时候执行，我们也很难确定返回值的生命周期到底是取决于哪一个参数的引用。

[typed-sigterm]

然而也不显得 C++ 编译器足够聪明，因为 new 的设计意图就是让我们手动管理这块内存，编译器不敢管它

[xbsheng]

不做完不爽夫斯~~终于看完这节了 休息休息

[Pursue-LLL]

太强了，看AI，看官方文档看了两天也没整明白，大佬写的一下子就看明白了，幸好是在你写了圣经之后开始学的Rust

[GYMZSX]

幸苦了，带佬

[pindar7f01]

rust使用生命周期标注来防止引用失效。—— Mr.Krabs
生命周期的标注不改变任何实际的生命周期——鲁迅
如果一个对象的状态与某个引用关联，对象必须向编译器保证自身存活时的所有关联引用都有效——庞统

[buchenglei]

有一点让我很困惑的是文中的这个例子：

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

这里不是要求生命周期 'a 只少活的和 'b一样久么，为什么我下面的测试代码还是可以编译呢

fn test_1() {
    let mut announce = String::from("announcement"); // 这里应该是生命周期'b开始的地方

    {
        let part = String::from("this is part"); // 这里是生命周期'a开始的地方
        let i = ImportantExcerpt { part: &part };
        println!("{}", i.announce_and_return_part(&announce));
    } // 'a在这里结束

    // println!("{}", part); 很明显这里的part已经不能使用了
    // 这很明显不能满足 'a: 'b 这个生命周期的约束了吧
    announce.push('😯');
    println!("{}", announce); // 'b在这里结束
}

有没有大佬可以帮忙解释一下，是我哪里理解的有问题么

[buchenglei]

我想我应该搞明白了，生命周期并不等于变量的作用域，并且生命周期一定小于变量的作用域，因为生命周期是从获取引用的位置开始，到引用不再继续使用的位置结束，所以上面的代码其实是没有问题的

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

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

fn main() {
    let mut announce = String::from("announcement"); 

    {
        let part = String::from("this is part"); 
        let i = ImportantExcerpt { part: &part }; // 这里是生命周期'a开始的地方
        println!("{}", i.announce_and_return_part(&announce)); // 这里才是生命周期 'b 开始的地方
    } // 'a在这里结束

    announce.push('😯');
    println!("{}", announce); 
}

[ADkun]

拥有者的生命周期≠引用的生命周期。
即part的生命周期与&part的生命周期不一样，announce的生命周期与&announce的生命周期不一样。

fn test_1() {
    let mut announce = String::from("announcement");

    {
        let part = String::from("this is part");
        let i = ImportantExcerpt { part: &part }; // 这里是生命周期'a开始的地方
        println!("{}", i.announce_and_return_part(&announce)); // 这里应该是生命周期'b开始的地方，也是结束的地方
    } // 'a在这里结束
}

显然'a≥'b是满足的

[w123ok]

本书写的确实很好，很快就学到了本章。对于本章中的有一段，个人觉得有点晦涩了：
“函数的两个参数都至少跟 'a 活得一样久”，这句话很难理解，不是说不对，因为'a在前面的叙述中并没有解释它到底能活多久，
只知道它是个生命周期声明，所以一头雾水。因此我借问了gpt，解释如下，终于明白了，见谅勿怪：
在这个代码中，'a 是一个生命周期标注，它表示输入参数 x 和 y 的生命周期必须至少和返回值的生命周期一样长。具体来说，'a 的生命周期是由函数参数 x 和 y 的生命周期决定的。

章节原文：该函数签名表明对于某些生命周期 'a，函数的两个参数都至少跟 'a 活得一样久，同时函数的返回引用也至少跟 'a 活得一样久。