rust - 将消耗树转换为非消耗树

Question

我创建了以下具有消耗深度优先遍历的树。

Playpen

struct TreeNode {
    value: i32,
    left: Option<Box<TreeNode>>,
    right: Option<Box<TreeNode>>,
}

fn main() {
    let root = build_tree();
    root.depth_first_pre();
}

fn build_tree() -> TreeNode {
    let root = TreeNode { value: 2,
        left: Some(Box::new(TreeNode { value: 7,
                            left: Some(Box::new(TreeNode { value: 2, left: None, right: None })),
                            right: Some(Box::new(TreeNode { value: 6,
                                                left: Some(Box::new(TreeNode { value: 5, left: None, right: None })),
                                                right: Some(Box::new(TreeNode { value: 11, left: None, right: None })) })) })),
        right: Some(Box::new(TreeNode { value: 5,
                            left: None,
                            right: Some(Box::new(TreeNode { value: 9,
                                                left: Some(Box::new(TreeNode { value: 4, left: None, right: None })),
                                                right: None })) }))};
    return root;
}

impl TreeNode {
    fn depth_first_pre(self) {
        print!("{}, ", self.value);

        if self.left.is_some() {
            self.left.unwrap().depth_first_pre();
        }

        if self.right.is_some() {
            self.right.unwrap().depth_first_pre();
        }
    }
}

Unwrap 从选项中取出值，在这种情况下是可以的，因为每个值只被访问一次。

如果我尝试调用该函数两次，就会出现问题:

root.depth_first_pre();
root.depth_first_pre();

这会导致函数的第二次调用出错:

<anon>:10:5: 10:9 error: use of moved value: `root` [E0382]
<anon>:10     root.depth_first_pre();
              ^~~~
<anon>:9:5: 9:9 note: `root` moved here because it has type `TreeNode`, which is non-copyable
<anon>:9     root.depth_first_pre();
             ^~~~
error: aborting due to previous error

我的理解是，它已被第一个函数调用移出，并在它超出该函数的范围后取消分配。

我该如何解决这个问题？

我已经尝试更改函数以引用 self (&self) 并将 .unwrap() 更改为 as_ref() 但是它没有解决我的问题。

Answer 1

它与您建议的更改 添加 as_ref 一起工作得很好，而不是将 unwrap 替换为 as_ref:

fn depth_first_pre(&self) {
    print!("{}, ", self.value);

    if self.left.is_some() {
        self.left.as_ref().unwrap().depth_first_pre();
    }

    if self.right.is_some() {
        self.right.as_ref().unwrap().depth_first_pre();
    }
}

但是，使用 if let 会更加地道:

fn depth_first_pre(&self) {
    print!("{}, ", self.value);

    if let Some(ref left) = self.left {
       left.depth_first_pre();
    }

    if let Some(ref right) = self.right {
        right.depth_first_pre();
    }
}