我有一组需要相互了解才能合作的对象。这些对象存储在容器中。我试图对如何用 Rust 构建我的代码有一个非常简单的想法。
让我们打个比方。 AComputer包含：
Mmu
Ram
Processor
In Rust:
struct Computer {
mmu: Mmu,
ram: Ram,
cpu: Cpu,
}
为了使任何事情发挥作用，Cpu需要了解Mmu它链接到，并且Mmu需要知道Ram它链接到。
I do not想要Cpu to 按值聚合 the Mmu。它们的寿命不同：Mmu可以自己过自己的生活。只是碰巧我可以将它插入Cpu。然而，创建一个Cpu没有Mmu依附于它，因为它无法完成它的工作。之间也存在同样的关系Mmu and Ram.
所以：
Ram可以自己生活。Mmu需要一个Ram.Cpu需要一个Mmu.我怎样才能在 Rust 中模拟这种设计，一个一个结构体，其字段相互了解.
在 C++ 中，它的结构如下：
>
struct Ram
{
};
struct Mmu
{
Ram& ram;
Mmu(Ram& r) : ram(r) {}
};
struct Cpu
{
Mmu& mmu;
Cpu(Mmu& m) : mmu(m) {}
};
struct Computer
{
Ram ram;
Mmu mmu;
Cpu cpu;
Computer() : ram(), mmu(ram), cpu(mmu) {}
};
以下是我开始用 Rust 翻译它的方式：
struct Ram;
struct Mmu<'a> {
ram: &'a Ram,
}
struct Cpu<'a> {
mmu: &'a Mmu<'a>,
}
impl Ram {
fn new() -> Ram {
Ram
}
}
impl<'a> Mmu<'a> {
fn new(ram: &'a Ram) -> Mmu<'a> {
Mmu {
ram: ram
}
}
}
impl<'a> Cpu<'a> {
fn new(mmu: &'a Mmu) -> Cpu<'a> {
Cpu {
mmu: mmu,
}
}
}
fn main() {
let ram = Ram::new();
let mmu = Mmu::new(&ram);
let cpu = Cpu::new(&mmu);
}
这很好，但现在我只是找不到一种方法来创建Computer struct.
我开始于：
struct Computer<'a> {
ram: Ram,
mmu: Mmu<'a>,
cpu: Cpu<'a>,
}
impl<'a> Computer<'a> {
fn new() -> Computer<'a> {
// Cannot do that, since struct fields are not accessible from the initializer
Computer {
ram: Ram::new(),
mmu: Mmu::new(&ram),
cpu: Cpu::new(&mmu),
}
// Of course cannot do that, since local variables won't live long enough
let ram = Ram::new();
let mmu = Mmu::new(&ram);
let cpu = Cpu::new(&mmu);
Computer {
ram: ram,
mmu: mmu,
cpu: cpu,
}
}
}
好吧，无论如何，我将无法找到一种方法来引用它们之间的结构字段。我想我可以通过创建来想出一些东西Ram, Mmu and Cpu在堆上；并将其放入结构中：
struct Computer<'a> {
ram: Box<Ram>,
mmu: Box<Mmu<'a>>,
cpu: Box<Cpu<'a>>,
}
impl<'a> Computer<'a> {
fn new() -> Computer<'a> {
let ram = Box::new(Ram::new());
// V-- ERROR: reference must be valid for the lifetime 'a
let mmu = Box::new(Mmu::new(&*ram));
let cpu = Box::new(Cpu::new(&*mmu));
Computer {
ram: ram,
mmu: mmu,
cpu: cpu,
}
}
}
是的，没错，此时 Rust 无法知道我要转让所有权let ram = Box::new(Ram::new()) to the Computer，所以它将得到一生'a.
我一直在尝试各种或多或少的黑客方法来实现这一点，但我就是无法想出一个干净的解决方案。我最接近的是放弃参考并使用Option，但是我所有的方法都必须检查是否Option is Some or None，这是相当难看的。
我想我只是走错了路，试图在 Rust 中映射我在 C++ 中要做的事情，但这不起作用。这就是为什么我需要帮助找出创建此架构的惯用 Rust 方法。
在这个答案中，我将讨论解决这个问题的两种方法，一种是安全的 Rust，具有零动态分配和很少的运行时成本，但可能会受到限制，另一种是使用不安全不变量的动态分配。
Cell<Option<&'a T>)use std::cell::Cell;
#[derive(Debug)]
struct Computer<'a> {
ram: Ram,
mmu: Mmu<'a>,
cpu: Cpu<'a>,
}
#[derive(Debug)]
struct Ram;
#[derive(Debug)]
struct Cpu<'a> {
mmu: Cell<Option<&'a Mmu<'a>>>,
}
#[derive(Debug)]
struct Mmu<'a> {
ram: Cell<Option<&'a Ram>>,
}
impl<'a> Computer<'a> {
fn new() -> Computer<'a> {
Computer {
ram: Ram,
cpu: Cpu {
mmu: Cell::new(None),
},
mmu: Mmu {
ram: Cell::new(None),
},
}
}
fn freeze(&'a self) {
self.mmu.ram.set(Some(&self.ram));
self.cpu.mmu.set(Some(&self.mmu));
}
}
fn main() {
let computer = Computer::new();
computer.freeze();
println!("{:?}, {:?}, {:?}", computer.ram, computer.mmu, computer.cpu);
}
操场
与普遍看法相反，自我引用are事实上，在安全的 Rust 中是可能的，甚至更好，当你使用它们时，Rust 将继续为你强制执行内存安全。
使用以下方法获取自我、递归或循环引用所需的主要“技巧”&'a T是使用一个Cell<Option<&'a T>包含参考。如果没有Cell<Option<T>>包装纸。
该解决方案的巧妙之处是将结构的初始创建与正确的初始化分开。这有一个不幸的缺点，即通过在调用之前初始化并使用它，可能会错误地使用该结构freeze，但如果不进一步使用它就不会导致内存不安全unsafe.
结构体的最初创建只是为我们后来的黑客行为奠定了基础——它创建了Ram，它没有依赖关系，并设置Cpu and Mmu至无法使用的状态，包含Cell::new(None)而不是他们需要的参考资料。
然后，我们调用freeze方法，故意借用 self 的生命周期'a，或结构的完整生命周期。调用此方法后，编译器将阻止我们获取对Computer or移动Computer，因为任何一个都可能使我们持有的引用无效。这freeze方法然后设置Cpu and Mmu适当地通过设置Cells 包含Some(&self.cpu) or Some(&self.ram)分别。
After freeze称为我们的结构已准备好使用，但只能是不可变的。
Box<T>从不移动T)#![allow(dead_code)]
use std::mem;
// CRUCIAL INFO:
//
// In order for this scheme to be safe, Computer *must not*
// expose any functionality that allows setting the ram or
// mmu to a different Box with a different memory location.
//
// Care must also be taken to prevent aliasing of &mut references
// to mmu and ram. This is not a completely safe interface,
// and its use must be restricted.
struct Computer {
ram: Box<Ram>,
cpu: Cpu,
mmu: Box<Mmu>,
}
struct Ram;
// Cpu and Mmu are unsafe to use directly, and *must only*
// be exposed when properly set up inside a Computer
struct Cpu {
mmu: *mut Mmu,
}
struct Mmu {
ram: *mut Ram,
}
impl Cpu {
// Safe if we uphold the invariant that Cpu must be
// constructed in a Computer.
fn mmu(&self) -> &Mmu {
unsafe { mem::transmute(self.mmu) }
}
}
impl Mmu {
// Safe if we uphold the invariant that Mmu must be
// constructed in a Computer.
fn ram(&self) -> &Ram {
unsafe { mem::transmute(self.ram) }
}
}
impl Computer {
fn new() -> Computer {
let ram = Box::new(Ram);
let mmu = Box::new(Mmu {
ram: unsafe { mem::transmute(&*ram) },
});
let cpu = Cpu {
mmu: unsafe { mem::transmute(&*mmu) },
};
// Safe to move the components in here because all the
// references are references to data behind a Box, so the
// data will not move.
Computer {
ram: ram,
mmu: mmu,
cpu: cpu,
}
}
}
fn main() {}
操场
NOTE：由于接口不受限制，该解决方案并不完全安全Computer- 必须注意不允许别名或删除Mmu or Ram在计算机的公共界面中。
该解决方案使用了数据存储在 a 内的不变式Box永远不会移动 - 它的地址永远不会改变 - 只要Box仍然活着。 Rust 不允许您在安全代码中依赖于此，因为移动Box可能会导致其后面的内存被释放，从而留下悬空指针，但我们可以在不安全的代码中依赖它。
该解决方案的主要技巧是使用原始指针来访问Box<Mmu> and Box<Ram>将引用存储在Cpu and Mmu分别。这将为您提供一个基本安全的界面，并且不会阻止您移动Computer在有限的情况下，甚至可以改变它。
综上所述，我认为这两种方法都不应该是解决这个问题的真正方法。所有权是 Rust 的核心概念，它渗透到几乎所有代码的设计选择中。如果Mmu拥有Ram和Cpu拥有Mmu，这就是您的代码中应该具有的关系。如果你使用Rc，您甚至可以保持共享底层片段的能力，尽管是一成不变的。