为什么我不能在同一个结构中存储一个值和对该值的引用？

让我们看看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 防止的主要错误类别之一。

这正是生命周期阻止的问题。生命周期是一些元数据，它允许您和编译器知道一个值在其当前内存位置有效多长时间。这是一个重要的区别，因为这是 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 提供了表示这种情况的方法，但它们要求基地址永远不会移动。这排除了变异向量，这可能导致堆分配值的重新分配和移动。

租金（不再维护或支持）

拥有_ref

衔尾蛇

使用租赁解决的问题示例：

是否有 String::chars 的自有版本？

独立于方法返回 RWLockReadGuard

如何在 Rust 中的锁定结构成员上返回迭代器？

如何返回对互斥锁下值的子值的引用？

如何使用启用 Futures 的 Hyper Chunk 的 Serde 零拷贝反序列化存储结果？

如何在不必处理生命周期的情况下存储引用？

在其他情况下，您可能希望使用某种类型的引用计数，例如使用 Rc 或 Arc。

更多信息

将父级移入结构后，为什么编译器无法获取对父级的新引用并将其分配给结构中的子级？

虽然理论上可以做到这一点，但这样做会带来大量的复杂性和开销。每次移动对象时，编译器都需要插入代码来“修复”引用。这意味着复制结构不再是一个非常便宜的操作，只是移动一些位。这甚至可能意味着这样的代码很昂贵，这取决于假设的优化器有多好：

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

也可以看看：

不能在一个代码中一次多次借用 mutable - 但可以在另一个非常相似的代码中

平呢？

Pin，在 Rust 1.33 中稳定，有这个 in the module documentation：

这种情况的一个主要示例是构建自引用结构，因为移动带有指向自身的指针的对象将使它们无效，这可能导致未定义的行为。

需要注意的是，“自我引用”并不一定意味着使用引用。实际上，example of a self-referential struct 明确表示（强调我的）：

我们无法通过正常的引用通知编译器，因为这种模式不能用通常的借用规则来描述。相反，我们使用原始指针，尽管已知它不是空指针，因为我们知道它指向字符串。

自 Rust 1.0 以来，就已经存在使用原始指针来实现这种行为的能力。实际上，owning-ref 和 rent 使用了底层的原始指针。

Pin 添加到表中的唯一内容是声明给定值保证不会移动的常用方式。

也可以看看：

如何使用带有自引用结构的 Pin 结构？

---

导致非常相似的编译器消息的一个稍微不同的问题是对象生存期依赖性，而不是存储显式引用。 ssh2 库就是一个例子。在开发比测试项目更大的东西时，很容易尝试将从该会话中获得的 Session 和 Channel 并排放入一个结构中，从而对用户隐藏实现细节。但是，请注意 Channel 定义在其类型注释中具有 'sess 生命周期，而 Session 没有。

这会导致与生命周期相关的类似编译器错误。

以非常简单的方式解决它的一种方法是在调用方中声明 Session 外部，然后用生命周期注释结构内的引用，类似于 this Rust User's Forum post 中的答案在封装时谈论相同的问题SFTP。这看起来并不优雅，并且可能并不总是适用 - 因为现在您有两个实体要处理，而不是您想要的一个！

原来，其他答案中的 rental crate 或 owning_ref crate 也是此问题的解决方案。让我们考虑一下 owning_ref，它具有用于这个确切目的的特殊对象：OwningHandle。为了避免底层对象移动，我们使用 Box 在堆上分配它，这为我们提供了以下可能的解决方案：

use ssh2::{Channel, Error, Session};
use std::net::TcpStream;

use owning_ref::OwningHandle;

struct DeviceSSHConnection {
    tcp: TcpStream,
    channel: OwningHandle<Box<Session>, Box<Channel<'static>>>,
}

impl DeviceSSHConnection {
    fn new(targ: &str, c_user: &str, c_pass: &str) -> Self {
        use std::net::TcpStream;
        let mut session = Session::new().unwrap();
        let mut tcp = TcpStream::connect(targ).unwrap();

        session.handshake(&tcp).unwrap();
        session.set_timeout(5000);
        session.userauth_password(c_user, c_pass).unwrap();

        let mut sess = Box::new(session);
        let mut oref = OwningHandle::new_with_fn(
            sess,
            unsafe { |x| Box::new((*x).channel_session().unwrap()) },
        );

        oref.shell().unwrap();
        let ret = DeviceSSHConnection {
            tcp: tcp,
            channel: oref,
        };
        ret
    }
}

此代码的结果是我们不能再使用 Session，但它与我们将使用的 Channel 一起存储。因为 OwningHandle 对象取消引用 Box，而 Box 取消引用 Channel，所以当将其存储在结构中时，我们将其命名为这样。 注意：这只是我的理解。我怀疑这可能不正确，因为它似乎非常接近 discussion of OwningHandle unsafety。

这里有一个奇怪的细节是，Session 在逻辑上与 TcpStream 具有类似的关系，就像 Channel 与 Session 的关系一样，但它的所有权并没有被占用，并且没有围绕这样做的类型注释。相反，这取决于用户，正如 handshake 方法的文档所述：

此会话不获取提供的套接字的所有权，建议确保套接字在此会话的生命周期中保持不变，以确保正确执行通信。还强烈建议在此会话期间不要在其他地方同时使用提供的流，因为它可能会干扰协议。

所以使用TcpStream，完全由程序员来确保代码的正确性。对于 OwningHandle，使用 unsafe {} 块将注意力吸引到“危险魔法”发生的位置。

此 Rust User's Forum thread 中对此问题进行了更深入和更高级的讨论 - 其中包括一个不同的示例及其使用不包含不安全块的出租箱的解决方案。

---

我发现 Arc（只读）或 Arc<Mutex>（带锁定的读写）模式有时在性能和代码复杂性（主要由生命周期注释引起）之间进行权衡非常有用。

弧：

use std::sync::Arc;

struct Parent {
    child: Arc<Child>,
}
struct Child {
    value: u32,
}
struct Combined(Parent, Arc<Child>);

fn main() {
    let parent = Parent { child: Arc::new(Child { value: 42 }) };
    let child = parent.child.clone();
    let combined = Combined(parent, child.clone());

    assert_eq!(combined.0.child.value, 42);
    assert_eq!(child.value, 42);
    // combined.0.child.value = 50; // fails, Arc is not DerefMut
}

弧+互斥：

use std::sync::{Arc, Mutex};

struct Child {
    value: u32,
}
struct Parent {
    child: Arc<Mutex<Child>>,
}
struct Combined(Parent, Arc<Mutex<Child>>);

fn main() {
    let parent = Parent { child: Arc::new(Mutex::new(Child {value: 42 }))};
    let child = parent.child.clone();
    let combined = Combined(parent, child.clone());

    assert_eq!(combined.0.child.lock().unwrap().value, 42);
    assert_eq!(child.lock().unwrap().value, 42);
    child.lock().unwrap().value = 50;
    assert_eq!(combined.0.child.lock().unwrap().value, 50);
}

另请参阅 RwLock (When or why should I use a Mutex over an RwLock?)

---

作为 Rust 的新手，我有一个与您上一个示例类似的案例：

struct Combined<'a>(Parent, Child<'a>);

fn make_combined<'a>() -> Combined<'a> {
    let parent = Parent::new();
    let child = parent.child();

    Combined(parent, child)
}

最后，我通过使用这种模式解决了它：

fn make_parent_and_child<'a>(anchor: &'a mut DataAnchorFor1<Parent>) -> Child<'a> {
    // construct parent, then store it in anchor object the caller gave us a mut-ref to
    *anchor = DataAnchorFor1::holding(Parent::new());

    // now retrieve parent from storage-slot we assigned to in the previous line
    let parent = anchor.val1.as_mut().unwrap();

    // now proceed with regular code, except returning only the child
    // (the parent can already be accessed by the caller through the anchor object)
    let child = parent.child();
    child
}

// this is a generic struct that we can define once, and use whenever we need this pattern
// (it can also be extended to have multiple slots, naturally)
struct DataAnchorFor1<T> {
    val1: Option<T>,
}
impl<T> DataAnchorFor1<T> {
    fn empty() -> Self {
        Self { val1: None }
    }
    fn holding(val1: T) -> Self {
        Self { val1: Some(val1) }
    }
}

// for my case, this was all I needed
fn main_simple() {
    let anchor = DataAnchorFor1::empty();
    let child = make_parent_and_child(&mut anchor);
    let child_processing_result = do_some_processing(child);
    println!("ChildProcessingResult:{}", child_processing_result);
}

// but if access to parent-data later on is required, you can use this
fn main_complex() {
    let anchor = DataAnchorFor1::empty();
    
    // if you want to use the parent object (which is stored in anchor), you must...
    // ...wrap the child-related processing in a new scope, so the mut-ref to anchor...
    // ...gets dropped at its end, letting us access anchor.val1 (the parent) directly
    let child_processing_result = {
        let child = make_parent_and_child(&mut anchor);
        // do the processing you want with the child here (avoiding ref-chain...
        // ...back to anchor-data, if you need to access parent-data afterward)
        do_some_processing(child)
    };

    // now that scope is ended, we can access parent data directly
    // so print out the relevant data for both parent and child (adjust to your case)
    let parent = anchor.val1.unwrap();
    println!("Parent:{} ChildProcessingResult:{}", parent, child_processing_result);
}

这远不是一个通用的解决方案！但它在我的情况下有效，并且只需要使用上面的 main_simple 模式（不是 main_complex 变体），因为在我的情况下，“父”对象只是我的临时对象（数据库“客户端”对象）必须构造以传递给“子”对象（数据库“事务”对象），以便我可以运行一些数据库命令。

无论如何，它完成了我需要的封装/简化样板（因为我有许多需要创建事务/“子”对象的函数，现在他们需要的只是通用的锚对象创建行），同时避免需要使用一个全新的库。

这些是我知道的可能相关的库：

拥有-ref

出租

衔尾蛇

参考

自我细胞

埃舍尔

锈视图框

但是，我浏览了它们，它们似乎都存在某种类型的问题（多年未更新，存在多个不健全问题/提出的担忧等），因此我对使用它们犹豫不决。

因此，虽然这不是一个通用的解决方案，但我想我会为有类似用例的人提及它：

调用者只需要返回的“子”对象。

但是被调用函数需要构造一个“父”对象来执行其功能。

借用规则要求“父”对象存储在“make_parent_and_child”函数之外的某个地方。 （就我而言，这是一个 start_transaction 函数）

---