struct - 为什么要在结构中对引用使用相同的生命周期？

Question

这个问题类似于When is it useful to define multiple lifetimes in a struct? ，但希望足够不同。该问题的答案很有帮助，但侧重于一种方法的优点(在结构中使用不同的生命周期作为引用)而不是缺点(如果有的话)。 This question, like that, 正在寻找有关如何在创建结构时选择生命周期的指导。

将此称为绑定(bind) 版本，因为x 和y 需要具有相同的生命周期:

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

并将其称为松散版本，因为生命周期可能会有所不同:

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

所引用问题的答案给出了一个明确的案例，其中客户端代码可以在给定松散 版本的情况下编译/运行，但对于绑定(bind) 版本将失败。是不是适用于绑定(bind) 版本的任何客户端代码也适用于松散 版本并且将保证同样安全(即安全)？反之则不然。从结构设计者的角度来看，宽松 版本显然更加灵活。鉴于这是一个好的/可接受的答案，指导可能是 - 在结构中使用引用时总是给它们不同的生命周期。

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

Answer 1

is there ever benefit to requiring references in a struct have the same lifetime

是的，它超越了结构。如果生命周期总是彼此不同，那么你就不能写这个函数:

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

这与链接的答案相反，它有评论:

you want to be able to take an aggregate value and split off parts of it after using it

在这种情况下，我们想要获取一个聚合值并统一它们。

在极少数情况下，您可能需要在不同的和统一的生命周期之间穿针引线:

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

虽然这在需要时很有用，但我无法想象如果我们每次都必须这样写，会爆发出怎样的哀嚎和咬牙切齿。

---

ignoring the extra typing

我不会。拥有

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

绝对优于

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

当您没有从额外的通用参数中受益时。