too-many-lists/bad-stack/basic-operations

[giscus[bot]]

too-many-lists/bad-stack/basic-operations

https://course.rs/too-many-lists/bad-stack/basic-operations.html

[dzwduan]

clone 用起来简单难 需要修改

[sunface]

来个 pr 😆

[PaiGack]

一直 clone 一直爽

[maolonglong]

为 Link 实现 Default trait，然后用 mem::take 去偷 self.head 能更简洁些

[maolonglong]

pub fn push(&mut self, elem: T) {
    let new_node = Box::new(Node {
        elem: elem,
        next: mem::take(&mut self.head),
    });

    self.head = Link::More(new_node);
}

[wuhaiji]

push方法直接把所有权拿到方法内部，再通过返回值转移回去可以吗
pub fn push(mut self, element: i32) -> Self {
let new_node = Node {
element,
next: self.head,
};
self.head = Link::More(Box::new(new_node));
self
}

[compdzwio]

如果没有要实现Drop那是可以，不实现Drop你就得手动写方法释放链表了。

[compdzwio]

pop 也可以这样实现，

   pub fn pop(&mut self) -> Option<i32> {
     	let result;
	    match &mut self.head {
	       Link::Empty => {
	           result = None;
	       }
	       Link::More(node) => {
	       	   result = Some(node.elem);
		       self.head = std::mem::replace(&mut node.next, Link::Empty);
	       }
	    }
    }

也可以这样实现， 多种方式加强理解学习。

   pub fn pop(&mut self) -> Option<i32> {
     	let result;
	    match self.head {
	       Link::Empty => {
	           result = None;
	       }
	       Link::More(ref mut node) => {
	       	   result = Some(node.elem);
		       self.head = std::mem::replace(&mut node.next, Link::Empty);
	       }
	    }
    }

[TangJiajian]

这种链表写法，针对实现了 Copy trait 的类型（比如 i32 ）是正确的，但是对于没有实现 Copy trait 的 elem 类型，Some(node.elem) 要改成 Some(std::mem::replace(node.elem, /*val*/)) 。相比之下，原作的链表写法更简洁，也不存在这个问题。

[GmwEnterprise]

“试图将借用的值 self 中的 head 字段的所有权转移给 next ，在 Rust 中这是不被允许的”

对于这段话我不太理解，在 StackOverflow 找到了如下解释：

In Rust, objects can be moved out of variables, but not out of structure fields or slice subscripts. This is because the compiler can check that the variable is not used after the move, as well as arrange that its destructor is not invoked. This is not possible for objects stored in fields of structures or inside slices, at least not without adding overhead to every structure or container.

因为编译器无法检查 self.实例 所有权被移出后是否不被使用，切片中也是如此

[ax7e]

我的理解是self的所有权被转移后是出于非 empty 非 Some态的，这个状态在rust中是不合法的

[nzhl]

1. 我理解上面这个 case 和 SO 上这个解释其实是两个不同的case, 上面这个case 说的是 cannot move out of node.next which is behind a shared reference, 这里的关键点在于 node 是一个 shared reference, 换句话你对 next 的所有权是“借” 的, 不能拿"借"的所有权去做转移.

2. "我的理解是self的所有权被转移后是出于非 empty 非 Some态的，这个状态在rust中是不合法的"

其实是合法的, rust 中有个概念叫 'partial moved', 你完全可以把 self (对应的底层 struct) 中的某些字段给 move 到一个新的 variable 里面. 只不过后续这个 struct 里面这个字段再也不能被使用了, 但是并不妨碍结构体里面其他的字段被使用. 见 https://doc.rust-lang.org/rust-by-example/scope/move/partial_move.html

[xcdnlgd]

Link->Option
Empty->None
More->Some

type Link = Option<Box>
Option有take方法

[xcdnlgd]

用 Option 后还可以使用 ? 语法糖

pub struct List {
    head: Link,
}

struct Node {
    item: i32,
    next: Link,
}

type Link = Option<Box<Node>>;

impl List {
    pub fn new() -> Self {
        List { head: None }
    }
}

impl List {
    pub fn push_front(&mut self, item: i32) {
        let new_node = Box::new(Node {
            item,
            next: self.head.take(),
        });
        self.head = Some(new_node);
    }

    pub fn pop_front(&mut self) -> Option<i32> {
        let head = self.head.take()?;
        self.head = head.next;
        Some(head.item)
    }
}

pop_front()那里的 ? 代表如果 head 为 None ，直接return None
然后 head 就不是一个Option了，而是一个 Box<Node>