递归结构错误寿命（无法推断函数调用中的生命周期参数的适当寿命... [E0495]）

Question

我找不出这个代码的生命周期参数。一切我通常会尝试导致编译器错误：

consider using an explicit lifetime parameter as shown

或类似

in type &'ent Entity<'a, 'ent> , reference has a longer lifetime than the data it references.

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

Answer 1

我一直在寻找在错误的方向。所以，我找到了解决方案，但不幸的是它并不安全。

• 可以使用Rc和Weak允许节点共享所有权实现它，虽然这种方法支付内存管理的成本。
• 您可以使用原始指针使用不安全的代码来实现它。这将会更有效率，但绕过Rust的安全保证。
• 使用借阅的参考文献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