rust 正在尝试嵌套for循环以生成IPv4地址

我需要一些帮助，我正在尝试迭代IP范围内的所有IP，但遇到了一些问题
我用loop试过了

'pos_1: loop {
        'pos_2: loop {
            'pos_3: loop {
                'pos_4: loop {
                    println!("{}.{}.{}.{}",new_ip[0], new_ip[1], new_ip[2], new_ip[3]);
                    if new_ip[3] == (first_ip[3]+ip_differences[3]) {break 'pos_4;}
                    new_ip[3] += 1;
                }
                if new_ip[2] == (first_ip[2]+ip_differences[2]) {break 'pos_3;}
                new_ip[2] += 1;
            }
            if new_ip[1] == (first_ip[1]+ip_differences[1]) {break 'pos_2;}
            new_ip[1] += 1;
        }
        if new_ip[0] == (first_ip[0]+ip_differences[0]) {break 'pos_1;}
        new_ip[0] += 1;
    }

也使用for循环

for i in -1..ip_differences[0] {
        for j in -1..ip_differences[1] {
            for k in -1..ip_differences[2] {
                for l in -1..ip_differences[3] {
                    println!("{}.{}.{}.{}", new_ip[0], new_ip[1], new_ip[2], new_ip[3]);
                    if new_ip[3] == (first_ip[3]+ip_differences[3]) {break;}
                    new_ip[3] += 1;

                }
                if new_ip[2] == (first_ip[2]+ip_differences[2]) {break;}

                new_ip[2] += 1;
            }
            if new_ip[1] == (first_ip[1]+ip_differences[1]) {break;}
            new_ip[1] += 1;
        }
        if new_ip[0] == (first_ip[0]+ip_differences[0]) {break;}
        new_ip[0] += 1;
    }

以上示例的输出：

93.124.176.{...}
93.124.176.248
93.124.176.249
93.124.176.250
93.124.176.251
93.124.176.252
93.124.176.253
93.124.176.254
93.124.176.255
93.124.177.255
93.124.178.255
93.124.179.255
93.124.180.255
93.124.181.255
93.124.182.255
93.124.183.255

还有while循环。我使用break关键字是因为我不希望值超过范围的上限。通常，我会假设break中断当前循环，转到上一个循环（重新启动内部循环），但感觉上，当我使用break时，它只是完全中断了循环，永远不会再使用。
（每次递增new_ip时不中断，您可以得到0.0.1234）
只是出于好奇，我试着用java来做，看看是我的想法不好，还是我对铁 rust 的理解......这是我对铁 rust 的理解。
因为这确实起作用：

for (int i = -1; i < ipDifferences[0]; i++) {
            for (int j = -1; j < ipDifferences[1]; j++) {
                for (int k = -1; k < ipDifferences[2]; k++) {
                    for (int l = -1; l < ipDifferences[3]; l++) {
                        System.out.println(String.format("%s.%s.%s.%s", nIP[0], nIP[1], nIP[2], nIP[3]));
                        if (nIP[3]==(firstIP[3]+ipDifferences[3])) {
                            break;
                        }
                        nIP[3]++;
                    }
                    nIP[3]=firstIP[3];
                    if (nIP[2]==firstIP[2]+ipDifferences[2]) {
                        break;
                    }
                    nIP[2]++;
                }
                nIP[2]=firstIP[2];
                if (nIP[1]==firstIP[1]+ipDifferences[1]) {
                    break;
                }
                nIP[1]++;
            }
            if (nIP[0]==firstIP[0]+ipDifferences[0]) {
                break;
            }
            nIP[0]++;
        }

java适配的输出：

93.124.175.{...}
...
93.124.176.252
93.124.176.253
93.124.176.254
93.124.176.255
93.124.177.15
93.124.177.16
93.124.177.17
...
93.124.177.255

https://play.rust-lang.org/?version=stable&mode=debug&edition=2021&gist=bffefca98ffa049422ed35deecd031d7

这应有助于：

for _ in 0..3 {
    for _ in 0..3 {
        println!("a");
    }
    println!("b");
}

其输出将为：

a,a,a,b,a,a,a,b,a,a,a,b

你需要对嵌套的for循环做一些实验来理解它们，但是基本上最里面的循环会运行指定的次数，然后下一个最外面的循环会运行，然后下一个最外面的循环，然后它会回到最里面的循环，并运行指定的次数，等等。
如果我们以嵌套的for循环为例，用5替换最里面的一个：

for _ in 0..3 {
    for _ in 0..5 {
        println!("a");
    }
    println!("b");
}

我们得到：

a,a,a,a,a,b,a,a,a,a,a,b,a,a,a,a,a,b

如果我们将最外层的for循环改为5：

for _ in 0..5 {
    for _ in 0..3 {
        println!("a");
    }
    println!("b");
}

我们得到这个：

a,a,a,b,a,a,a,b,a,a,a,b,a,a,a,b,a,a,a,b

这应该有助于您更好地理解嵌套的for循环，因为在我到处扔了一些数字之后，我确实觉得我知道我在做什么（直到我再次假装不会发生这种情况）。
当嵌套更多的for循环时，复杂性会迅速增加，因此要不惜一切代价避免这种情况，甚至将每个for循环分解为一个函数也会有所帮助。

rust 正在尝试嵌套for循环以生成IPv4地址

2条答案

相关问题

热门标签

最新问答