Question

我正在尝试在Rust中实现循环链接数据结构。我的Node定义为：

#[derive(Debug)]
enum Node<'a> {
    Link(&'a Node<'a>),
    Leaf,
}

我正在尝试构建这样的最小结构（额外的括号以提高终身可见性）：

fn main() {
    let placeholder = Node::Leaf;
    {
        let link1 = Node::Link(&placeholder);
        {
            let link2 = Node::Link(&link1);
            println!("{:?}", link2);
        } // link2 gets dropped
    } // link1 gets dropped
}

这样可行，但现在我不知道如何用link2引用替换占位符来＆＃34;关闭周期＆＃34;。我尝试了这个，但它不起作用，因为我无法分配到link1，这是借用了上面的一行，并且因为link2会超出范围，而它是＆＃39 ; s仍被link1引用：

let placeholder = Node::Leaf;
{
    let mut link1 = Node::Link(&placeholder);
    {
        let link2 = Node::Link(&link1);
        link1 = Node::Link(&link2);
        println!("{:?}", link2);
    } // link2 gets dropped
} // link1 gets dropped

error: `link2` does not live long enough
  --> src/main.rs:15:9
   |
13 |             link1 = Node::Link(&link2);
   |                                 ----- borrow occurs here
14 |             println!("{:?}", link2);
15 |         } // link2 gets dropped
   |         ^ `link2` dropped here while still borrowed
16 |     } // link1 gets dropped
   |     - borrowed value needs to live until here

error[E0506]: cannot assign to `link1` because it is borrowed
  --> src/main.rs:13:13
   |
12 |             let link2 = Node::Link(&link1);
   |                                     ----- borrow of `link1` occurs here
13 |             link1 = Node::Link(&link2);
   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^ assignment to borrowed `link1` occurs here

我可以尝试使用Rc来避免这些生命周期问题，但这听起来像是会破坏Rust的0运行时成本生命周期管理的目的。

将所有节点放入Vec并仅直接引用该节点的另一种尝试也不起作用：

use std::ops::IndexMut;

let mut store = Vec::new();
store.push(Node::Leaf);
store.push(Node::Link(&store[0]));
store.push(Node::Link(&store[1]));
*store.index_mut(1) = Node::Link(&store[2]);

因为我无法改变任何节点而没有可变地借用它们，但它们已经被不可避免地借用了。

error[E0502]: cannot borrow `store` as immutable because it is also borrowed as mutable
  --> src/main.rs:12:28
   |
12 |     store.push(Node::Link(&store[0]));
   |     -----                  ^^^^^    - mutable borrow ends here
   |     |                      |
   |     |                      immutable borrow occurs here
   |     mutable borrow occurs here

error[E0502]: cannot borrow `store` as mutable because it is also borrowed as immutable
  --> src/main.rs:13:5
   |
12 |     store.push(Node::Link(&store[0]));
   |                            ----- immutable borrow occurs here
13 |     store.push(Node::Link(&store[1]));
   |     ^^^^^ mutable borrow occurs here
14 |     *store.index_mut(1) = Node::Link(&store[2]);
15 | }
   | - immutable borrow ends here

error[E0502]: cannot borrow `store` as immutable because it is also borrowed as mutable
  --> src/main.rs:13:28
   |
13 |     store.push(Node::Link(&store[1]));
   |     -----                  ^^^^^    - mutable borrow ends here
   |     |                      |
   |     |                      immutable borrow occurs here
   |     mutable borrow occurs here

error[E0502]: cannot borrow `store` as mutable because it is also borrowed as immutable
  --> src/main.rs:14:6
   |
12 |     store.push(Node::Link(&store[0]));
   |                            ----- immutable borrow occurs here
13 |     store.push(Node::Link(&store[1]));
14 |     *store.index_mut(1) = Node::Link(&store[2]);
   |      ^^^^^ mutable borrow occurs here
15 | }
   | - immutable borrow ends here

有没有办法让这样的结构具有循环链接而没有运行时开销，例如像我尝试过的纯引用？我有额外的内存成本，例如支持所有节点的后备Vec。

Answer 1

有没有办法让这样的结构具有循环链接而没有运行时开销，例如像我尝试过的纯引用？我没有额外的内存成本，比如支持Vec持有所有节点的所有权。

是的，有很多方法。

然而，实现Rust需要始终强制执行别名XOR可变性原则是至关重要的。最好在编译时强制执行它，以便有0运行时成本，但有时需要在运行时管理它，并且有多种结构：

Cell，RefCell，AtomicXXX，Mutex，RWLock（名字不详）是关于安全地改变别名的项目，
Rc，Weak，Arc，是关于拥有多个所有者。

与获得的灵活性相比，平衡潜在的运行时间开销是一门艺术;需要一些经验和实验。

在您的特定情况下（使用引用彼此的节点构建BNF语法），我们确实可以使用Cell实现0运行时开销以实现可变性。

然而，主要困难是获得一组具有相同生命周期的节点。你在Vec<Node>的想法走在正确的轨道上，但是当你借用一个节点时你注意到你不能再次改变Vec：这是因为增长Vec可能使它重新分配其底层存储，这将导致已经获得的引用悬空（指向释放的内存）。

通用的解决方案是使用不安全的代码来自己管理节点的生命周期。但是，你很幸运：正如你所提到的，你的情况很特殊，因为节点的数量是有限的（通过语法定义），你可以一次性删除它们。这需要竞技场。

因此，我的建议是双重的：

存储typed-arena，
使用Cell表示可变部分（&T为Copy）。

如果没有unsafe代码，您将无法将竞技场存储在与其余语法相同的结构中;取决于您是使用unsafe还是构建程序，以便竞技场比计算更长。

有没有办法用循环链接构建一个没有运行时开销的结构？

1 个答案: