Rust字符串长期引用困惑：循环实现双行轮换报E0506错误求解

问题概述 #

在练习Rust时，尝试读取字符串中的行并通过两个变量轮换保存最后两行的引用，分步实现的代码可以正常运行，但改为循环后触发了借用检查错误。

可运行的分步代码 #

fn main() {
    let test_lines = "line 1
        line 2
        line 3
        line 4
        line 5";
    let mut lines = test_lines.lines();

    let mut a = &String::new();
    let mut b = &String::new();
    println!("{} - {}", a, b);

    let temp = lines.next().unwrap().trim().to_string();
    a = b;
    b = &temp;
    println!("{} - {}", a, b);

    let temp = lines.next().unwrap().trim().to_string();
    a = b;
    b = &temp;
    println!("{} - {}", a, b);

    let temp = lines.next().unwrap().trim().to_string();
    a = b;
    b = &temp;
    println!("{} - {}", a, b);
}

分步代码运行结果 #

- 
 - line 1
line 1 - line 2
line 2 - line 3

循环版本的错误代码 #

fn main() {
    let test_lines = "line 1
            line 2
            line 3
            line 4
            line 5";

    let mut a = &String::new();
    let mut b = &String::new();

    let temp;
    for line in test_lines.lines() {
        a = b;
        temp = line.trim().to_string();
        b = &temp;

        println!("{} - {}", a, b);
    }
}

错误信息 #

error[E0506]: cannot assign to `temp` because it is borrowed
  --> src/main.rs:68:9
   |
68 |         temp = line.trim().to_string();
   |         ^^^^ `temp` is assigned to here but it was already borrowed
69 |         b = &temp;
   |             ----- `temp` is borrowed here
70 |
71 |         println!("{} - {}", a, b);
   |                             - borrow later used here

错误原因分析 #

分步代码能运行的核心原因是：每次的temp是独立变量。每个temp在自己的代码块中创建，b引用的是这个独立的temp，后续新的temp是完全不同的变量，生命周期彼此不重叠，借用检查器不会报错。

但循环版本中，temp是循环外声明的单个变量：

1. 第一次循环中，b = &temp创建了对temp的不可变借用，这个借用会持续到println执行完毕。
2. 第二次循环时，尝试给temp赋值属于可变借用，此时b仍持有对temp的不可变借用——Rust的借用规则禁止同一时间存在可变借用和不可变借用，因此触发编译错误。

C/C++没有编译期的生命周期和借用检查，只要指针指向的内存有效即可，但Rust的借用系统是为了在编译期避免悬垂引用和数据竞争，因此这种写法不符合规则。

正确实现方案 #

不需要使用引用持有行数据，直接持有String的所有权即可解决问题。以下是两种可行的实现方式：

方式一：使用Option<String>管理行数据 #

通过Option处理初始空值，每次循环转移所有权：

fn main() {
    let test_lines = "line 1
            line 2
            line 3
            line 4
            line 5";

    let mut prev_line: Option<String> = None;
    let mut current_line: Option<String> = None;

    for line in test_lines.lines() {
        // 将当前行的所有权转移给前一行，清空当前行的位置
        prev_line = current_line.take();
        // 存储新的当前行
        current_line = Some(line.trim().to_string());

        // 打印最后两行，空值时显示空字符串
        println!("{} - {}", 
            prev_line.as_deref().unwrap_or(""), 
            current_line.as_deref().unwrap_or("")
        );
    }
}

方式二：使用两个String变量交换数据 #

通过std::mem::swap交换字符串内容，避免所有权转移的复杂操作：

fn main() {
    let test_lines = "line 1
            line 2
            line 3
            line 4
            line 5";

    let mut a = String::new();
    let mut b = String::new();

    for line in test_lines.lines() {
        // 交换a和b的内容，让a保存上一次的b的值
        std::mem::swap(&mut a, &mut b);
        // 清空b并写入新行
        b.clear();
        b.push_str(line.trim());

        println!("{} - {}", a, b);
    }
}

这两种方式都直接持有String的所有权，Rust会自动管理内存，旧字符串在被替换时会自动释放，完全符合借用规则，同时实现了“保留最后两行”的需求。

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