rust - 包含相互了解的字段的结构

Question

我有一组需要相互了解才能合作的对象。这些对象存储在容器中。我试图对如何在 Rust 中构建我的代码有一个非常简单的想法。

让我们打个比方。 Computer包含:

• 1 Mmu
• 1 Ram
• 1 Processor

在 Rust 中:

struct Computer {
    mmu: Mmu,
    ram: Ram,
    cpu: Cpu,
}

对于任何工作，Cpu需要了解 Mmu它链接到 Mmu需要知道 Ram它链接到。

我不想要Cpu 按值聚合 Mmu .他们的生命周期不同:Mmu可以自己过自己的生活。碰巧我可以将它插入 Cpu .但是，创建 Cpu 是没有意义的。没有 Mmu依附于它，因为它无法完成它的工作。 Mmu 之间存在相同的关系和 Ram .

因此:

• A Ram可以自己生活。
• 安 Mmu需要 Ram .
• A 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 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和 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()) 的所有权到 Computer , 所以它的生命周期为 'a .

我一直在尝试各种或多或少有点老套的方法来解决这个问题，但我就是想不出一个干净的解决方案。我最接近的是删除引用并使用 Option ，但是我所有的方法都必须检查 Option 是否是Some或 None ，这是相当丑陋的。

我想我只是走错了路，试图在 Rust 中映射我在 C++ 中所做的事情，但这行不通。这就是为什么我需要帮助找出创建此架构的惯用 Rust 方法。

Answer 1

在这个答案中，我将讨论解决此问题的两种方法，一种是安全的 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);
}

Playground

与流行的看法相反，自引用在安全的 Rust 中实际上是可能的，而且更好的是，当您使用它们时，Rust 将继续为您强制执行内存安全。

使用 &'a T 获取自引用、递归引用或循环引用所需的主要“技巧”是使用 Cell<Option<&'a T>包含引用。如果没有 Cell<Option<T>>，您将无法执行此操作包装器。

此解决方案的巧妙之处在于将结构的初始创建与正确的初始化分开。这有一个不幸的缺点，即在调用 freeze 之前初始化它并使用它可能会错误地使用这个结构。 , 但如果不进一步使用 unsafe 就不会导致内存不安全.

结构的初始创建只是为我们后来的 hackery 设置了舞台 - 它创建了 Ram ，它没有依赖关系，并设置 Cpu和 Mmu到他们无法使用的状态，包含Cell::new(None)而不是他们需要的引用资料。

然后，我们调用 freeze方法，有意地借用自己的一生'a ，或结构的整个生命周期。调用此方法后，编译器将阻止我们获取对 Computer 的可变引用。 或移动Computer ，因为任何一个都可能使我们持有的引用无效。 freeze然后方法设置 Cpu和 Mmu通过设置 Cell 来适本地包含 Some(&self.cpu)或 Some(&self.ram)分别。

在 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() {}

Playground

注意:考虑到 Computer 的不受限制接口(interface)，此解决方案并不完全安全- 必须注意不要使用别名或删除 Mmu或 Ram在计算机的公共(public)界面中。

此解决方案改为使用不变量，即数据存储在 Box 中永远不会移动 - 它的地址永远不会改变 - 只要 Box还活着。 Rust 不允许您在安全代码中依赖于此，因为移动了 Box可能导致它后面的内存被释放，从而留下悬空指针，但我们可以在不安全的代码中依赖它。

这个解决方案的主要技巧是使用原始指针进入 Box<Mmu> 的内容。和 Box<Ram>在 Cpu 中存储对它们的引用和 Mmu分别。这为您提供了一个基本安全的界面，并且不会阻止您移动 Computer在受限情况下围绕甚至改变它。

结束语

综上所述，我认为这些中的任何一个都不应该真正成为您解决此问题的方式。所有权是 Rust 的核心概念，它渗透到几乎所有代码的设计选择中。如果Mmu拥有 Ram和 Cpu拥有 Mmu ，这就是您的代码中应该具有的关系。如果你使用 Rc ，您甚至可以保持共享底层部分的能力，尽管是不可变的。