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,
}

[Liusy12810]

‘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);
}

[tabris233]

以下代码可运行。

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);
}

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

谢谢大佬，写的真好 ❤️

[ziyoung]

生命周期 'static 意味着能和程序活得一样久

在 5.2 章节中实现一个 ThreadPool，

        let s = stream.unwrap();
        let f = || {
            handle_connection(s);

        };
        pool.execute(f);

f 被标记了 'static，如果 f 跟整个程序运行的一样长的话，那么不断会有新的 f 创建出来，老的 f 不会被销毁，内存将很快用完。

[ziyoung]

问了一下 GPT，属于是我的理解有问题。

需要注意的是，'static 生命周期并不意味着变量会始终存在于内存中。它只表示该变量在整个程序的运行期间有效，但 Rust 的所有权系统仍然负责内存的分配和释放。当不再需要具有 'static 生命周期的变量时，Rust 会自动释放它们占用的内存。

综上所述，当你在 Rust 中使用 thread::spawn(myFn) 时，并不意味着 myFn 会一直存在于内存中，但它的生命周期会延伸至整个程序的运行时间，直到不再需要它为止。

[defaultkavy]

很有趣又易懂的文章👍

[AndyLue]

感谢，居然读懂了

[fetasty]

引用上的生命周期标注是对引用指向的内存数据的作用域要求, 而不是对引用变量本身的要求

fn test<'a>(s1: &'a str, s2: &'a str) -> &'a str {
    if s1.len() >= s2.len() {
        s1
    } else {
        s2
    }
}

fn main() {
    let str1 = "abc".to_string();
    let str2 = "cde".to_string();
    let s3;
    {
        let s1 = &str1; // s1和s2的生命周期小于s3, 但是它们指向的数据生命周期大于s3
        {
            let s2 = &str2;
            s3 = test(s1, s2); // OK
        }
    }
    println!("{s3}");
}

[115130]

大佬牛逼，就你的书看得懂到底写的是个啥了

[lugeke]

有一点很容易推理出来：由于 &'a self 是被引用的一方，因此引用它的 &'b str 必须要活得比它短，否则会出现悬垂引用。因此说明生命周期 'b 必须要比 'a 小 这句话谁来解释下，被引用和引用是怎么得出的？

[glaceglace]

因为编译器需要知道这些，来确保函数调用后的引用生命周期分析
這一句話解釋了我所有的疑惑，比官方原文解釋得清楚多了

[BuzzWoods]

'static 好用，就会被滥用🐶

[hamsterjiang23]

// 延长局部变量生命周期？ -> 为啥还可以返回
       fn longest3<'a,'b,'c>(x : &'a str, y : &'b str) -> &'c str
       {
           let d : &str = "hello";
           d
       }
       let e : &str = &longest3(string1.as_str(), string2);
       println!("{}", e);

为啥这一段可以运行？

[hamsterjiang23]

        {
            if x.len() > y.len(){
                // WRONG
                // String::from("ccdd").as_str()
                // WRONG
                // let c : String = String::from("ccc");
                // &c
                let s : &str = "xxx";
                s
            }
            else {
                let s : &str = "yyy";
                s
            }
        }

看到三条消除规则好像都不满足

[hamsterjiang23]

看到最后懂了：字符串字面量具有全局的生命周期

[vince-1998]

看到这里感觉Rust为了应对自动垃圾回收和人工的内存管理，设置了一堆语言特性搞成一个Rust，感觉还不如C++直接释放好呢，语言特性太多了

[CodeGorgeous]

请问一下下面这段代码的理解是这样子的么:
方案1的s1生命周期是随着s的生命周期一致, 所以这段代码报错。
方案2是直接一个static静态生命周期, 所以不会报错。
这两个虽然传入demo都是一个字符串切片, 但方案1是基于一个变量进行一系列magic后产生的, 这时候&str已经隐式的和s的生命周期保持一致了, 而方案2则是直接性质的static生命周期不是基于某个变量衍生的

fn main() {
    let s1;
    {
        // 方案1:
        let s = String::from("Buyu");
        let s2 = &s[..]; 
        s1 = demo(s2);
        
        // 方案2:
        // let s: &str = "Buyu";
        // s1 = demo(s);
    }
    println!("The longest string is {}", s1);
}

// 显式写出生命周期
fn demo<'a>(s: &'a str) -> &'a str {
    s
}

不知道理解的对不对, 如有错误欢迎进行指正、学习、讨论

[YiiMus]

之前的集合章节。。。挺难的，其实一点也不简单

[fredlifeup]

第一次来看这个，的确太绕了！

[Icemans007]

对作者函数参数生命周期的描述，我始终不好理解： fn useless<'a>(first: &'a i32, second: &'a i32) {}

它的第一个参数 first 是一个指向 i32 类型的引用，具有生命周期 'a，该函数还有另一个参数 second，它也是指向 i32 类型的引用，并且同样具有生命周期 'a。此处生命周期标注仅仅说明，这两个参 first 和 second 至少活得和 'a 一样久，至于到底活多久或者哪个活得更久，抱歉我们都无法得知

我的疑问是怎么能要求函数内的局部变量 first 和 second 活得比 'a 更久？
能否这样理解？ first 和 second 本身是局部变量，函数调用完成它的生命周期就结束了，但给变量约束上 first: &'a i32 的生命周期标签，并不是对这变量本身，而是指变量所借用(引用)的对象的生命周期，它不比 'a 短！
例如，设法将局部变量所引用的对象生命周期变短，它就会报错

fn useless<'a>(first: &'a i32, second: &'a i32) {
	let tmp = 1;
	first = &tmp; // 如没有这代码，first的被引用对象的生命周期至少和 'a 一样长，接下改变了
}

他会报如下错误：

error[E0597]: `tmp` does not live long enough
 --> src/main.rs:4:10
  |
1 | fn useless<'a>(mut first: &'a i32, second: &'a i32) {
  |            -- lifetime `'a` defined here
2 |     
3 |     let tmp = 1;
  |         --- binding `tmp` declared here
4 |     first = &tmp; // 如没有这代码，first的被引用对象的生命周期至少和 'a 一样长，接下改变了
  |     --------^^^^
  |     |       |
  |     |       borrowed value does not live long enough
  |     assignment requires that `tmp` is borrowed for `'a`
5 | }
  | - `tmp` dropped here while still borrowed

至于'a取的是谁的生命周期长度，是看 first 和 second 两个谁短，谁短就是'a的生命周期

[Yu-Xiao-Sheng]

666,写的真好