Rust单链表实现中self借用问题求助：生命周期与借用错误解析

嘿，作为Rust新手碰到这些问题太正常了——这正是Rust的所有权系统在帮你建立内存安全的思维习惯！先帮你逐个拆解错误，再给你修复后的代码示例。

你的原始代码 #

use std::fmt::Display;
#[derive(Debug)]
struct Node<T> {
    payload: T,
    next: Option<Box<Node<T>>>
}
impl<T> Node<T> where T: Display + PartialEq {
    fn new(payload: T, next: Option<Box<Node<T>>>) -> Option<Box<Node<T>>> {
        Some(Box::new(Node { payload, next }))
    }
    fn print_nodes(&mut self) {
        let this = self;
        loop {
            match this.next {
                Some(_) => {
                    print!("{} -> ", &this.payload);
                }
                None => {
                    print!("{}", &this.payload);
                    break;
                }
            }
            this = &mut this.next.unwrap();
        }
    }
}
fn main() {
    let a = Node::new(String::from("hello"), None);
    let b = Node::new(String::from("hey"), a);
    let mut d = b.unwrap();
    d.print_nodes();
}

你遇到的错误信息 #

error[E0597]: borrowed value does not live long enough
 --> main.rs:31:43
|
31 |             this = &mut this.next.unwrap();
|                     ------------------^ temporary value dropped here while still borrowed
|                     |
|                     temporary value created here
32 |         }
33 |     }
|     - temporary value needs to live until here
|
= note: consider using a `let` binding to increase its lifetime

error[E0507]: cannot move out of borrowed content
 --> main.rs:31:25
|
31 |             this = &mut this.next.unwrap();
|                         ^^^^ cannot move out of borrowed content

error[E0384]: cannot assign twice to immutable variable `this`
 --> main.rs:31:13
|
20 |         let this = self;
|             ---- first assignment to `this`
...
31 |             this = &mut this.next.unwrap();
|             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ cannot assign twice to immutable variable

错误逐个解析 #

1. cannot assign twice to immutable variable 'this'
   你用let this = self;声明了一个不可变变量，但后续又尝试给它重新赋值。Rust里不可变变量一旦绑定就不能修改，只需把它改成可变绑定：let mut this = self;。

2. cannot move out of borrowed content
this是&mut Node<T>类型的借用指针，你没有节点的所有权，只能借用。而unwrap()会尝试把Option里的Box<Node<T>>移动出来——这是所有权层面的操作，借用指针根本没权限这么做。这里应该用as_mut()获取Option内部的可变借用，而非直接移动。

3. borrowed value does not live long enough
   就算解决了前两个问题，unwrap()返回的Box<Node<T>>是临时值，你取它的可变借用后，临时值会在当前语句结束后销毁，导致借用悬空。还是得用as_mut()来获取持久的可变借用。

修复后的代码 #

use std::fmt::Display;
#[derive(Debug)]
struct Node<T> {
    payload: T,
    next: Option<Box<Node<T>>>
}
impl<T> Node<T> where T: Display + PartialEq {
    fn new(payload: T, next: Option<Box<Node<T>>>) -> Option<Box<Node<T>>> {
        Some(Box::new(Node { payload, next }))
    }
    fn print_nodes(&mut self) {
        // 声明可变的借用指针
        let mut this = self;
        loop {
            // 先打印当前节点内容
            print!("{}", &this.payload);
            
            // 匹配下一个节点的可变借用，避免所有权移动
            match &mut this.next {
                Some(next_node) => {
                    print!(" -> ");
                    // 更新this为下一个节点的可变借用，无临时值问题
                    this = next_node;
                }
                None => {
                    // 无后续节点，退出循环
                    break;
                }
            }
        }
        // 最后换行优化输出格式
        println!();
    }
}
fn main() {
    let a = Node::new(String::from("hello"), None);
    let b = Node::new(String::from("hey"), a);
    let mut d = b.unwrap();
    d.print_nodes();
}

额外说明 #

• 修复后的代码用&mut this.next匹配，完全基于借用操作，不会触发所有权移动；
• 通过Some(next_node)直接获取下一个节点的可变借用，更新this时不会产生临时值，解决了生命周期问题；
• 调整了打印逻辑，让代码结构更清晰，最后添加换行让输出更美观。

内容的提问来源于stack exchange，提问作者Emulebest