recursion - 递归结构错误生存期(无法为函数调用中的生存期参数推断适当的生存期... [E0495])

This question already has an answer here:

What lifetimes do I use to create Rust structs that reference each other cyclically?
（1个答案）
三年前关闭。
我无法计算出此代码的生存期参数。我尝试的所有操作通常都会导致编译器错误：
考虑使用显式生存期参数，如图所示
或者类似的
在类型&'ent Entity<'a, 'ent>中，引用的生存期比它引用的数据长。
Entity，Reference是简化版本，以保持此示例最少。

struct Entity<'a> {
    id: i32,
    name: &'a str,
    references: Option<Vec<Reference<'a>>>,
}

struct Reference<'a> {
    entity: &'a Entity<'a>,
}

fn main() {
    let mut ents: Vec<Entity> = vec![Entity {
                                      id: 0,
                                      name: "Zero",
                                      references: None,
                                  },
                                  Entity {
                                      id: 1,
                                      name: "One",
                                      references: None,
                                  },
                                  Entity {
                                      id: 2,
                                      name: "Two",
                                      references: None,
                                  },
                                  Entity {
                                      id: 3,
                                      name: "Three",
                                      references: None,
                                  }];
    let references_ents_id = vec![vec![3, 1, 2], vec![1], vec![0, 3], vec![3, 0]];
    create_references(&references_ents_id, &mut ents);
}

fn create_references(refs_id: &Vec<Vec<i32>>, ents_vec: &mut Vec<Entity>) {
    for (id_ent, references) in refs_id.iter().enumerate() {
        let mut references_of_ent: Vec<Reference> = vec![];
        for id_ent in references {
            references_of_ent.push(Reference {
                entity: ents_vec.iter().find(|ent| ent.id == *id_ent).unwrap(),
            });
        }
        ents_vec[id_ent].references = Some(references_of_ent);
    }
}

Rust Playground

最佳答案

我看错方向了。所以，我找到了一个解决方案，但不幸的是它并不安全。
您可以使用Rc和Weak来实现它，以允许共享节点的所有权，尽管这种方法需要支付内存管理的成本。
您可以使用不安全的代码使用原始指针来实现它。这将是更有效的，但绕过铁锈的安全保证。
使用带UnsafeCell的借用引用。
Rust FAQ
Other answer on SO
使用原始指针实现不安全版本的示例：

struct Entity<'a> {
    id: i32,
    name: &'a str,
    references: Option<Vec<Reference<'a>>>,
}

struct Reference<'a> {
    entity: *const Entity<'a>,
}

铁锈操场：https://play.rust-lang.org/?gist=8237d8cb80a681c981a85610104f2e5c&version=stable&backtrace=0