盒装价值的寿命不够长

Question

我正在尝试在 Rust 中实现一个缺点列表作为练习。我已经设法解决了除此之外的所有编译器错误：

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),
}

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

Answer 1

不幸的是，您修复其他编译器错误的尝试导致您陷入不一致的黑暗境地。首先，您需要决定是要 Box<List> 还是 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 更改为 return 一个简单的 List，即：

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

这也为您节省了调用中所有讨厌的重新借用 (&*):

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

最后，至于为什么盒子活得不够长：嗯，你基本上创建了一个 local/temporary 盒子，引用了它，然后试图在不保持盒子存活的情况下传递引用.一个盒子 without an owner 被释放，所以你需要给它一个所有者。在上面的固定代码中，owner是我们创建并写入&mut List.

的List::Node的next字段

Answer 2

我认为您遗漏了 Rust 的一些关键细节；我认为我们需要处理三件事：

模式的工作原理；
不可变（&）和可变（&mut）引用的区别；
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 a新参考。

你在价值观方面也有点过分了；我倾向于说 new() 应该 return 为 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 来引用该框的内容。请记住，与普通表达式相比，模式完全是从前到后。

最后，我强烈建议对所有这些使用 impls，将所有方法放在 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);
}

盒装价值的寿命不够长

Boxed value does not live long enough

rust