我可以将可变切片引用重新分配给自身的子切片吗? [英] Can I reassign a mutable slice reference to a sub-slice of itself?
问题描述
我正在实现类似堆栈的结构，其中该结构包含对切片的可变引用.
I'm implementing a stack-like structure, where the structure holds a mutable reference to a slice.
struct StackLike<'a, X> {
data: &'a mut [X],
}
我希望能够从堆栈中弹出最后一个元素，例如:
I'd like to be able to pop the last element off this stack, something like:
impl<'a, X> StackLike<'a, X> {
pub fn pop(&mut self) -> Option<&'a X> {
if self.data.is_empty() {
return None;
}
let n = self.data.len();
let result = &self.data[n - 1];
self.data = &mut self.data[0..n - 1];
Some(result)
}
}
此操作失败:
error[E0495]: cannot infer an appropriate lifetime for lifetime parameter in function call due to conflicting requirements
--> src/lib.rs:11:23
|
11 | let result = &self.data[n - 1];
| ^^^^^^^^^^^^^^^^
|
note: first, the lifetime cannot outlive the anonymous lifetime #1 defined on the method body at 6:5...
--> src/lib.rs:6:5
|
6 | / pub fn pop(&mut self) -> Option<&'a X> {
7 | | if self.data.is_empty() {
8 | | return None;
9 | | }
... |
13 | | Some(result)
14 | | }
| |_____^
note: ...so that reference does not outlive borrowed content
--> src/lib.rs:11:23
|
11 | let result = &self.data[n - 1];
| ^^^^^^^^^
note: but, the lifetime must be valid for the lifetime `'a` as defined on the impl at 5:6...
--> src/lib.rs:5:6
|
5 | impl<'a, X> StackLike<'a, X> {
| ^^
note: ...so that the expression is assignable
--> src/lib.rs:13:9
|
13 | Some(result)
| ^^^^^^^^^^^^
= note: expected `std::option::Option<&'a X>`
found `std::option::Option<&X>`
甚至 pop 不返回值，而仅缩小切片是不起作用的.
Even a simplified version of pop that doesn't return a value and only shrinks the slice doesn't work.
impl<'a, X> StackLike<'a, X> {
pub fn pop_no_return(&mut self) {
if self.data.is_empty() {
return;
}
let n = self.data.len();
self.data = &mut self.data[0..n - 1];
}
}
给出
error[E0495]: cannot infer an appropriate lifetime for lifetime parameter in function call due to conflicting requirements
--> src/lib.rs:11:26
|
11 | self.data = &mut self.data[0..n - 1];
| ^^^^^^^^^^^^^^^^^^^
|
note: first, the lifetime cannot outlive the anonymous lifetime #1 defined on the method body at 6:5...
--> src/lib.rs:6:5
|
6 | / pub fn pop_no_return(&mut self) {
7 | | if self.data.is_empty() {
8 | | return;
9 | | }
10 | | let n = self.data.len();
11 | | self.data = &mut self.data[0..n - 1];
12 | | }
| |_____^
note: ...so that reference does not outlive borrowed content
--> src/lib.rs:11:26
|
11 | self.data = &mut self.data[0..n - 1];
| ^^^^^^^^^
note: but, the lifetime must be valid for the lifetime `'a` as defined on the impl at 5:6...
--> src/lib.rs:5:6
|
5 | impl<'a, X> StackLike<'a, X> {
| ^^
note: ...so that reference does not outlive borrowed content
--> src/lib.rs:11:21
|
11 | self.data = &mut self.data[0..n - 1];
| ^^^^^^^^^^^^^^^^^^^^^^^^
是否可以进行这项工作，还是需要更明确地跟踪我感兴趣的切片的边界?
Is there a way to make this work, or do I need to track the bounds of the slice I'm interested in more explicitly?
推荐答案
我略微修改了Masklinn的代码，以允许在同一堆栈上调用多个 .pop():
I modified Masklinn's code slightly to allow multiple .pop()s to be called on the same stack:
struct StackLike<'a, X> {
data: &'a mut [X],
}
impl<'a, X> StackLike<'a, X> {
pub fn pop(&mut self) -> Option<&'a mut X> {
let data = std::mem::replace(&mut self.data, &mut []);
if let Some((last, subslice)) = data.split_last_mut() {
self.data = subslice;
Some(last)
} else {
None
}
}
}
fn main() {
let mut data = [1, 2, 3, 4, 5];
let mut stack = StackLike { data: &mut data };
let x = stack.pop().unwrap();
let y = stack.pop().unwrap();
println!("X: {}, Y: {}", x, y);
}
这里最棘手的部分是这一行(为明确起见，我添加了类型注释):
The tricky part here is this line (I added a type annotation for explicitness):
let data: &'a mut [X] = std::mem::replace(&mut self.data, &mut []);
我们暂时将 self.data 替换为一个空切片，以便我们可以拆分切片.如果您要简单地写
We replace self.data with an empty slice temporarily so that we can split the slice. If you were to write simply
let data: &'a mut [X] = self.data;
编译器会很不高兴:
error[E0312]: lifetime of reference outlives lifetime of borrowed content...
--> src/main.rs:7:33
|
7 | let data: &'a mut [X] = self.data;
| ^^^^^^^^^
|
note: ...the reference is valid for the lifetime `'a` as defined on the impl at 5:6...
--> src/main.rs:5:6
|
5 | impl<'a, X> StackLike<'a, X> {
| ^^
note: ...but the borrowed content is only valid for the anonymous lifetime #1 defined on the method body at 6:5
--> src/main.rs:6:5
|
6 | / pub fn pop(&mut self) -> Option<&'a mut X> {
7 | | let data: &'a mut [X] = self.data;
8 | | if let Some((last, subslice)) = data.split_last_mut() {
9 | | self.data = subslice;
... |
13 | | }
14 | | }
| |_____^
据我了解，问题在于 self.data 是可变引用，可变引用不是 Copy (请记住，您只能拥有一个一次).而且您不能移出 self.data ，因为 self 是可变引用，而不是所有者.因此，编译器尝试执行的操作是重新借入 self.data ，它会在& mut self 的生命周期内感染"它.这是一个死胡同:我们希望引用对'a 有效，但实际上仅在& mut self 的生命周期内有效，并且这些生命周期通常是不相关(它们不需要相关)，这会使编译器感到困惑.
As far as I understand it, the problem is that self.data is a mutable reference, and mutable references are not Copy (remember, you can only have one at a time). And you cannot move out of self.data since self is a mutable reference, not an owner. So what the compiler tries to do is to reborrow self.data, which "infects" it with with the lifetime of &mut self. This is a dead end: we want the reference to live for 'a, but it is actually valid only for the lifetime of &mut self, and these lifetimes are generally unrelated (and they don't need to be related), which leaves the compiler perplexed.
为帮助编译器，我们使用 std :: mem :: replace 将切片显式移出 self.data ，并将其临时替换为空切片，可以是任何生命周期.现在，我们可以使用 data 进行任何操作，而不会与& mut self 的生存期纠缠在一起.
To aid the compiler, we use std::mem::replace to explicitly move the slice out of self.data and temporarily replace it with an empty slice, which can be any lifetime. Now we can do anything with data without tangling it with the lifetime of &mut self.
这篇关于我可以将可变切片引用重新分配给自身的子切片吗?的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！
