为什么你会在结构中使用相同的生命周期参考？

Question

此问题与When is it useful to define multiple lifetimes in a struct?类似，但希望不同。这个问题的答案是有帮助的，但是关注一种方法的优点（在struct中使用不同的生命期），而不是缺点（如果有的话）。这个问题就像这样，正在寻找如何在创建结构时选择生命周期的指导。

称此为绑在一起版本，因为X和ÿ需要具有相同的寿命：

struct Foo<'a> { 
    x: &'a i32, 
    y: &'a i32, 
} 

和称此为松散版本，因为寿命可以变化：

struct Foo<'a, 'b> { 
    x: &'a i32, 
    y: &'b i32, 
} 

对引用问题的回答给出了一个明确的例子：客户端代码可以编译/运行给定宽松版本，但将连接在一起版本失败。是不是说，对于适用于任何客户端代码捆绑在一起版本还将为宽松版工作，将得到保证的情况下一样安全（即安全的）？正面是不正确的。从结构设计师的角度来看，宽松的版本显然更加灵活。鉴于这是一个很好/被接受的答案，指导可能是 - 当在结构中使用引用总是给它们不同的生命期。

这个建议的缺点是什么，忽略了额外的输入？例如，是否有益于要求引用在结构体中具有相同的生命周期？

Answer 1

是否有过利于需要在结构中引用具有相同的寿命

是的，它超越了具有结构。如果寿命总是有别于对方，那么你可以不写这样的功能：

fn foo<'a, 'b>(a: &'a str, b: &'b str) -> &str { // What lifetime to return? 
    if (global_random_number() == 42) { a } else { b } 
} 

应用的结构，你可以有这样的事情：

struct EvenOrOdd<'a, 'b> { 
    even: &'a str, 
    odd: &'b str, 
} 

impl<'a, 'b> EvenOrOdd<'a, 'b> { 
    fn do_it(&self, i: u8) -> &str { 
     if i % 2 == 0 { 
      self.even 
     } else { 
      self.odd 
     } 
    } 
} 

注意的是，虽然这个编译，它不会返回一个字符串，它可以超过结构本身，这不是预期的。此代码失败，即使它应该能够工作：

fn foo<'a, 'b>(a: &'a str, b: &'b str) { 
    let result = { 
     EvenOrOdd { even: a, odd: b }.do_it(42) 
    }; 

    println!("{}", result); 
} 

这将统一寿命工作：

struct EvenOrOdd<'a> { 
    even: &'a str, 
    odd: &'a str, 
} 

impl<'a> EvenOrOdd<'a> { 
    fn do_it(&self, i: u8) -> &'a str { 
     if i % 2 == 0 { self.even } else { self.odd } 
    } 
} 

这是链接的答案相反，它有注释：

要能够采取的总值，并用它

之后分出其中的一部分

在这种情况下，我们要取一个合计值和统一他们。

在极少数情况下，您可能需要不同的线程和统一的寿命之间的针：

struct EvenOrOdd<'a, 'b: 'a> { 
    even: &'a str, 
    odd: &'b str, 
} 

impl<'a, 'b> EvenOrOdd<'a, 'b> { 
    fn do_it(&self, i: u8) -> &'a str { 
     if i % 2 == 0 { self.even } else { self.odd } 
    } 
} 

虽然这是非常有用的需要的时候，我无法想象的哀号和咬牙切齿会爆发，如果我们每次都必须这样写。

---

忽略了额外的输入

我不会。有

foo<'a>(Bar<'a>) 

绝对优于

foo<'a, 'b', 'c, 'd>(Bar<'a, 'b', 'c, 'd>) 

当你不是从额外的通用参数中受益。