我们来看看a simple implementation of this：
struct Parent {
count: u32,
}
struct Child<'a> {
parent: &'a Parent,
}
struct Combined<'a> {
parent: Parent,
child: Child<'a>,
}
impl<'a> Combined<'a> {
fn new() -> Self {
let parent = Parent { count: 42 };
let child = Child { parent: &parent };
Combined { parent, child }
}
}
fn main() {}
这将失败并出现错误：
error[E0515]: cannot return value referencing local variable `parent`
--> src/main.rs:19:9
|
17 | let child = Child { parent: &parent };
| ------- `parent` is borrowed here
18 |
19 | Combined { parent, child }
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ returns a value referencing data owned by the current function
error[E0505]: cannot move out of `parent` because it is borrowed
--> src/main.rs:19:20
|
14 | impl<'a> Combined<'a> {
| -- lifetime `'a` defined here
...
17 | let child = Child { parent: &parent };
| ------- borrow of `parent` occurs here
18 |
19 | Combined { parent, child }
| -----------^^^^^^---------
| | |
| | move out of `parent` occurs here
| returning this value requires that `parent` is borrowed for `'a`
要完全理解这个错误，你必须考虑如何
值在内存中表示，当您移动时会发生什么
那些价值观。让我们用一些假设来注释Combined::new
显示值所在位置的内存地址：
let parent = Parent { count: 42 };
// `parent` lives at address 0x1000 and takes up 4 bytes
// The value of `parent` is 42
let child = Child { parent: &parent };
// `child` lives at address 0x1010 and takes up 4 bytes
// The value of `child` is 0x1000
Combined { parent, child }
// The return value lives at address 0x2000 and takes up 8 bytes
// `parent` is moved to 0x2000
// `child` is ... ?
child 会发生什么？如果值只是像parent 一样移动
是，那么它将引用不再保证的内存
有一个有效的值。允许存储任何其他代码
内存地址 0x1000 处的值。假设它是访问该内存
整数可能导致崩溃和/或安全错误，并且是其中之一
Rust 防止的主要错误类别。
这正是 lifetimes 防止的问题。一生是一个
一些元数据，可以让您和编译器知道一个多长时间
值将在其当前内存位置有效。那是一个
重要的区别，因为这是 Rust 新手常犯的错误。
Rust 生命周期 不是 对象在
创建以及何时销毁！
打个比方，这样想：在一个人的一生中，他们会
居住在许多不同的位置，每个位置都有不同的地址。一种
Rust 生命周期与您当前所在的地址有关，
不是关于你将来什么时候死（虽然死也
更改您的地址）。每次你移动它都是相关的，因为你的
地址不再有效。
同样重要的是要注意生命周期不会改变你的代码；您的
代码控制生命周期，您的生命周期不控制代码。这
精辟的说法是“一生是描述性的，而不是规定性的”。
让我们用一些我们将使用的行号来注释Combined::new
突出生命周期：
{ // 0
let parent = Parent { count: 42 }; // 1
let child = Child { parent: &parent }; // 2
// 3
Combined { parent, child } // 4
} // 5
parent 的具体生命周期是从 1 到 4，包括 1 到 4（我将
表示为[1,4])。 child 的具体生命周期为 [2,4]，并且
返回值的具体生命周期是[4,5]。它是
可能有从零开始的具体生命周期 - 那将
表示函数参数的生命周期或其他东西
存在于区块之外。
注意child 本身的生命周期是[2,4]，但它指的是
到 一个生命周期为[1,4] 的值。这很好，只要
引用值在被引用值之前变得无效。这
当我们尝试从块中返回child 时会出现问题。这个会
“过度延长”生命周期超出其自然长度。
这个新知识应该解释前两个例子。第三
一个需要查看Parent::child 的实现。机会
是，它看起来像这样：
impl Parent {
fn child(&self) -> Child { /* ... */ }
}
这使用生命周期省略来避免写显式泛型
生命周期参数。相当于：
impl Parent {
fn child<'a>(&'a self) -> Child<'a> { /* ... */ }
}
在这两种情况下，该方法都表示Child 结构将是
返回已用具体生命周期参数化的
self。换句话说，Child 实例包含一个引用
到创建它的Parent，因此不能活得比这更长
Parent 实例。
这也让我们认识到我们的问题确实有问题
创建函数：
fn make_combined<'a>() -> Combined<'a> { /* ... */ }
虽然您更有可能看到它以不同的形式写成：
impl<'a> Combined<'a> {
fn new() -> Combined<'a> { /* ... */ }
}
在这两种情况下，都没有通过
争论。这意味着Combined 的生命周期将是
参数化不受任何约束 - 它可以是任何东西
调用者希望它是。这是荒谬的，因为调用者
可以指定 'static 生命周期，但无法满足
条件。
我该如何解决？
最简单和最推荐的解决方案是不要尝试将
这些项目在同一个结构中在一起。通过这样做，您的
结构嵌套将模仿代码的生命周期。地点类型
将自己的数据一起放入一个结构中，然后提供方法
允许您根据需要获取引用或包含引用的对象。
有一种特殊情况是生命周期跟踪过于热心：
当你有东西放在堆上时。当您使用
例如Box<T>。在这种情况下，被移动的结构
包含指向堆的指针。指向的值将保持不变
稳定，但指针本身的地址会移动。在实践中，
这没关系，因为你总是跟着指针走。
一些 crate 提供了表示这种情况的方法，但它们
要求基地址永不移动。这排除了变异
向量，这可能会导致重新分配和移动
堆分配的值。
通过租赁解决的问题示例：
在其他情况下，您可能希望使用某种类型的引用计数，例如使用Rc 或Arc。
更多信息
将parent移动到结构体后，为什么编译器无法获得对parent的新引用并将其分配给结构体中的child？
虽然理论上可以这样做，但这样做会带来大量的复杂性和开销。每次移动对象时，编译器都需要插入代码来“修复”引用。这意味着复制结构不再是一个非常便宜的操作，只是移动一些位。这甚至可能意味着这样的代码很昂贵，这取决于假设的优化器有多好：
let a = Object::new();
let b = a;
let c = b;
不是在每次移动时强制发生这种情况，程序员可以通过创建方法来选择何时发生这种情况，这些方法仅在您调用它们时才会采用适当的引用.
引用自身的类型
在一种特殊情况下，您可以创建一个引用自身的类型。您需要使用Option 之类的东西分两步完成：
#[derive(Debug)]
struct WhatAboutThis<'a> {
name: String,
nickname: Option<&'a str>,
}
fn main() {
let mut tricky = WhatAboutThis {
name: "Annabelle".to_string(),
nickname: None,
};
tricky.nickname = Some(&tricky.name[..4]);
println!("{:?}", tricky);
}
从某种意义上说，这确实有效，但所创造的价值受到高度限制——它永远不能被移动。值得注意的是，这意味着它不能从函数返回或按值传递给任何东西。构造函数显示了与上述生命周期相同的问题：
fn creator<'a>() -> WhatAboutThis<'a> { /* ... */ }
如果您尝试使用方法执行相同的代码，您将需要诱人但最终无用的&'a self。当涉及到这一点时，此代码会受到更多限制，并且在第一次方法调用后您将收到借用检查器错误：
#[derive(Debug)]
struct WhatAboutThis<'a> {
name: String,
nickname: Option<&'a str>,
}
impl<'a> WhatAboutThis<'a> {
fn tie_the_knot(&'a mut self) {
self.nickname = Some(&self.name[..4]);
}
}
fn main() {
let mut tricky = WhatAboutThis {
name: "Annabelle".to_string(),
nickname: None,
};
tricky.tie_the_knot();
// cannot borrow `tricky` as immutable because it is also borrowed as mutable
// println!("{:?}", tricky);
}
另见：
Pin 呢？
Pin，稳定在 Rust 1.33，有这个in the module documentation：
这种情况的一个典型例子是构建自引用结构，因为移动带有指向自身的指针的对象会使它们无效，这可能导致未定义的行为。
请务必注意，“自我引用”并不一定意味着使用引用。确实，example of a self-referential struct 明确表示（强调我的）：
我们无法通过普通引用通知编译器，
因为这种模式不能用通常的借用规则来描述。
取而代之的是我们使用一个原始指针，虽然它已知不为空，
因为我们知道它指向字符串。
自 Rust 1.0 以来就存在使用原始指针进行此行为的能力。事实上，owning-ref 和 renting 在后台使用原始指针。
Pin 添加到表中的唯一内容是声明给定值保证不会移动的常用方式。
另见：