循环变量的寿命不够长

Question

过去几天我一直在玩Rust，而我仍然在努力处理内存管理（数字）。

我写了一个简单的项目 ，从lexing /解析文本文件创建结构层次结构（“关键字”）。

关键字的定义如下：

pub struct Keyword<'a> {
    name: String,
    code: u32,
    parent: Option<&'a Keyword<'a>>,
}

这是我对这个C结构的等价物：

typedef struct Keyword Keyword;

struct Keyword {
    char* name;
    unsigned int code;
    Keyword* parent;
};

层次结构只是关键字的容器，定义如下：

pub struct KeywordHierarchy<'a> {
    keywords: Vec<Box<Keyword<'a>>>,
}

impl<'a> KeywordHierarchy<'a> {
    fn add_keyword(&mut self, keyword: Box<Keyword<'a>>) {
        self.keywords.push(keyword);
    }
}

在parse函数（ 它是完整解析器的存根 ）中，我重新创建了在我的代码中产生生命周期错误的条件。

fn parse<'a>() -> Result<KeywordHierarchy<'a>, String> {

    let mut hierarchy = KeywordHierarchy { keywords: Vec::new() };

    let mut first_if = true;
    let mut second_if = false;

    while true {

        if first_if {

            // All good here.

            let root_keyword = Keyword {
                name: String::from("ROOT"),
                code: 0,
                parent: None,
            };
            hierarchy.add_keyword(Box::new(root_keyword));

            first_if = false;
            second_if = true;
        }

        if second_if {

            // Hierarchy might have expired here?

            // Find parent
            match hierarchy.keywords.iter().find(|p| p.code == 0) {
                None => return Err(String::from("No such parent")),
                Some(parent) => {

                    // If parent is found, create a child
                    let child = Keyword {
                        name: String::from("CHILD"),
                        code: 1,
                        parent: Some(&parent),
                    };
                    hierarchy.add_keyword(Box::new(child));
                }
            }

            second_if = false;
        }

        if !first_if && !second_if {
            break;
        }
    }

    Ok(hierarchy)

}

有一个while循环，通过词法分析器令牌去。

在第一个if ，我将ROOT关键字添加到层次结构中，这是唯一没有父项的层次结构，并且一切都按预期顺利进行。

在第二个if ，我解析子关键字，并在调用KeywordHierarchy.add_keyword()时得到生命周期错误。

hierarchy.keywords` does not live long enough

你们能推荐一种惯用的方法来解决这个问题吗？

干杯。

PS点击这里操场

Answer 1

我可以在你的设计中看到的直接问题是你的循环将修改hierarchy.keywords向量（在first_if块中），但它也借用hierarchy.keywords向量中的元素（在second_if块中）。

这是有问题的，因为修改向量可能会导致其后备缓冲区被重新分配，如果允许，则会使向量的所有现有借用无效。 （因此不允许。）

您是否考虑过使用竞技场来保存关键字而不是Vec ？ 阿里纳斯的设计是为了让你可以在其中分配新的东西，同时仍然有先前在竞技场内分配的元素。

---

更新：这是你的代码的修订版本，它说明了使用竞技场（在这种情况下是rustc_arena::TypedArena ，但这只是为了让我可以在play.rust-lang.org服务上运行）和Vec<&Keyword>处理查找。

https://play.rust-lang.org/?gist=fc6d81cb7efa7e4f32c481ab6482e587&version=nightly&backtrace=0

代码的关键部分是这样的：

第一： KeywordHierarchy现在与vec一起举办竞技场：

pub struct KeywordHierarchy<'a> {
    keywords: Vec<&'a Keyword<'a>>,
    kw_arena: &'a TypedArena<Keyword<'a>>,
}

第二：添加关键字现在在竞技场中分配点，并在vec中存储对该点的引用：

fn add_keyword(&mut self, keyword: Keyword<'a>) {
    let kw = self.kw_arena.alloc(keyword);
    self.keywords.push(kw);
}

第三： fn parse函数现在将竞技场（引用）作为输入，因为我们需要竞技场比fn parse的堆栈帧寿命更长：

fn parse<'a>(arena: &'a TypedArena<Keyword<'a>>) -> Result<KeywordHierarchy<'a>, String> {
    ...

第四：为了避免借用hierarchy时借用hierarchy是可变的同时迭代它，我将hierarchy修改移到了查找父match ：

        // Find parent
        let parent = match hierarchy.keywords.iter().find(|p| p.code == 0) {
            None => return Err(String::from("No such parent")),
            Some(parent) => *parent, // (this deref is important)
        };
        // If parent is found, create a child
        let child = Keyword {
            name: String::from("CHILD"),
            code: 1,
            parent: Some(parent),
        };
        hierarchy.add_keyword(child);
        second_if = false;