如何让Rust编译器认可已处理“Value used here after move”场景？

问题代码 #

pub fn group_strings(strings: Vec<String>) -> Vec<Vec<String>> {
    let mut strings_iter = strings.into_iter();

    // Unwrap because the problem guarantees that strings len >= 1
    let mut result = vec![vec![strings_iter.next().unwrap()]];

    let mut seq_found: bool = false;
    while let Some(input_string) = strings_iter.next() {
        // Is this string in seq with any of the strings in the result?
        for output_string_list in result.iter_mut() {
            if Solution::are_in_seq(&output_string_list[0], &input_string) {
                // We are cloning because rust complains that we are using input_string
                // after it is moved here, although seq_found flag ensures that we don't.
                output_string_list.push(input_string);
                seq_found = true;
                break;
            }
        }

        if !seq_found {
            result.push(vec![input_string]);
        }
        seq_found = false;            
    }

    return result;
}

编译报错 #

Line 22, Char 34: use of moved value: `input_string` (solution.rs)
   |
9 |         while let Some(input_string) = strings_iter.next() {
   |                        ------------
   |                        |
   |                        this reinitialization might get skipped
   |                        move occurs because `input_string` has type `std::string::String`, which does not implement the `Copy` trait
...
15 |                     output_string_list.push(input_string);
   |                                             ------------ value moved here
...
22 |                 result.push(vec![input_string]);
   |                                  ^^^^^^^^^^^^ value used here after move
For more information about this error, try `rustc --explain E0382`.

问题分析 #

虽然你通过seq_found布尔变量确保input_string只会被移动一次，但Rust编译器不会分析这种跨代码块的布尔逻辑关联。它只追踪代码的控制流和所有权转移路径，因此会判定input_string存在被移动后再次使用的风险。

解决方案：用Option管理所有权 #

通过将input_string包装进Option，明确告知编译器值的存在状态，避免不必要的克隆：

pub fn group_strings(strings: Vec<String>) -> Vec<Vec<String>> {
    let mut strings_iter = strings.into_iter();

    // Unwrap since problem guarantees strings length >= 1
    let mut result = vec![vec![strings_iter.next().unwrap()]];

    while let Some(input) = strings_iter.next() {
        let mut input_opt = Some(input);
        
        for output_list in result.iter_mut() {
            // 先检查input_opt是否还有值，同时借用字符串做判断
            if let Some(ref s) = input_opt {
                if Solution::are_in_seq(&output_list[0], s) {
                    // take()取出值并将input_opt设为None，明确转移所有权
                    output_list.push(input_opt.take().unwrap());
                    break;
                }
            } else {
                // 已经转移所有权，无需继续遍历
                break;
            }
        }

        // 仅当input_opt仍持有值时，说明未找到匹配，加入新分组
        if let Some(remaining_input) = input_opt {
            result.push(vec![remaining_input]);
        }
    }

    result
}

原理说明 #

• input_opt.take()会将Option中的值取出，同时将input_opt设置为None，编译器能清晰追踪到：一旦进入匹配分支，input_opt就不再持有值。
• 后续的if let Some(...)只会在input_opt未被取出值（即未找到匹配）的情况下执行，此时remaining_input拥有完整所有权，不会触发移动后使用的错误。

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