Rust使用replacen替换字符串时临时值释放报错的解决方法

问题场景 #

尝试将字符替换后的结果赋值回原始magazine变量时，代码编译失败。

问题代码 #

fn can_construct(ransom_note: String, magazine: String) -> bool {
    let ransom_arr: Vec<char> = ransom_note.chars().collect();
    let mut magazine = magazine.as_str();
    for index in 0..ransom_arr.len() {
        let original_length = &magazine.len();
        let mut new_str = &magazine.replacen(ransom_arr[index], "", 1);
        if &new_str.len() == original_length {
            return false;
        }
        magazine = new_str.as_mut_str();
    }
    true
}

编译器报错信息 #

let original_length = &magazine.len();
                       -------------- borrow later used here
let mut new_str = &magazine.replacen(ransom_arr[index], "", 1);
                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ creates a temporary which is freed while still in use
...
}
- temporary value is freed at the end of this statement

= note: consider using a `let` binding to create a longer lived value

对应题目规则 #

给定两个字符串ransomNote和magazine，若ransomNote可以通过使用magazine中的字母构造则返回true，否则返回false：

• magazine中的每个字母在ransomNote中最多只能使用一次。

测试示例：

• 输入: ransomNote = "aa", magazine = "ab"
• 输出: false

报错根因 #

这个错误是Rust所有权机制拦截悬空引用的正常表现：

1. magazine.replacen(...)会返回一个全新的堆分配String值，你没有将这个新String绑定到具名变量上持有所有权，直接取它的引用赋值给new_str。这个无主的String属于临时值，会在当前语句执行结束后被自动释放。
2. 后续你尝试将这个临时值的可变引用存入magazine（magazine是&str类型，本身只存字符串的内存地址，不持有所有权），等临时值被释放后，magazine存储的地址就会指向无效的已释放内存，编译器直接阻止了这个内存风险。
3. 代码中let original_length = &magazine.len();属于无意义写法，len()返回的是实现了Copy特征的基础数字类型usize，直接存值即可，多余的引用会平白增加借用检查的复杂度。

修复方案 #

方案1：保留原替换逻辑，修正所有权问题 #

顺着你原本逐次替换字符的思路，给replacen生成的新String绑定所有权，避免临时值提前释放：

fn can_construct(ransom_note: String, magazine: String) -> bool {
    let ransom_arr: Vec<char> = ransom_note.chars().collect();
    // 直接持有magazine的String所有权，不提前转&str
    let mut magazine = magazine;
    for c in ransom_arr {
        let original_len = magazine.len();
        // 给替换生成的新String绑定具名变量，延长生命周期到循环轮次结束
        let new_str = magazine.replacen(c, "", 1);
        if new_str.len() == original_len {
            return false;
        }
        // 所有权转移给magazine，不存在悬空引用问题
        magazine = new_str;
    }
    true
}

方案2：字符计数法（性能更优） #

逐次替换字符串每次都会生成新的堆分配字符串，性能较差，更高效的实现是统计字符出现次数：

fn can_construct(ransom_note: String, magazine: String) -> bool {
    // 仅匹配ASCII字符时用长度256的数组即可，性能远高于HashMap
    let mut char_count = [0i32; 256];
    for b in magazine.into_bytes() {
        char_count[b as usize] += 1;
    }
    for b in ransom_note.into_bytes() {
        let idx = b as usize;
        char_count[idx] -= 1;
        if char_count[idx] < 0 {
            return false;
        }
    }
    true
}

如果题目需要支持非ASCII的Unicode字符，把数组替换为std::collections::HashMap<char, i32>即可，计数逻辑完全一致。

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