rust - 如何获得 C++ 初始化列表的等价物

Question

我有两个这样的简单结构:

struct Foo {
}

struct Bar<'a> {
    foo: &'a mut Foo;
}

impl Foo {
    pub fn new() -> Foo {
        Foo
    }
}

impl<'a> Bar<'a> {
    pub fn new(foo: &'a mut Foo) -> Bar<'a> {
        Bar {
            foo: foo,
        }
    }
}

所以基本上是结构 Bar需要引用 Foo继续工作。这是我使用它的方式:

let mut foo = Foo::new();
let mut bar = Bar::new(&mut foo);

现在我想创建一个“胶水”结构来处理所有这些的创建Foo s 和 Bar秒。所以我只想要结构 Container有 1 Foo , 1 Bar .

我试过做类似的事情:

impl Container {
    pub fn new() -> Container {
        Container {
          foo: Foo::new(),
          bar: Bar::new(&mut foo),
        }
    }
}

但它不起作用，我无法引用字段 foo来自 bar初始值设定项。我基本上想模仿以下 C++ 代码:

Container::Container() :
    foo(),
    bar(&foo)
{}

关于如何解决这个问题的任何想法？当然，在这里使用任何类型的动态分配/引用计数都太过分了。

--- 编辑 ---

明确地说，我想创建与此 C++ 片段等效的 Rust 代码:

struct Foo {
};

struct Bar {
    Bar(Foo& f) : foo(f) {}
    Foo& foo;
};

Foo f;
Bar b(f);

struct Container {
    Container() : f(), b(f) {}
    Foo f;
    Bar b;
};

--- 编辑 ---

这是我最后做的，使用 Rc<> .

use std::rc::Rc;

struct Foo {
  pub bar: Rc<Bar>,
}

impl Foo {
  pub fn new(bar: Rc<Bar>) -> Foo {
    Foo {
      bar: bar,
    }
  }
}

struct Bar {
  a: u8,
}

impl Bar {
  pub fn new() -> Bar {
    Bar {
      a: 42,
    }
  }
}

struct Container {
  pub bar: Rc<Bar>,
  pub foo: Foo,
}

impl Container {
  pub fn new() -> Container {
    let bar = Rc::new(Bar::new());
    Container {
      bar: bar.clone(),
      foo: Foo::new(bar.clone()),
    }
  }
}

fn main() {
  // Just checking that we get the same bar for both
  // inside Container and inside Foo
  let c = Container::new();
  println!("{:p}", &*c.bar);
  println!("{:p}", &*c.foo.bar);

  // So from what I understand, here bar is on the stack
  // then byte-copied to the heap where that Rc<> will point?
  let bar = Bar::new();
  println!("{:p}", &bar);
  let foo = Foo::new(Rc::new(bar));
  println!("{:p}", &*foo.bar);

  // Sad story is that using this Rc<> I now use the "cuteness"
  // and safety that I had with reference borrowing:
  // struct Foo<'a> {
  //   bar: &'a mut Bar,
  // }
  // impl<'a> Foo<'a> {
  //   pub fn new(bar: &'a Bar) -> Foo<'a> {
  //     Foo { bar: bar }
  //   }
  // }
  // let bar = Bar::new();
  // let foo = Foo::new(&bar);
}

不过这真的不是很满足，感觉就像用机关枪打兔子一样。非常感谢任何见解:(

Answer 1

在 Rust 的安全代码中不可能表达这个概念。