Rust 普林顿！循环外是一个无法访问的语句，如何在；可达的；方式

循环终止后，如何打印频率

HashSet

？问题似乎是无法保证循环终止

use std::collections::HashSet;
use std::fs;

fn main() {
    let f = fs::read_to_string("input.txt").expect("Unable to open file");

    let mut total = 0;
    let mut frequencies = HashSet::new();
    frequencies.insert(0);

    loop {
        for line in f.lines() {
            let line_trimmed = line.trim();
            let something = line_trimmed.parse::<i32>().unwrap();
            total += something;
            // println!("{:?}",total);

            if frequencies.contains(&total) {
                println!("duplicated found {:?}", total);
                return;
            }
            frequencies.insert(total);
        }
    }
    println!("duplicated found {:?}", frequencies);
}

使用std:：collections:：HashSet；
使用std：：fs；
fn main（）{
让f=fs：：读取字符串（“input.txt”）。预期（“无法打开文件”）；
设mut-total=0；
让mut frequencies=HashSet:：new（）；
频率。插入（0）；
环路{
对于f中的行。行（）{
让line_修剪=line.trim（）；
让something=line_trimmed.parse:：（）.unwrap（）；
总数+=某物；
//println！（“{：？}”，总计）；
如果频率。包含（&total）{
println！（“发现重复的{：？}”，总计）；
返回；
}
频率。插入（总数）；
}
}
println！（“发现重复的{：？}”，频率）；
}

println！（“发现重复{：？}”，频率）不可访问，因为当您调用
return
时，您正在退出
main
函数

将循环更改为while，并设置一个变量以退出while循环

let mut duplicated_found = false;
while !duplicated_found {
    for line in f.lines() {

        let line_trimmed = line.trim();
        let something = line_trimmed.parse::<i32>().unwrap();
        total += something;
        // println!("{:?}",total);

        if frequencies.contains(&total) {
            println!("duplicated found {:?}", total);
            duplicated_found = true;
            break; // This breaks out of the for loop
        }
        frequencies.insert(total);
    }
}
println!("duplicated found {:?}", frequencies);

让mut duplicated\u found=false；
虽然找到重复的{
对于f中的行。行（）{
让line_修剪=line.trim（）；
让something=line_trimmed.parse:：（）.unwrap（）；
总数+=某物；
//println！（“{：？}”，总计）；
如果频率。包含（&total）{
println！（“发现重复的{：？}”，总计）；
重复的_found=true；
break；//这将中断for循环
}
频率。插入（总数）；
}
}
普林顿！（“发现重复{：？}”，频率）；

或者，可以使用标签指定要打断的循环：

'outer: loop {
    for line in f.lines() {

        let line_trimmed = line.trim();
        let something = line_trimmed.parse::<i32>().unwrap();
        total += something;
        // println!("{:?}",total);

        if frequencies.contains(&total) {
            println!("duplicated found {:?}", total);
            break 'outer; // This breaks out of the outer loop
        }
        frequencies.insert(total);
    }
}
println!("duplicated found {:?}", frequencies);

“外部：循环”{
对于f中的行。行（）{
让line_修剪=line.trim（）；
让something=line_trimmed.parse:：（）.unwrap（）；
总数+=某物；
//println！（“{：？}”，总计）；
如果频率。包含（&total）{
println！（“发现重复的{：？}”，总计）；
break'outer；//这会中断外部循环
}
频率。插入（总数）；
}
}
普林顿！（“发现重复{：？}”，频率）；
命名标签似乎是打破外部循环的一种更为明显的方式。对于一个变量，它需要更多的脑力来知道为什么这个变量在这里，它做什么，什么时候被使用。