帶參考的嵌套結構

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 => {}, 
     } 
    } 

}