包含可变切片的结构
Structs containing mutable slices
我正在尝试了解生命周期并将可变切片存储在结构中。
我想出了这个例子,其中包含一个带有切片的结构和一个 take
函数,该函数将 return n
元素(如果存在)并将其余部分存储在结构本身中.此代码无法编译。
fn main() {
let mut v: Vec<u8> = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
let mut blah = Blah { slice: &mut v[..] };
let b = blah.take(5);
println!("b: {:?}", b);
}
#[derive(Debug)]
struct Blah<'a> {
slice: &'a mut [u8],
}
impl<'a> Blah<'a> {
pub fn take(&'a mut self, n: usize) -> Option<Self> {
if self.slice.len() > n {
let blah = Blah {
slice: &mut self.slice[..n],
};
self.slice = &mut self.slice[n..];
Some(blah)
} else {
None
}
}
}
编译器错误:
error[E0499]: cannot borrow `*self.slice` as mutable more than once at a time
--> src/main.rs:21:31
|
15 | impl<'a> Blah<'a> {
| -- lifetime `'a` defined here
...
19 | slice: &mut self.slice[..n],
| ---------- first mutable borrow occurs here
20 | };
21 | self.slice = &mut self.slice[n..];
| ^^^^^^^^^^ second mutable borrow occurs here
22 | Some(blah)
| ---------- returning this value requires that `*self.slice` is borrowed for `'a`
我有一个我不想复制的大内存缓冲区。相反,我想通过随身携带 "fat pointers"(类似于偏移量 + 长度)来继续引用相同的内存。
Rust 编译器无法检测到子切片的两个借用是不重叠的。当你借用&mut self.slice[..n]
时,整个self.slice
被认为是借用的,所以你不能再借用剩余的元素。
有一种方法split_at_mut
,旨在通过从一个切片中产生两个不相交的可变借用来解决这个问题。您的代码可以更新为像这样使用它:
impl<'a> Blah<'a> {
pub fn take(&'a mut self, n: usize) -> Option<Self> {
if self.slice.len() > n {
let (left, right) = self.slice.split_at_mut(n);
let blah = Blah {
slice: left
};
self.slice = right;
Some(blah)
} else {
None
}
}
}
我正在尝试了解生命周期并将可变切片存储在结构中。
我想出了这个例子,其中包含一个带有切片的结构和一个 take
函数,该函数将 return n
元素(如果存在)并将其余部分存储在结构本身中.此代码无法编译。
fn main() {
let mut v: Vec<u8> = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
let mut blah = Blah { slice: &mut v[..] };
let b = blah.take(5);
println!("b: {:?}", b);
}
#[derive(Debug)]
struct Blah<'a> {
slice: &'a mut [u8],
}
impl<'a> Blah<'a> {
pub fn take(&'a mut self, n: usize) -> Option<Self> {
if self.slice.len() > n {
let blah = Blah {
slice: &mut self.slice[..n],
};
self.slice = &mut self.slice[n..];
Some(blah)
} else {
None
}
}
}
编译器错误:
error[E0499]: cannot borrow `*self.slice` as mutable more than once at a time
--> src/main.rs:21:31
|
15 | impl<'a> Blah<'a> {
| -- lifetime `'a` defined here
...
19 | slice: &mut self.slice[..n],
| ---------- first mutable borrow occurs here
20 | };
21 | self.slice = &mut self.slice[n..];
| ^^^^^^^^^^ second mutable borrow occurs here
22 | Some(blah)
| ---------- returning this value requires that `*self.slice` is borrowed for `'a`
我有一个我不想复制的大内存缓冲区。相反,我想通过随身携带 "fat pointers"(类似于偏移量 + 长度)来继续引用相同的内存。
Rust 编译器无法检测到子切片的两个借用是不重叠的。当你借用&mut self.slice[..n]
时,整个self.slice
被认为是借用的,所以你不能再借用剩余的元素。
有一种方法split_at_mut
,旨在通过从一个切片中产生两个不相交的可变借用来解决这个问题。您的代码可以更新为像这样使用它:
impl<'a> Blah<'a> {
pub fn take(&'a mut self, n: usize) -> Option<Self> {
if self.slice.len() > n {
let (left, right) = self.slice.split_at_mut(n);
let blah = Blah {
slice: left
};
self.slice = right;
Some(blah)
} else {
None
}
}
}