rust-course/advance/lifetime/basic

[sunface]

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

[brelance]

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

[sunface]

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

感谢鼓励 ：）

[stupidodie]

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

[fivestrong]

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

[sunface]

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

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

[stanhangzhou]

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

[zzps]

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

[yuhao00]

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

[watsonsong]

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

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

struct Bar {
    bar: &'static str,
}

[starrys147]

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

[haobohuiying]

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

[97Yates05]

也正有此问，即使结构体有多个引用，每个引用都要保证比结构体活的久，这是显而易见的吧，每个引用的生命周期都是明确的

[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学习路上撞得头破血流

[jyutjyu]

写得挺好。谢谢分享。

[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]

谢谢大佬，写的真好 ❤️

[justin-z0]

生命周期只是为了取悦编译器。这种事情有更好的实现方案吗？（比如引用计数？）
而不是把这种烧脑的操作留给程序员

[FleetingLore]

我很期待有人用数学之类的方法论证这在一定方向下不可能

[loccyliu]

oc就是引用计数的，后面也改成arc了

[zhouzuoji]

struct ImportantExcerpt<'a> {
part: &'a str,
}
结构体包含的借用类型字段显然要比结构体生命周期长，为什么不能自动标注呢？

[ZhiHuiProgram]

存在多个结构体字段，释放时间不一样的

[cyny666]

感觉看完后对输入生命周期和输出生命周期的区别不是理解很深。感觉应该指出一下若输出变量存活时间超过输出生命周期，编译器即认为会发生悬垂引用 导致报错

[yyyyysssssi7606]

太好了，小白最好的老师，希望能继续更新，进度条快一半了，真的就像看小说一样爽

[gqingc]

碉堡了

[fuochai]

生命周期 'static 意味着能和程序活得一样久，例如字符串字面量和特征对象

请问这里的特征对象是指什么意思？他们为什么会有生命周期的概念？
他们的生命周期不应该是不长于被引用的对象吗

[Steven-hsm]

生命周期，还有一点没看懂

[Rainy-day-y]

嘿，爷内存硬盘不值钱，每个变量都给我静态周期（doge）（好像和内存泄露就没区别了）

[loccyliu]

只要我内存够大，它就泄露不了吗

[coderyang123]

真的很好

[onns]

impl<'a: 'b, 'b> ImportantExcerpt<'a> {
    fn announce_and_return_part(&'a self, announcement: &'b str) -> &'b str {
        self.part
    }
}
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
    }
}

两者有细微区别？'b的在前者中是整个impl维度可用的？

[FleetingLore]

效果上好像没区别。

[FleetingLore]

生命周期都看明白了特质还没看懂（无语

[zanezhangzz]

补充一个我的疑惑，以及我找到的答案

为什么需要标注生命周期?

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

fn main() {
    let s1 = String::from("short");
    let result;
    {
        let s2 = String::from("loooong");
        result = longest(&s1, &s2);  // 这里编译器检查生命周期
    }
    // println!("{}", result);  // 错误：result 可能引用已 drop 的 s2
}

[loccyliu]

上面说的很清楚了，返回值R是引用类型，这个R要么从参数中来，要么要函数内引用新创建的变量而来，后者会造成野指针，直接报错，前者的参数不知道什么时候会释放，所以需要标注

[yikolemon]

写的不错，我这种猪鼻都能看懂

[gkatgithub]

作者厉害，感谢

[bxjg1987]

在手机端时代码里那个copy 按钮总是挡住代码内容了

[sunface]

好的，我 fix 下