练习题来自https://practice-zh.course.rs/lifetime/basic.html

1

/* 为 `i` 和 `borrow2` 标注合适的生命周期范围 */// `i` 拥有最长的生命周期，因为它的作用域完整的包含了 `borrow1` 和 `borrow2` 。
// 而 `borrow1` 和 `borrow2` 的生命周期并无关联，因为它们的作用域没有重叠
fn main() {let i = 3;                                             {                                                    let borrow1 = &i; // `borrow1` 生命周期开始. ──┐//                                                │println!("borrow1: {}", borrow1); //              │} // `borrow1` 生命周期结束. ──────────────────────────────────┘{                                                    let borrow2 = &i; println!("borrow2: {}", borrow2);               }                                                   
}   

我就不标注了，i的生命周期从main函数开始到结束。

2

/* 像上面的示例一样，为 `r` 和 `x` 标准生命周期，然后从生命周期的角度. */fn main() {  {let r;                // ---------+-- 'a//          |{                     //          |let x = 5;        // -+-- 'b  |r = &x;           //  |       |}                     // -+       |//          |println!("r: {}", r); //          |}                         // ---------+
}

和上面的代码一样，这段代码是无法通过编译的，r的生命周期大于其引用的x。这意味着一旦x被释放，r将成为一个悬垂引用。

3

/* 添加合适的生命周期标注，让下面的代码工作 */
fn longest(x: &str, y: &str) -> &str {if x.len() > y.len() {x} else {y}
}fn main() {}

答案：

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

原则1：每一个引用参数都会获得独特的生命周期
然后没有了，此时编译器无法推导出返回值引用的生命周期，这就需要我们手动标注。因为我们将返回值的生命周期标注为a，就必须让返回值的生命周期小于入参的（否则入参被释放了，就出现悬垂引用的问题了）

另外，类似的生命周期问题在C++中也是存在的：

int &larger(int &a, int &b)
{return a > b ? a : b;
}int main()
{int a = 1;int& res = a;{int b = 2;res = larger(a, b);}cout << res << endl;return 0;
}

注意，C++是强类型语言，因此res的类型必须提前声明（即使用auto，那也得是auto&）。另外，C++中的引用声明时就必须初始化。

当b为更大值时，这里就会出现悬垂引用的问题。但在我编译这段代码并反复运行时，我没有看到异常输出。我的C++水平还没法解释为什么。

4

使用三种方法修复下面的错误

fn invalid_output<'a>() -> &'a String { &String::from("foo") 
}fn main() {
}

第一种当然是最原始的方法，转移所有权：

fn invalid_output() ->  String { String::from("foo") 
}

新增一个入参也是不错的选择，甚至可以省略生命周期标注符号：

fn invalid_output(s: &String) -> &String {s
}

第三种我倒是没想到，看了答案才意识到，我也可以直接返回硬编码的&str：

fn invalid_output() -> &'static str { "foo"
}

5

// `print_refs` 有两个引用参数，它们的生命周期 `'a` 和 `'b` 至少得跟函数活得一样久
fn print_refs<'a, 'b>(x: &'a i32, y: &'b i32) {println!("x is {} and y is {}", x, y);
}/* 让下面的代码工作 */
fn failed_borrow<'a>() {let _x = 12;// ERROR: `_x` 活得不够久does not live long enoughlet y: &'a i32 = &_x;// 在函数内使用 `'a` 将会报错，原因是 `&_x` 的生命周期显然比 `'a` 要小// 你不能将一个小的生命周期强转成大的
}fn main() {let (four, nine) = (4, 9);print_refs(&four, &nine);// 这里，four 和 nice 的生命周期必须要比函数 print_refs 长failed_borrow();// `failed_borrow`  没有传入任何引用去限制生命周期 `'a`，因此，此时的 `'a` 生命周期是没有任何限制的，它默认是 `'static`
}

Rust处理这类问题的一个基本原则是：调用者的生命周期一定要比被调用的短，否则就会出现空的调用。

fn failed_borrow<'a>() {let _x = 12;// ERROR: `_x` 活得不够久does not live long enoughlet y: & i32 = &_x;// 在函数内使用 `'a` 将会报错，原因是 `&_x` 的生命周期显然比 `'a` 要小// 你不能将一个小的生命周期强转成大的
}

6

/* 增加合适的生命周期标准，让代码工作 */// `i32` 的引用必须比 `Borrowed` 活得更久
#[derive(Debug)]
struct Borrowed(&i32);// 类似的，下面两个引用也必须比结构体 `NamedBorrowed` 活得更久
#[derive(Debug)]
struct NamedBorrowed {x: &i32,y: &i32,
}#[derive(Debug)]
enum Either {Num(i32),Ref(&i32),
}fn main() {let x = 18;let y = 15;let single = Borrowed(&x);let double = NamedBorrowed { x: &x, y: &y };let reference = Either::Ref(&x);let number    = Either::Num(y);println!("x is borrowed in {:?}", single);println!("x and y are borrowed in {:?}", double);println!("x is borrowed in {:?}", reference);println!("y is *not* borrowed in {:?}", number);
}

我得去查查Rust有没有什么编码规范，规定了生命周期的命名。

#[derive(Debug)]
struct Borrowed<'a>(&'a i32);// 类似的，下面两个引用也必须比结构体 `NamedBorrowed` 活得更久
#[derive(Debug)]
struct NamedBorrowed<'b> {x: &'b i32,y: &'b i32,
}#[derive(Debug)]
enum Either <'c>{Num(i32),Ref(&'c i32),
}

7

/* 让代码工作 */#[derive(Debug)]
struct NoCopyType {}#[derive(Debug)]
struct Example<'a, 'b> {a: &'a u32,b: &'b NoCopyType
}fn main()
{ let var_a = 35;let example: Example;{let var_b = NoCopyType {};/* 修复错误 */example = Example { a: &var_a, b: &var_b };}println!("(Success!) {:?}", example);
}

b的生命周期太短了，打印example时b已经被释放了。

fn main()
{ let var_a = 35;let example: Example;let var_b = NoCopyType {};{/* 修复错误 */example = Example { a: &var_a, b: &var_b };}println!("(Success!) {:?}", example);
}

8

#[derive(Debug)]
struct NoCopyType {}#[derive(Debug)]
#[allow(dead_code)]
struct Example<'a, 'b> {a: &'a u32,b: &'b NoCopyType
}/* 修复函数的签名 */
fn fix_me(foo: &Example) -> &NoCopyType
{ foo.b }fn main()
{let no_copy = NoCopyType {};let example = Example { a: &1, b: &no_copy };fix_me(&example);println!("Success!")
}

加个生命周期标识符就行了，至于是否真能活到那时候，谁知道。

fn fix_me<'a>(foo: &'a Example) -> &'a NoCopyType
{ foo.b }

9

/* 添加合适的生命周期让下面代码工作 */
struct ImportantExcerpt {part: &str,
}impl ImportantExcerpt {fn level(&'a self) -> i32 {3}
}fn main() {}

答案

struct ImportantExcerpt<'a> {part: &'a str,
}impl<'a> ImportantExcerpt<'a> {fn level(&'a self) -> i32 {3}
}

10

/* 移除所有可以消除的生命周期标注 */fn nput<'a>(x: &'a i32) {println!("`annotated_input`: {}", x);
}fn pass<'a>(x: &'a i32) -> &'a i32 { x }fn longest<'a, 'b>(x: &'a str, y: &'b str) -> &'a str {x
}struct Owner(i32);impl Owner {fn add_one<'a>(&'a mut self) { self.0 += 1; }fn print<'a>(&'a self) {println!("`print`: {}", self.0);}
}struct Person<'a> {age: u8,name: &'a str,
}enum Either<'a> {Num(i32),Ref(&'a i32),
}fn main() {}

由于入参只有一个引用，引用只有一个生命周期，第一个、第二个消除：

fn nput(x: &i32) {println!("`annotated_input`: {}", x);
}fn pass(x: &i32) -> &i32 { x }

参数含有self时（即方法），self的生命周期会赋给全部输出，这里也消除：

struct Owner(i32);impl Owner {fn add_one(&mut self) { self.0 += 1; }fn print(&self) {println!("`print`: {}", self.0);}
}