作为练习,我正在尝试在 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),
}
但我得到了完全相同的错误。我错过了什么?
最佳答案
我认为您遗漏了 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;
…
}
也许这样看事情会更清楚;函数的签名根本不考虑变量绑定(bind)的模式。您的函数签名实际上是规范形式 fn add(&List, uint)
. mut list
部分只是意味着您正在绑定(bind) &List
可变名称的值;也就是说,您可以为 list
分配一个新值名称,但它在函数之外没有任何影响,这纯粹是将变量绑定(bind)到位置的问题。
现在进入第二个问题:了解不可变引用(类型 &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::Node
list
内容里面的值” 而不是 list = &…
, 意思是“分配给变量 list
一个新的引用”。
您对值(value)观的限制也有点过火了;我倾向于说 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);
}
关于rust - 盒装值(value)的生命周期不够长,我们在Stack Overflow上找到一个类似的问题: https://stackoverflow.com/questions/27742032/