mirror of https://github.com/sunface/rust-course
Rustln
3 years ago
committed by
GitHub
commit
e28872da93
@ -0,0 +1 @@
|
||||
# 裸指针、引用和智能指针 todo
|
||||
@ -0,0 +1,5 @@
|
||||
# 异步编程
|
||||
|
||||
接下来，我们将深入了解 async/await 的使用方式及背后的原理。
|
||||
|
||||
> 本章在内容上大量借鉴和翻译了原版英文书籍[Asynchronous Programming In Rust](https://rust-lang.github.io/async-book/01_getting_started/01_chapter.html), 特此感谢
|
||||
@ -1 +0,0 @@
|
||||
# 原生指针、引用和智能指针 todo
|
||||
@ -1 +0,0 @@
|
||||
# 所有权和借用
|
||||
@ -1,3 +0,0 @@
|
||||
# 复杂错误索引
|
||||
|
||||
读者可以在本章中通过错误前缀来索引查询相应的解决方案，简单的错误并不在本章的内容范畴之内。
|
||||
@ -1 +0,0 @@
|
||||
# 生命周期 todo
|
||||
@ -1,2 +1,3 @@
|
||||
# Rust最佳实践
|
||||
|
||||
对于生产级项目而言，运行稳定性和可维护性是非常重要的，本章就一起来看看 Rust 项目有哪些最佳实践准则。
|
||||
@ -0,0 +1,247 @@
|
||||
# 最终代码
|
||||
这一章真不好写( 也很难翻译... )，最终我们实现了一个 100% 安全但是功能残缺的双向链表。
|
||||
|
||||
同时在实现中，还有大量 `Rc` 和 `RefCell` 引起的运行时检查，最终会影响链表的性能。整个双向链表实现史就是一部别名和所有权的奋斗史。
|
||||
|
||||
总之，不管爱与不爱，它就这样了，特别是如果我们不在意内部的细节暴露给外面用户时。
|
||||
|
||||
而从下一章开始，我们将实现一个真正能够全盘掌控的链表，当然...通过 unsafe 代码实现！
|
||||
|
||||
|
||||
```rust
|
||||
|
||||
#![allow(unused)]
|
||||
fn main() {
|
||||
use std::rc::Rc;
|
||||
use std::cell::{Ref, RefMut, RefCell};
|
||||
|
||||
pub struct List<T> {
|
||||
head: Link<T>,
|
||||
tail: Link<T>,
|
||||
}
|
||||
|
||||
type Link<T> = Option<Rc<RefCell<Node<T>>>>;
|
||||
|
||||
struct Node<T> {
|
||||
elem: T,
|
||||
next: Link<T>,
|
||||
prev: Link<T>,
|
||||
}
|
||||
|
||||
|
||||
impl<T> Node<T> {
|
||||
fn new(elem: T) -> Rc<RefCell<Self>> {
|
||||
Rc::new(RefCell::new(Node {
|
||||
elem: elem,
|
||||
prev: None,
|
||||
next: None,
|
||||
}))
|
||||
}
|
||||
}
|
||||
|
||||
impl<T> List<T> {
|
||||
pub fn new() -> Self {
|
||||
List { head: None, tail: None }
|
||||
}
|
||||
|
||||
pub fn push_front(&mut self, elem: T) {
|
||||
let new_head = Node::new(elem);
|
||||
match self.head.take() {
|
||||
Some(old_head) => {
|
||||
old_head.borrow_mut().prev = Some(new_head.clone());
|
||||
new_head.borrow_mut().next = Some(old_head);
|
||||
self.head = Some(new_head);
|
||||
}
|
||||
None => {
|
||||
self.tail = Some(new_head.clone());
|
||||
self.head = Some(new_head);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub fn push_back(&mut self, elem: T) {
|
||||
let new_tail = Node::new(elem);
|
||||
match self.tail.take() {
|
||||
Some(old_tail) => {
|
||||
old_tail.borrow_mut().next = Some(new_tail.clone());
|
||||
new_tail.borrow_mut().prev = Some(old_tail);
|
||||
self.tail = Some(new_tail);
|
||||
}
|
||||
None => {
|
||||
self.head = Some(new_tail.clone());
|
||||
self.tail = Some(new_tail);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub fn pop_back(&mut self) -> Option<T> {
|
||||
self.tail.take().map(|old_tail| {
|
||||
match old_tail.borrow_mut().prev.take() {
|
||||
Some(new_tail) => {
|
||||
new_tail.borrow_mut().next.take();
|
||||
self.tail = Some(new_tail);
|
||||
}
|
||||
None => {
|
||||
self.head.take();
|
||||
}
|
||||
}
|
||||
Rc::try_unwrap(old_tail).ok().unwrap().into_inner().elem
|
||||
})
|
||||
}
|
||||
|
||||
pub fn pop_front(&mut self) -> Option<T> {
|
||||
self.head.take().map(|old_head| {
|
||||
match old_head.borrow_mut().next.take() {
|
||||
Some(new_head) => {
|
||||
new_head.borrow_mut().prev.take();
|
||||
self.head = Some(new_head);
|
||||
}
|
||||
None => {
|
||||
self.tail.take();
|
||||
}
|
||||
}
|
||||
Rc::try_unwrap(old_head).ok().unwrap().into_inner().elem
|
||||
})
|
||||
}
|
||||
|
||||
pub fn peek_front(&self) -> Option<Ref<T>> {
|
||||
self.head.as_ref().map(|node| {
|
||||
Ref::map(node.borrow(), |node| &node.elem)
|
||||
})
|
||||
}
|
||||
|
||||
pub fn peek_back(&self) -> Option<Ref<T>> {
|
||||
self.tail.as_ref().map(|node| {
|
||||
Ref::map(node.borrow(), |node| &node.elem)
|
||||
})
|
||||
}
|
||||
|
||||
pub fn peek_back_mut(&mut self) -> Option<RefMut<T>> {
|
||||
self.tail.as_ref().map(|node| {
|
||||
RefMut::map(node.borrow_mut(), |node| &mut node.elem)
|
||||
})
|
||||
}
|
||||
|
||||
pub fn peek_front_mut(&mut self) -> Option<RefMut<T>> {
|
||||
self.head.as_ref().map(|node| {
|
||||
RefMut::map(node.borrow_mut(), |node| &mut node.elem)
|
||||
})
|
||||
}
|
||||
|
||||
pub fn into_iter(self) -> IntoIter<T> {
|
||||
IntoIter(self)
|
||||
}
|
||||
}
|
||||
|
||||
impl<T> Drop for List<T> {
|
||||
fn drop(&mut self) {
|
||||
while self.pop_front().is_some() {}
|
||||
}
|
||||
}
|
||||
|
||||
pub struct IntoIter<T>(List<T>);
|
||||
|
||||
impl<T> Iterator for IntoIter<T> {
|
||||
type Item = T;
|
||||
|
||||
fn next(&mut self) -> Option<T> {
|
||||
self.0.pop_front()
|
||||
}
|
||||
}
|
||||
|
||||
impl<T> DoubleEndedIterator for IntoIter<T> {
|
||||
fn next_back(&mut self) -> Option<T> {
|
||||
self.0.pop_back()
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod test {
|
||||
use super::List;
|
||||
|
||||
#[test]
|
||||
fn basics() {
|
||||
let mut list = List::new();
|
||||
|
||||
// Check empty list behaves right
|
||||
assert_eq!(list.pop_front(), None);
|
||||
|
||||
// Populate list
|
||||
list.push_front(1);
|
||||
list.push_front(2);
|
||||
list.push_front(3);
|
||||
|
||||
// Check normal removal
|
||||
assert_eq!(list.pop_front(), Some(3));
|
||||
assert_eq!(list.pop_front(), Some(2));
|
||||
|
||||
// Push some more just to make sure nothing's corrupted
|
||||
list.push_front(4);
|
||||
list.push_front(5);
|
||||
|
||||
// Check normal removal
|
||||
assert_eq!(list.pop_front(), Some(5));
|
||||
assert_eq!(list.pop_front(), Some(4));
|
||||
|
||||
// Check exhaustion
|
||||
assert_eq!(list.pop_front(), Some(1));
|
||||
assert_eq!(list.pop_front(), None);
|
||||
|
||||
// ---- back -----
|
||||
|
||||
// Check empty list behaves right
|
||||
assert_eq!(list.pop_back(), None);
|
||||
|
||||
// Populate list
|
||||
list.push_back(1);
|
||||
list.push_back(2);
|
||||
list.push_back(3);
|
||||
|
||||
// Check normal removal
|
||||
assert_eq!(list.pop_back(), Some(3));
|
||||
assert_eq!(list.pop_back(), Some(2));
|
||||
|
||||
// Push some more just to make sure nothing's corrupted
|
||||
list.push_back(4);
|
||||
list.push_back(5);
|
||||
|
||||
// Check normal removal
|
||||
assert_eq!(list.pop_back(), Some(5));
|
||||
assert_eq!(list.pop_back(), Some(4));
|
||||
|
||||
// Check exhaustion
|
||||
assert_eq!(list.pop_back(), Some(1));
|
||||
assert_eq!(list.pop_back(), None);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn peek() {
|
||||
let mut list = List::new();
|
||||
assert!(list.peek_front().is_none());
|
||||
assert!(list.peek_back().is_none());
|
||||
assert!(list.peek_front_mut().is_none());
|
||||
assert!(list.peek_back_mut().is_none());
|
||||
|
||||
list.push_front(1); list.push_front(2); list.push_front(3);
|
||||
|
||||
assert_eq!(&*list.peek_front().unwrap(), &3);
|
||||
assert_eq!(&mut *list.peek_front_mut().unwrap(), &mut 3);
|
||||
assert_eq!(&*list.peek_back().unwrap(), &1);
|
||||
assert_eq!(&mut *list.peek_back_mut().unwrap(), &mut 1);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn into_iter() {
|
||||
let mut list = List::new();
|
||||
list.push_front(1); list.push_front(2); list.push_front(3);
|
||||
|
||||
let mut iter = list.into_iter();
|
||||
assert_eq!(iter.next(), Some(3));
|
||||
assert_eq!(iter.next_back(), Some(1));
|
||||
assert_eq!(iter.next(), Some(2));
|
||||
assert_eq!(iter.next_back(), None);
|
||||
assert_eq!(iter.next(), None);
|
||||
}
|
||||
}
|
||||
}
|
||||
```
|
||||
@ -0,0 +1,136 @@
|
||||
# Peek
|
||||
`push` 和 `pop` 的防不胜防的编译报错着实让人出了些冷汗，下面来看看轻松的，至少在之前的链表中是很轻松的 :)
|
||||
|
||||
```rust
|
||||
pub fn peek_front(&self) -> Option<&T> {
|
||||
self.head.as_ref().map(|node| {
|
||||
&node.elem
|
||||
})
|
||||
}
|
||||
```
|
||||
|
||||
额...好像被人发现我是复制黏贴的了，赶紧换一个:
|
||||
```rust
|
||||
pub fn peek_front(&self) -> Option<&T> {
|
||||
self.head.as_ref().map(|node| {
|
||||
// BORROW!!!!
|
||||
&node.borrow().elem
|
||||
})
|
||||
}
|
||||
```
|
||||
|
||||
```shell
|
||||
cargo build
|
||||
|
||||
error[E0515]: cannot return value referencing temporary value
|
||||
--> src/fourth.rs:66:13
|
||||
|
|
||||
66 | &node.borrow().elem
|
||||
| ^ ----------^^^^^
|
||||
| | |
|
||||
| | temporary value created here
|
||||
| |
|
||||
| returns a value referencing data owned by the current function
|
||||
```
|
||||
|
||||
从报错可以看出，原因是我们引用了局部的变量并试图在函数中返回。为了解释这个问题，先来看看 `borrow` 的定义:
|
||||
```rust
|
||||
fn borrow<'a>(&'a self) -> Ref<'a, T>
|
||||
fn borrow_mut<'a>(&'a self) -> RefMut<'a, T>
|
||||
```
|
||||
|
||||
这里返回的并不是 `&T` 或 `&mut T`，而是一个 [`Ref`](https://doc.rust-lang.org/std/cell/struct.Ref.html) 和 [`RefMut`](https://doc.rust-lang.org/std/cell/struct.RefMut.html)，那么它们是什么？说白了，它们就是在借用到的引用外包裹了一层。而且 `Ref` 和 `RefMut` 分别实现了 `Deref` 和 `DerefMut`，在绝大多数场景中，我们都可以像使用 `&T` 一样去使用它们。
|
||||
|
||||
|
||||
只能说是成是败都赖萧何，恰恰就因为这一层包裹，导致生命周期改变了，也就是 `Ref` 和内部引用的生命周期不再和 `RefCell` 相同，而 `Ref` 的生命周期是什么，相信大家都能看得出来，因此就造成了局部引用的问题。
|
||||
|
||||
事实上，这是必须的，如果内部的引用和外部的 `Ref` 生命周期不一致，那该如何管理？当 `Ref` 因超出作用域被 `drop` 时，内部的引用怎么办？
|
||||
|
||||
现在该怎么办？我们只想要一个引用，现在却多了一个 `Ref` 拦路虎。等等，如果我们不返回 `&T` 而是返回 `Ref` 呢？
|
||||
```rust
|
||||
use std::cell::{Ref, RefCell};
|
||||
|
||||
pub fn peek_front(&self) -> Option<Ref<T>> {
|
||||
self.head.as_ref().map(|node| {
|
||||
node.borrow()
|
||||
})
|
||||
}
|
||||
```
|
||||
|
||||
```shell
|
||||
> cargo build
|
||||
|
||||
error[E0308]: mismatched types
|
||||
--> src/fourth.rs:64:9
|
||||
|
|
||||
64 | / self.head.as_ref().map(|node| {
|
||||
65 | | node.borrow()
|
||||
66 | | })
|
||||
| |__________^ expected type parameter, found struct `fourth::Node`
|
||||
|
|
||||
= note: expected type `std::option::Option<std::cell::Ref<'_, T>>`
|
||||
found type `std::option::Option<std::cell::Ref<'_, fourth::Node<T>>>`
|
||||
```
|
||||
|
||||
嗯，类型不匹配了，要返回的是 `Ref<T>` 但是获取的却是 `Ref<Node<T>>`，那么现在看上去有两个选择：
|
||||
|
||||
- 抛弃这条路，换一条重新开始
|
||||
- 一条路走到死，最终通过更复杂的实现来解决
|
||||
|
||||
但是，仔细想想，这两个选择都不是我们想要的，那没办法了，只能继续深挖，看看有没有其它解决办法。啊哦，还真发现了一只野兽：
|
||||
```rust
|
||||
map<U, F>(orig: Ref<'b, T>, f: F) -> Ref<'b, U>
|
||||
where F: FnOnce(&T) -> &U,
|
||||
U: ?Sized
|
||||
```
|
||||
|
||||
就像在 `Result` 和 `Option` 上使用 `map` 一样，我们还能在 `Ref` 上使用 `map`:
|
||||
```rust
|
||||
pub fn peek_front(&self) -> Option<Ref<T>> {
|
||||
self.head.as_ref().map(|node| {
|
||||
Ref::map(node.borrow(), |node| &node.elem)
|
||||
})
|
||||
}
|
||||
```
|
||||
|
||||
```shell
|
||||
> cargo build
|
||||
```
|
||||
|
||||
Gooood! 本章节的编译错误可以说是多个链表中最难解决的之一，依然被我们成功搞定了！
|
||||
|
||||
|
||||
下面来写下测试用例，需要注意的是 `Ref` 不能被直接比较，因此我们需要先利用 `Deref` 解引用出其中的值，再进行比较。
|
||||
|
||||
```rust
|
||||
#[test]
|
||||
fn peek() {
|
||||
let mut list = List::new();
|
||||
assert!(list.peek_front().is_none());
|
||||
list.push_front(1); list.push_front(2); list.push_front(3);
|
||||
|
||||
assert_eq!(&*list.peek_front().unwrap(), &3);
|
||||
}
|
||||
```
|
||||
|
||||
```shell
|
||||
> cargo test
|
||||
|
||||
Running target/debug/lists-5c71138492ad4b4a
|
||||
|
||||
running 10 tests
|
||||
test first::test::basics ... ok
|
||||
test fourth::test::basics ... ok
|
||||
test second::test::basics ... ok
|
||||
test fourth::test::peek ... ok
|
||||
test second::test::iter_mut ... ok
|
||||
test second::test::into_iter ... ok
|
||||
test third::test::basics ... ok
|
||||
test second::test::peek ... ok
|
||||
test second::test::iter ... ok
|
||||
test third::test::iter ... ok
|
||||
|
||||
test result: ok. 10 passed; 0 failed; 0 ignored; 0 measured
|
||||
```
|
||||
|
||||
终于可以把文章开头的冷汗擦拭干净了，忘掉这个章节吧，让我来养你...哦不对，让我们开始一段真正轻松的章节。
|
||||
@ -0,0 +1,374 @@
|
||||
# 数据布局
|
||||
那么单向链表的队列长什么样？对于栈来说，我们向一端推入( push )元素，然后再从同一端弹出( pop )。对于栈和队列而言，唯一的区别在于队列从末端弹出。
|
||||
|
||||
栈的实现类似于下图：
|
||||
```shell
|
||||
input list:
|
||||
[Some(ptr)] -> (A, Some(ptr)) -> (B, None)
|
||||
|
||||
stack push X:
|
||||
[Some(ptr)] -> (X, Some(ptr)) -> (A, Some(ptr)) -> (B, None)
|
||||
|
||||
stack pop:
|
||||
[Some(ptr)] -> (A, Some(ptr)) -> (B, None)
|
||||
```
|
||||
|
||||
由于队列是首端进，末端出，因此我们需要决定将 `push` 和 `pop` 中的哪个放到末端去操作，如果将 `push` 放在末端操作:
|
||||
```shell
|
||||
input list:
|
||||
[Some(ptr)] -> (A, Some(ptr)) -> (B, None)
|
||||
|
||||
flipped push X:
|
||||
[Some(ptr)] -> (A, Some(ptr)) -> (B, Some(ptr)) -> (X, None)
|
||||
```
|
||||
|
||||
而如果将 `pop` 放在末端:
|
||||
```shell
|
||||
input list:
|
||||
[Some(ptr)] -> (A, Some(ptr)) -> (B, Some(ptr)) -> (X, None)
|
||||
|
||||
flipped pop:
|
||||
[Some(ptr)] -> (A, Some(ptr)) -> (B, None)
|
||||
```
|
||||
|
||||
但是这样实现有一个很糟糕的地方：两个操作都需要遍历整个链表后才能完成。队列要求 `push` 和 `pop` 操作需要高效，但是遍历整个链表才能完成的操作怎么看都谈不上高效！
|
||||
|
||||
其中一个解决办法就是保存一个指针指向末端:
|
||||
```rust
|
||||
use std::mem;
|
||||
|
||||
pub struct List<T> {
|
||||
head: Link<T>,
|
||||
tail: Link<T>, // NEW!
|
||||
}
|
||||
|
||||
type Link<T> = Option<Box<Node<T>>>;
|
||||
|
||||
struct Node<T> {
|
||||
elem: T,
|
||||
next: Link<T>,
|
||||
}
|
||||
|
||||
impl<T> List<T> {
|
||||
pub fn new() -> Self {
|
||||
List { head: None, tail: None }
|
||||
}
|
||||
|
||||
pub fn push(&mut self, elem: T) {
|
||||
let new_tail = Box::new(Node {
|
||||
elem: elem,
|
||||
// 在尾端推入一个新节点时，新节点的下一个节点永远是 None
|
||||
next: None,
|
||||
});
|
||||
|
||||
// 让 tail 指向新的节点，并返回之前的 old tail
|
||||
let old_tail = mem::replace(&mut self.tail, Some(new_tail));
|
||||
|
||||
match old_tail {
|
||||
Some(mut old_tail) => {
|
||||
// 若 old tail 存在，则让该节点指向新的节点
|
||||
old_tail.next = Some(new_tail);
|
||||
}
|
||||
None => {
|
||||
// 否则，将 head 指向新的节点
|
||||
self.head = Some(new_tail);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
在之前的各种链表锤炼下，我们对于相关代码应该相当熟悉了，因此可以适当提提速 - 在写的过程中，事实上我碰到了很多错误，这些错误就不再一一列举。
|
||||
|
||||
但是如果你担心不再能看到错误，那就纯属多余了:
|
||||
```shell
|
||||
> cargo build
|
||||
|
||||
error[E0382]: use of moved value: `new_tail`
|
||||
--> src/fifth.rs:38:38
|
||||
|
|
||||
26 | let new_tail = Box::new(Node {
|
||||
| -------- move occurs because `new_tail` has type `std::boxed::Box<fifth::Node<T>>`, which does not implement the `Copy` trait
|
||||
...
|
||||
33 | let old_tail = mem::replace(&mut self.tail, Some(new_tail));
|
||||
| -------- value moved here
|
||||
...
|
||||
38 | old_tail.next = Some(new_tail);
|
||||
| ^^^^^^^^ value used here after move
|
||||
```
|
||||
|
||||
新鲜出炉的错误，接好！`Box` 并没有实现 `Copy` 特征，因此我们不能在两个地方进行赋值。好在，可以使用没有所有权的引用类型:
|
||||
```rust
|
||||
pub struct List<T> {
|
||||
head: Link<T>,
|
||||
tail: Option<&mut Node<T>>, // NEW!
|
||||
}
|
||||
|
||||
type Link<T> = Option<Box<Node<T>>>;
|
||||
|
||||
struct Node<T> {
|
||||
elem: T,
|
||||
next: Link<T>,
|
||||
}
|
||||
|
||||
impl<T> List<T> {
|
||||
pub fn new() -> Self {
|
||||
List { head: None, tail: None }
|
||||
}
|
||||
|
||||
pub fn push(&mut self, elem: T) {
|
||||
let new_tail = Box::new(Node {
|
||||
elem: elem,
|
||||
next: None,
|
||||
});
|
||||
|
||||
let new_tail = match self.tail.take() {
|
||||
Some(old_tail) => {
|
||||
old_tail.next = Some(new_tail);
|
||||
old_tail.next.as_deref_mut()
|
||||
}
|
||||
None => {
|
||||
self.head = Some(new_tail);
|
||||
self.head.as_deref_mut()
|
||||
}
|
||||
};
|
||||
|
||||
self.tail = new_tail;
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
```shell
|
||||
> cargo build
|
||||
|
||||
error[E0106]: missing lifetime specifier
|
||||
--> src/fifth.rs:3:18
|
||||
|
|
||||
3 | tail: Option<&mut Node<T>>, // NEW!
|
||||
| ^ expected lifetime parameter
|
||||
```
|
||||
|
||||
好吧，结构体中的引用类型需要显式的标注生命周期，先加一个 `'a` 吧:
|
||||
```rust
|
||||
pub struct List<'a, T> {
|
||||
head: Link<T>,
|
||||
tail: Option<&'a mut Node<T>>, // NEW!
|
||||
}
|
||||
|
||||
type Link<T> = Option<Box<Node<T>>>;
|
||||
|
||||
struct Node<T> {
|
||||
elem: T,
|
||||
next: Link<T>,
|
||||
}
|
||||
|
||||
impl<'a, T> List<'a, T> {
|
||||
pub fn new() -> Self {
|
||||
List { head: None, tail: None }
|
||||
}
|
||||
|
||||
pub fn push(&mut self, elem: T) {
|
||||
let new_tail = Box::new(Node {
|
||||
elem: elem,
|
||||
next: None,
|
||||
});
|
||||
|
||||
let new_tail = match self.tail.take() {
|
||||
Some(old_tail) => {
|
||||
old_tail.next = Some(new_tail);
|
||||
old_tail.next.as_deref_mut()
|
||||
}
|
||||
None => {
|
||||
self.head = Some(new_tail);
|
||||
self.head.as_deref_mut()
|
||||
}
|
||||
};
|
||||
|
||||
self.tail = new_tail;
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
```shell
|
||||
cargo build
|
||||
|
||||
error[E0495]: cannot infer an appropriate lifetime for autoref due to conflicting requirements
|
||||
--> src/fifth.rs:35:27
|
||||
|
|
||||
35 | self.head.as_deref_mut()
|
||||
| ^^^^^^^^^^^^
|
||||
|
|
||||
note: first, the lifetime cannot outlive the anonymous lifetime #1 defined on the method body at 18:5...
|
||||
--> src/fifth.rs:18:5
|
||||
|
|
||||
18 | / pub fn push(&mut self, elem: T) {
|
||||
19 | | let new_tail = Box::new(Node {
|
||||
20 | | elem: elem,
|
||||
21 | | // When you push onto the tail, your next is always None
|
||||
... |
|
||||
39 | | self.tail = new_tail;
|
||||
40 | | }
|
||||
| |_____^
|
||||
note: ...so that reference does not outlive borrowed content
|
||||
--> src/fifth.rs:35:17
|
||||
|
|
||||
35 | self.head.as_deref_mut()
|
||||
| ^^^^^^^^^
|
||||
note: but, the lifetime must be valid for the lifetime 'a as defined on the impl at 13:6...
|
||||
--> src/fifth.rs:13:6
|
||||
|
|
||||
13 | impl<'a, T> List<'a, T> {
|
||||
| ^^
|
||||
= note: ...so that the expression is assignable:
|
||||
expected std::option::Option<&'a mut fifth::Node<T>>
|
||||
found std::option::Option<&mut fifth::Node<T>>
|
||||
```
|
||||
|
||||
好长... Rust 为啥这么难... 但是，这里有一句重点:
|
||||
|
||||
> the lifetime must be valid for the lifetime 'a as defined on the impl
|
||||
|
||||
意思是说生命周期至少要和 `'a` 一样长，是不是因为编译器为 `self` 推导的生命周期不够长呢？我们试着来手动标注下:
|
||||
```rust
|
||||
pub fn push(&'a mut self, elem: T) {
|
||||
```
|
||||
|
||||
当当当当，成功通过编译:
|
||||
```shell
|
||||
cargo build
|
||||
|
||||
warning: field is never used: `elem`
|
||||
--> src/fifth.rs:9:5
|
||||
|
|
||||
9 | elem: T,
|
||||
| ^^^^^^^
|
||||
|
|
||||
= note: #[warn(dead_code)] on by default
|
||||
```
|
||||
|
||||
这个错误可以称之为错误之王，但是我们依然成功的解决了它，太棒了！再来实现下 `pop`:
|
||||
```rust
|
||||
pub fn pop(&'a mut self) -> Option<T> {
|
||||
self.head.take().map(|head| {
|
||||
let head = *head;
|
||||
self.head = head.next;
|
||||
|
||||
if self.head.is_none() {
|
||||
self.tail = None;
|
||||
}
|
||||
|
||||
head.elem
|
||||
})
|
||||
}
|
||||
```
|
||||
|
||||
看起来不错，写几个测试用例溜一溜:
|
||||
```rust
|
||||
mod test {
|
||||
use super::List;
|
||||
#[test]
|
||||
fn basics() {
|
||||
let mut list = List::new();
|
||||
|
||||
// Check empty list behaves right
|
||||
assert_eq!(list.pop(), None);
|
||||
|
||||
// Populate list
|
||||
list.push(1);
|
||||
list.push(2);
|
||||
list.push(3);
|
||||
|
||||
// Check normal removal
|
||||
assert_eq!(list.pop(), Some(1));
|
||||
assert_eq!(list.pop(), Some(2));
|
||||
|
||||
// Push some more just to make sure nothing's corrupted
|
||||
list.push(4);
|
||||
list.push(5);
|
||||
|
||||
// Check normal removal
|
||||
assert_eq!(list.pop(), Some(3));
|
||||
assert_eq!(list.pop(), Some(4));
|
||||
|
||||
// Check exhaustion
|
||||
assert_eq!(list.pop(), Some(5));
|
||||
assert_eq!(list.pop(), None);
|
||||
}
|
||||
}
|
||||
```
|
||||
```shell
|
||||
cargo test
|
||||
|
||||
error[E0499]: cannot borrow `list` as mutable more than once at a time
|
||||
--> src/fifth.rs:68:9
|
||||
|
|
||||
65 | assert_eq!(list.pop(), None);
|
||||
| ---- first mutable borrow occurs here
|
||||
...
|
||||
68 | list.push(1);
|
||||
| ^^^^
|
||||
| |
|
||||
| second mutable borrow occurs here
|
||||
| first borrow later used here
|
||||
|
||||
error[E0499]: cannot borrow `list` as mutable more than once at a time
|
||||
--> src/fifth.rs:69:9
|
||||
|
|
||||
65 | assert_eq!(list.pop(), None);
|
||||
| ---- first mutable borrow occurs here
|
||||
...
|
||||
69 | list.push(2);
|
||||
| ^^^^
|
||||
| |
|
||||
| second mutable borrow occurs here
|
||||
| first borrow later used here
|
||||
|
||||
error[E0499]: cannot borrow `list` as mutable more than once at a time
|
||||
--> src/fifth.rs:70:9
|
||||
|
|
||||
65 | assert_eq!(list.pop(), None);
|
||||
| ---- first mutable borrow occurs here
|
||||
...
|
||||
70 | list.push(3);
|
||||
| ^^^^
|
||||
| |
|
||||
| second mutable borrow occurs here
|
||||
| first borrow later used here
|
||||
|
||||
|
||||
....
|
||||
|
||||
** WAY MORE LINES OF ERRORS **
|
||||
|
||||
....
|
||||
|
||||
error: aborting due to 11 previous errors
|
||||
```
|
||||
|
||||
🙀🙀🙀，震惊！但编译器真的没错，因为都是我们刚才那个标记惹的祸。
|
||||
|
||||
我们为 `self` 标记了 `'a`，意味着在 `'a` 结束前，无法再去使用 `self`，大家可以自己推断下 `'a` 的生命周期是多长。
|
||||
|
||||
那么该怎么办？回到老路 `RefCell` 上？显然不可能，那只能祭出大杀器：裸指针。
|
||||
|
||||
> 事实上，上文的问题主要是自引用引起的，感兴趣的同学可以查看[这里](https://course.rs/advance/circle-self-ref/intro.html)深入阅读。
|
||||
|
||||
```rust
|
||||
pub struct List<T> {
|
||||
head: Link<T>,
|
||||
tail: *mut Node<T>, // DANGER DANGER
|
||||
}
|
||||
|
||||
type Link<T> = Option<Box<Node<T>>>;
|
||||
|
||||
struct Node<T> {
|
||||
elem: T,
|
||||
next: Link<T>,
|
||||
}
|
||||
```
|
||||
|
||||
如上所示，当使用裸指针后， `head` 和 `tail` 就不会形成自引用的问题，也不再违反 Rust 严苛的借用规则。
|
||||
|
||||
> 注意！当前的实现依然是有严重问题的，在后面我们会修复
|
||||
|
||||
果然，编程的最高境界就是回归本质：使用 C 语言的东东。
|
||||
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in new issue