Rust 将在结构中移动的值的借用指针

假设

管理器

持有对

设计器

和

程序员

的引用，但是

程序员

也必须持有对

设计器

的引用，以便在需要时对其进行ping操作

问题是，通过在

Manager:：new（）

中创建

设计器

和

程序员

，

&Designer

引用的寿命不够长，因为在下面几行中，它在

管理器

中移动

错误是，

“设计器”的寿命不够长

struct Programmer<'a> {
    designer: &'a Designer,
}

impl<'a> Programmer<'a> {
    pub fn new(designer: &'a Designer) -> Programmer<'a> {
        Programmer { designer: designer }
    }
}

struct Designer {
    iq: u32,
}

impl Designer {
    pub fn new(iq: u32) -> Designer {
        Designer { iq: iq }
    }
}

struct Manager<'a> {
    programmer: Programmer<'a>,
    designer: Designer
}

impl<'a> Manager<'a> {
    pub fn new() -> Manager<'a> {
        let designer = Designer::new(42);
        let programmer = Programmer::new(&designer);

        Manager { designer: designer, programmer: programmer }
    }
}

fn main() {
    Manager::new();
}

struct程序员{
pub fn new（设计师：&'a设计师）->程序员{
程序员：程序员经理{
let designer=designer:：new（42）；
让程序员=程序员：：新建（&designer）；
经理{设计师：设计师，程序员：程序员}
}
}
fn main（）{
Manager:：new（）；
}

编译失败，出现以下消息：

test.rs:29:47: 29:55 error: `designer` does not live long enough
test.rs:29             let programmer = Programmer::new(&designer);
                                                         ^~~~~~~~
test.rs:27:37: 32:10 note: reference must be valid for the lifetime 'a as defined on the block at 27:36...
test.rs:27         pub fn new() -> Manager<'a> {
test.rs:28             let designer = Designer::new(42);
test.rs:29             let programmer = Programmer::new(&designer);
test.rs:30
test.rs:31             Manager { designer: designer, programmer: programmer }
test.rs:32         }
test.rs:27:37: 32:10 note: ...but borrowed value is only valid for the block at 27:36
test.rs:27         pub fn new() -> Manager<'a> {
test.rs:28             let designer = Designer::new(42);
test.rs:29             let programmer = Programmer::new(&designer);
test.rs:30
test.rs:31             Manager { designer: designer, programmer: programmer }
test.rs:32         }

test.rs:29:47:29:55错误：'designer'寿命不够长
test.rs:29 let programmer=programmer:：new（&designer）；
^~~~~~~~
test.rs:27:37:32:10注：参考必须在27:36块上定义的生命周期“a”内有效。。。
test.rs:27 pub fn new（）->Manager{
test.rs:28 let designer=designer:：new（42）；
test.rs:29 let programmer=programmer:：new（&designer）；
测试。rs:30
test.rs:31经理{设计师：设计师，程序员：程序员}
test.rs:32}

---

如果不通过

Manager:：new（&Designer）注入
Designer
，如何解决此问题

？

我想你知道自己在做什么，但这似乎不是最好的生锈设计。你说一个

程序员

应该持有一个

设计师

的引用才能ping它们，但我想ping它们意味着在某种程度上变异

设计师

（例如，假设在

设计器

上有一些

字段，这是通过一个简单的引用无法做到的。通过一个常规的、不可变的引用，你所能做的就是读取数据或调用不改变变量的方法。此外，只要你有这个引用，原始的
设计器
就不能改变

但是，如果您确实希望有一个不可变的引用，那么可以使用提供不可变引用计数指针的类型

如果您想以某种方式允许
程序员
向
设计器
发送消息，这些消息可能会或可能不会触发
设计器
上的突变，那么您可以尝试使用通道。每个
设计器
都将存储自己的消息，并且可以有一种方法克隆感兴趣的
程序的通道末端rammer
存储和使用。
我不是在暗示变异。我会尝试使用
Rc
，看看会发生什么。感谢您的回复。：）使用
Rc
效果很好，我想我现在已经足够满意了。再次感谢！