如何将结构引用存储在 vec 中并稍后在其他地方使用该结构？

Question

我想创建一个结构体，在vec 中存储对它的引用，然后稍后使用该结构体：

pub struct NonTerminal {
    name: String
}

impl<'a> NonTerminal {
    pub fn new(grammar: &'a mut Grammar, name: &str) -> &'a NonTerminal {
        let t = NonTerminal {
            name: name.to_string()
        };
        grammar.non_terminals.push(t);
        grammar.non_terminals.last().unwrap()
    }
}

pub struct Grammar<'a> {
    non_terminals: Vec<NonTerminal>
}

pub fn create_rules<'a>(g: &'a mut grammar::Grammar<'a>) {
    let sum  =  grammar::NonTerminal::new(g, "Sum");
    let product = grammar::NonTerminal::new(g, "Product");
    // this fails: "cannot borrow `*g` as mutable more than once at a time, second mutable borrow occurs here"
    // ...
    // use the sum and product vars when constructing rules
}

如何解决这个问题？

Answer 1

你不能这样做。这只是变相的经典“矢量推送”示例。让我们看一下这个简化但语义等效的代码：

let mut v = Vec::new();
v.push(27);
let twenty_seven = v.last().unwrap();
v.push(3);
println!("{}", twenty_seven);

这不会编译，也永远不会在 Rust 中编译，因为这本质上是内存不安全的。您有一个指向向量中元素的引用（指针）。但是对Vec::push 的调用可能会重新分配，从而使对其元素的所有引用无效。在 C++ 中它会编译，但会导致 UB，因为您会尝试读取未初始化或未分配的内存。

您的问题的“答案”……并不简单。您必须为您的程序考虑另一种结构。有时，使用引用计数的智能指针（如Rc）很有用。它会很容易地解决你的问题。但在许多其他情况下，您最好完全重新考虑您的应用程序。

Answer 2

在任何给定时间都可能发生一次&mut 数据借用。

我建议颠倒事情，以便Grammar 具有添加NonTerminals 的功能

pub struct NonTerminal {
    name: String
}

impl NonTerminal {
    pub fn new(name: &str) -> NonTerminal {
        Self {
            name: name.to_string()
        }
    }
}

pub struct Grammar {
    pub non_terminals: Vec<NonTerminal>
}

impl Grammar {
    fn add_non_terminal(&mut self, s: &str) -> &NonTerminal {
        self.non_terminals.push(NonTerminal::new(s));
        self.non_terminals.last().unwrap()
    }
}

pub fn main() {
    let mut g = Grammar {
        non_terminals: vec![]
    };
    let product_ref = g.add_non_terminal("Product");
    let sum_ref = g.add_non_terminal("Sum");
}

---

Updated 基于来自@Lukas Kalbertodt 的反馈。 可以通过g.non_terminals遍历所有非终端