Question

我想创建一个简单的链表并在其中添加一个值。如何实施add方法，以便在第42行（第{{}}}次调用时输出此代码100 50 10 5？

root.print()

(Playground)

我重写了这个函数：

use std::rc::Rc;

struct Node {
    value: i32,
    next: Option<Box<Node>>,
}

impl Node {
    fn print(&self) {
        let mut current = self;
        loop {
            println!("{}", current.value);
            match current.next {
                Some(ref next) => {
                    current = &**next;
                }
                None => break,
            }
        }
    }

    fn add(&mut self, node: Node) {
        let item = Some(Box::new(node));
        let mut current = self;
        loop {
            match current.next {
                None => current.next = item,
                _ => {} 
                //Some(next) => { current = next; }
            }
        }
    }
}

fn main() {
    let leaf = Node {
        value: 10,
        next: None,
    };
    let branch = Node {
        value: 50,
        next: Some(Box::new(leaf)),
    };
    let mut root = Node {
        value: 100,
        next: Some(Box::new(branch)),
    };
    root.print();

    let new_leaf = Node {
        value: 5,
        next: None,
    };
    root.add(new_leaf);
    root.print();
}

但是编译器说

fn add(&mut self, node: Node) {
    let item = Some(Box::new(node));
    let mut current = self;
    loop {
        match current {
            &mut Node {
                     value: _,
                     next: None,
                 } => current.next = item,
            _ => {} 
            //Some(next) => { current = next; }
        }
    }
}

我不明白为什么如果该项目只使用过一次就会先前移动该项目，以及如何实施error[E0382]: use of moved value: `item` --> <anon>:28:40 | 28 | None => current.next = item, | ^^^^ value moved here in previous iteration of loop | = note: move occurs because `item` has type `std::option::Option<std::boxed::Box<Node>>`, which does not implement the `Copy` trait分支以迭代列表？

Answer 1

这就是你需要写它的方式(playground link)

fn add(&mut self, node: Node) {
    let item = Some(Box::new(node));
    let mut current = self;
    loop {
        match moving(current).next {
            ref mut slot @ None => {
                *slot = item;
                return;
            }
            Some(ref mut next) => current = next,
        };
    }
}

好的，这是什么？

第1步，我们需要在使用值return后立即item。然后编译器正确地看到它只从一次移动。

ref mut slot @ None => {
    *slot = item;
    return;
}

第2步，使用我们在此过程中更新的&mut指针进行循环是非常棘手的。

默认情况下，Rust会重新展开一个被解除引用的&mut。只要借用的产品仍然存在，它就不会消耗参考，它只是考虑借用它。

显然，这在这里效果不佳。我们希望从旧current到新current“切换”。我们可以强制&mut指针服从改为移动语义。

我们需要这个（identity函数强制移动！）：

match moving(current).next

我们也可以这样写：

let tmp = current;
match tmp.next

或者这个：

match {current}.next

第3步，我们在其内部查找后没有当前指针，因此请调整代码。

使用ref mut slot来保留下一个值的位置。

如何实现链表的添加方法？

1 个答案: