一个简单的测试用例来检查我对锈蚀寿命的理解

Question

刚刚读完《铁锈书》中关于生命的章节。

所有的东西都是有意义的，特别是一个主要的例子是下面的不会编译

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

fn main() {
    let string1 = String::from("long string is long");
    let result;
    {
        let string2 = String::from("xyz");
        result = longest(string1.as_str(), string2.as_str());
    }
    println!("The longest string is {}", result);
}

这是因为“我们告诉Rust，最长函数返回的引用的生存期与传入的引用的生存期中的较小者相同。因此，借用检查器不允许清单10-24中的代码具有无效引用。”在本章的另一部分中，“最长函数返回的引用的生存期与传入的引用的生存期中较小者相同。”

因此，很自然地，我会尝试给出我自己的简化示例，如下所示

fn foo<'a>(x: &'a str) -> &'a str {                                                
    x                                                                              
}                                                                                  
                                                                                   
fn main() {                                                                        
                                                                                   
    let y;                                                                         
    {                                                                              
        let x = "hello";                                                           
        y = foo(x);                                                                
    }                                                                              
    println!("y: {}", y);                                                          
}  

令我惊讶的是，这个编译和运行都很好。怎样当引用x超出范围时，引用y是否应该终止其生存期？

Answer 1

之所以这样做，是因为“hello”有一个静态生存期，x只是对该静态字符串的引用。x本身可以超出范围，它引用的资源有一个静态生命周期，因此生命周期足够长，可以容纳y。

如果我们改为让x指向std::String，我们会得到您期望的错误：

fn foo<'a>(x: &'a str) -> &'a str {                                                
    x                                                                              
}                                                                                  
                                                                                   
fn main() {                                                                        
                                                                                   
    let y;                                                                         
    {                                                                              
        let x = String::from("hello");                                                           
        y = foo(&x);                                                                
    }                                                                              
    println!("y: {}", y);                                                          
}  

error[E0597]: `x` does not live long enough
  --> src/main.rs:10:17
   |
10 |         y = foo(&x);                                                                
   |                 ^^ borrowed value does not live long enough
11 |     }                                                                              
   |     - `x` dropped here while still borrowed
12 |     println!("y: {}", y);                                                          
   |                       - borrow later used here