Rust 为什么你会为 struct 中的引用使用相同的生命周期

要求 struct 中的引用具有相同的生存期有什么好处吗

是的，它不仅仅是一个 struct .如果生命周期总是彼此不同，则无法编写此函数:

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

应用于struct，可以有如下内容:

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

请注意，虽然这是编译，但它是doesn't return a string that can outlive the structure itself，这不是预期的.此代码失败，即使它应该能够工作:

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

这与链接答案相反，链接答案中有这样的 comments :

您希望能够获取一个聚合值，并在使用该值后将其拆分

在这种情况下，我们要取一个聚合值，并将其设置为unify.

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

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

当你不能从额外的泛型参数中获益时.