带参考的嵌套结构

Question

我有一些嵌套的结构体，不能创建父结构体的反向引用。一个example：

struct Foo<'a> { 
    parent: &'a Bar<'a>, 
} 

impl<'a> Foo<'a> { 
    fn new(parent: &'a Bar) -> Self { 
     Foo { parent: parent } 
    } 

    fn hello_world(&self) -> String { 
     self.parent.hello().to_owned() + " world" 
    } 
} 

struct Bar<'b> { 
    child: Option<Foo<'b>>, 
    data: &'static str, 
} 

impl<'b> Bar<'b> { 
    fn new() -> Self { 
     Bar { 
      child: None, 
      data: "hello", 
     } 
    } 

    fn hello(&self) -> &str { 
     self.data 
    } 

    fn get_foo(&self) -> Option<&Foo> { 
     self.child.as_ref() 
    } 
} 

fn main() { 
    let bar = Bar::new(); 
    assert_eq!("hello", bar.hello()); 
    match bar.get_foo() { 
     Some(foo) => assert_eq!("hello world", foo.hello_world()), 
     None =>(), 
    } 
} 

我怎么能一起Bar参考替换None与Some<Foo>？到目前为止，我不确定这是可能的。

Answer 1

这不完全是您的示例的插入式解决方案，但我相信您可以使用Arc和RwLock指定的方式创建“循环引用”。 API不完全相同（例如，parent是一个可选字段），我重命名了一些对象，它肯定更详细，但是您的测试通过！

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

#[derive(Debug, Clone)] 
struct Child { 
    parent: Option<Arc<RwLock<Parent>>> 
} 

impl Child { 
    fn new() -> Self { 
     Child { 
      parent: None 
     } 
    } 

    fn hello_world(&self) -> String { 
     let x = self.parent.as_ref().unwrap().clone(); 
     let y = x.read().unwrap(); 
     y.hello().to_owned() + " world" 
    } 
} 

#[derive(Debug, Clone)] 
struct Parent { 
    child: Option<Arc<RwLock<Child>>>, 
    data: &'static str 
} 

impl Parent { 
    fn new() -> Self { 
     Parent { 
      child: None, 
      data: "hello" 
     } 
    } 

    fn hello(&self) -> &str { 
     self.data 
    } 

    fn get_child(&self) -> Option<Arc<RwLock<Child>>> { 
     self.child.as_ref().map(|x| x.clone()) 
    } 


} 

fn main() { 
    let parent = Arc::new(RwLock::new(Parent::new())); 
    let child = Arc::new(RwLock::new(Child::new())); 

    parent.write().unwrap().child = Some(child.clone()); 
    child.write().unwrap().parent = Some(parent.clone()); 

    assert_eq!("hello", parent.read().unwrap().hello()); 

    { 
     let x = parent.read().unwrap(); 
     match x.get_child() { 
      Some(child) => { assert_eq!("hello world", child.read().unwrap().hello_world()); } 
      None => {}, 
     } 
    } 

}