盒装值的生命周期不够长

Question

我正在尝试用Rust实现一个cons列表作为练习。我已经成功解决了所有的编译器错误，除了这个:

Compiling list v0.0.1 (file:///home/nate/git/rust/list)
/home/nate/git/rust/list/src/main.rs:18:24: 18:60 error: borrowed value does not live long enough
/home/nate/git/rust/list/src/main.rs:18         List::End => list = &*(box List::Node(x, box List::End)),
                                                                     ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
/home/nate/git/rust/list/src/main.rs:16:34: 21:2 note: reference must be valid for the anonymous lifetime #1 defined on the block at 16:33...
/home/nate/git/rust/list/src/main.rs:16 fn add(mut list: &List, x: uint) {
/home/nate/git/rust/list/src/main.rs:17     match *list {
/home/nate/git/rust/list/src/main.rs:18         List::End => list = &*(box List::Node(x, box List::End)),
/home/nate/git/rust/list/src/main.rs:19         List::Node(_, ref next_node) => add(&**next_node, x),
/home/nate/git/rust/list/src/main.rs:20     }
/home/nate/git/rust/list/src/main.rs:21 }
/home/nate/git/rust/list/src/main.rs:18:16: 18:60 note: ...but borrowed value is only valid for the expression at 18:15
/home/nate/git/rust/list/src/main.rs:18         List::End => list = &*(box List::Node(x, box List::End)),
                                                             ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
error: aborting due to previous error
Could not compile `list`.

To learn more, run the command again with --verbose.

我正在尝试编译的代码：

enum List {
    Node(uint, Box<List>),
    End,
}

fn main() {
    let mut list = new();

    add(&*list, 10);
    //add(list, 20);
    //add(list, 30);

    print(&*list);
}

fn add(mut list: &List, x: uint) {
    match *list {
        List::End => list = &*(box List::Node(x, box List::End)),
        List::Node(_, ref next_node) => add(&**next_node, x),
    }
}

fn new() -> Box<List> {
    box List::End
}

那么为什么装箱值的寿命不够长呢？是因为我立即取消引用它们吗？我尝试过这种方式：

match *list {
    List::End => {
        let end = box List::Node(x, box List::End);
        list = &*end;
    }
    List::Node(_, ref next_node) => add(&**next_node, x),
}

但我得到了完全相同的错误。我错过了什么？

- Lily Mara

Answer 1

我认为你缺少Rust的一些关键细节; 我认为我们需要处理以下三个问题：

1. 模式是如何工作的；
2. 不可变(&)和可变(&mut)引用之间的区别；
3. Rust所有权模型的工作原理（因为你尝试使用&*box）。

首先，我将处理模式部分; 在fn add(mut list: &List, x: uint)中，使用了两个模式，即mut list和x。 模式的其他示例是let lhs = rhs;左侧和match表达式的每个分支之前的位。 它们如何有效地应用于调用？实际上就像你正在做这样:

fn add(__arg_0: &List, __arg_1: uint) {
    let mut list = __arg_0;
    let x = __arg_1;
    …
}

也许这种看待事物的方式会更清晰：函数的签名完全不考虑变量绑定的模式。您的函数签名实际上是规范形式的fn add(&List, uint)。 mut list部分只是意味着将&List值绑定到可变名称；也就是说，您可以向list名称分配新值，但它在函数外没有任何影响，它纯粹是将变量绑定到位置的问题。

现在进入第二个问题：学习不可变引用（类型&T，值&x）和可变引用（类型&mut T，值&x）之间的区别。它们非常基本，我在这里不会详细介绍它们-它们已经有足够的文件记录，您应该阅读那些内容。简而言之：如果您想要改变某些东西，则需要&mut而不是&，因此您的add方法需要采用&mut List。

第三个问题是所有权：在Rust中，每个对象都在精确的一个位置拥有所有权；没有垃圾回收或任何东西，所有权的唯一性意味着只要对象超出范围，它就会被销毁。在这种情况下，有问题的表达式是&*(box List::Node(x, box List::End))。您已经将值装箱，但实际上没有在任何地方存储它：你只是试图获取其中包含的值的引用，但盒子将立即被删除。在这种情况下，您实际上想要修改List的内容；您想编写*list = List::Node(x, box List::End)，意思是“在list的内容中存储一个List::Node值”，而不是list = &…，意思是“为变量list分配一个新引用”。

您还过度使用了值的装箱；我倾向于说new()应返回List而不是Box<List>，尽管问题略有争议。无论如何，这是我得到的add方法：

fn add(list: &mut List, x: uint) {
    match *list {
        List::End => *list = List::Node(x, box List::End),
        List::Node(_, box ref mut next_node) => add(next_node, x),
    }
}

你可能会遇到困难的主要部分是模式box ref mut next_node。 box ref mut部分的含义是“将值从其盒子中取出，然后创建对该值的可变引用”；因此，给定一个Box<List>，它将产生一个引用到该盒子内容的&mut List。请记住，与正常表达式完全相反，模式是完全背靠背的。

最后，我强烈建议为所有这些使用impl，将所有方法放在List类型上：

enum List {
    Node(uint, Box<List>),
    End,
}

impl List {
    fn new() -> List {
        List::End
    }

    fn add(&mut self, x: uint) {
        match *self {
            List::End => *self = List::Node(x, box List::End),
            List::Node(_, box ref mut next_node) => next_node.add(x),
        }
    }
}

fn main() {
    let mut list = List::new();

    list.add(10);
}

- Chris Morgan

Answer 2

你试图修复其他编译错误，但不幸的是，这导致了一种不一致的情况。首先，你需要确定你想要一个 List 还是 Box<List> 作为（子）列表头的句柄。让我们选择 List ，因为它更灵活，通常是最简单的方法。

然后，你需要意识到 mut list：&List 和 list：&mut List 之间存在区别。第一个是只读引用，你可以将其更改为指向其他只读内容。第二个是可读写引用，你不能将其更改为指向其他可读写内容。还有 mut list：&mut List ，因为这两个功能是正交的。

在add中，当你写list = ...时，你只影响了你的本地变量。它对调用者没有影响。你想要改变调用者看到的列表节点！既然我们说过要处理List而不是盒子，我们将更改现有列表节点的内容（用Node(..., box End)替换最后的End）。也就是说，签名和代码如下所示：

fn add(list: &mut List, x: uint) {
    match *list {
        List::End => *list = List::Node(x, box List::End),
        List::Node(_, box ref mut next_node) => add(next_node, x),
    }
}

请注意，*list =与list =不同，我们现在是在原地更改列表节点的内容，而不是使我们的本地引用指向另一个节点。

为了保持一致性和人性化（以及稍微提高一点效率），你应该将new更改为返回一个裸的List，即：new List()。

fn new() -> List {
    List::End
}

这还可以避免在调用中进行繁琐的再借用（&*）操作：

let list = new(); // type: List
add(&mut list, 10);

最后，关于为什么盒子没有存活足够长的原因：你基本上创建了一个本地/临时盒子，获取了对它的引用，然后尝试传递引用而不保持盒子存活。没有所有者的盒子被释放内存，所以你需要给它一个所有者。在上面修复的代码中，所有者是我们创建并写入&mut List的List::Node的next字段。

- user395760

---

ref mut next_node 和 &mut **next_node 应该写成 box ref mut next_node 和 next_node。 - Chris Morgan

@ChrisMorgan 非常感谢！已经整合进去了！ - user395760