Rustで特定のループに戻る!ラベル付きcontinueの使い方を徹底解説

Rustのプログラミングにおいて、ループ処理はコードの効率化と柔軟性を提供する重要な機能です。その中でも、特定のループに戻るために使用する「ラベル付きcontinue」は、入れ子構造が複雑な場合や特定の条件でループをスキップしたい場合に役立ちます。しかし、その構文や使い方を正しく理解していないと、意図しない動作やエラーにつながる可能性があります。本記事では、Rustのループ構文の基本からラベル付きcontinueの詳細な使い方、さらには実践的な応用例までを詳しく解説します。これを学ぶことで、Rustのコードをより効率的かつ可読性高く記述するスキルを習得できます。

目次

Rustの基本的なループ構文


Rustには、効率的で柔軟なループ制御を可能にするいくつかのループ構文があります。それぞれの構文の特性を理解することで、目的に合ったループを選択できます。

1. `loop`


loopは無限ループを作成するための構文です。明示的にbreakを使用しない限り、ループは終了しません。

fn main() {
    let mut counter = 0;
    loop {
        counter += 1;
        if counter == 5 {
            break;
        }
        println!("Counter: {}", counter);
    }
}

2. `while`


whileは条件を満たす間ループを繰り返します。特定の条件を基準にループを制御する場合に便利です。

fn main() {
    let mut number = 3;
    while number != 0 {
        println!("Number: {}", number);
        number -= 1;
    }
}

3. `for`


forは特定の範囲やイテレータを基にループを実行します。特定の回数や要素に対して繰り返し操作を行いたい場合に最適です。

fn main() {
    for i in 1..5 {
        println!("Number: {}", i);
    }
}

選択のポイント

  • 無限ループが必要な場合はloopを使用
  • 条件を基にループする場合はwhileを使用
  • イテレータや範囲を利用する場合はforを使用

Rustのループ構文を使いこなすことで、さまざまなシナリオに適したコードを簡潔に記述できます。次に、continueの基本的な使い方を解説します。

`continue`の基本的な使い方


continueは、ループ内で現在の反復をスキップし、次の反復に進むためのキーワードです。条件によって処理を中断せずにスキップすることで、効率的なループ処理が可能になります。

1. 基本的な`continue`の使用例


以下の例では、偶数の場合に処理をスキップしています。

fn main() {
    for i in 1..10 {
        if i % 2 == 0 {
            continue;
        }
        println!("Odd number: {}", i);
    }
}

出力:

Odd number: 1  
Odd number: 3  
Odd number: 5  
Odd number: 7  
Odd number: 9  

ここでは、i % 2 == 0(偶数)の場合にcontinueが実行され、println!のコードがスキップされます。

2. `while`と組み合わせた例


continuewhileループでも同様に使用できます。

fn main() {
    let mut number = 0;
    while number < 10 {
        number += 1;
        if number % 3 == 0 {
            continue;
        }
        println!("Number: {}", number);
    }
}

出力:

Number: 1  
Number: 2  
Number: 4  
Number: 5  
Number: 7  
Number: 8  
Number: 10  

この例では、numberが3の倍数のときにcontinueが実行され、それ以外の値が出力されます。

3. `loop`での使用


continueは無限ループの中でも使用可能です。以下の例では特定の条件を満たした場合にのみ処理をスキップします。

fn main() {
    let mut count = 0;
    loop {
        count += 1;
        if count % 2 == 0 {
            continue;
        }
        println!("Count: {}", count);
        if count > 5 {
            break;
        }
    }
}

出力:

Count: 1  
Count: 3  
Count: 5  

`continue`の注意点

  • 無限ループの場合、continueを適切に制御しないと無限実行状態になる可能性があります。
  • 条件の設定やデバッグで処理フローを追跡することが重要です。

次に、より複雑なラベル付きcontinueについて解説します。これにより、入れ子ループでの制御がさらに簡単になります。

ラベル付き`continue`の概要


Rustでは、複雑な入れ子構造のループで特定のループに戻りたい場合に「ラベル付きcontinue」を使用します。通常のcontinueは現在のループをスキップしますが、ラベルを指定することで、スキップする対象のループを明示的に指定できます。

1. ラベル付き`continue`の仕組み


Rustのラベルは、ループの先頭に'ラベル名:の形式で定義されます。continue 'ラベル名;を使用することで、そのラベルが付いたループに戻ることが可能です。

基本構文

'label_name: loop {
    // 内部でラベル付き`continue`を呼び出す
    continue 'label_name;
}

2. ラベル付き`continue`が必要な場面

  • 入れ子ループの外側に戻る必要がある場合
  • 特定の条件で一部のループ処理をスキップし、外側のループに制御を戻したい場合
  • コードの可読性を高めたい場合

3. ラベル付き`continue`の簡単な例


以下はラベル付きcontinueを用いた基本的な例です。

fn main() {
    'outer: for i in 1..=3 {
        for j in 1..=3 {
            if j == 2 {
                continue 'outer; // 外側のループに戻る
            }
            println!("i = {}, j = {}", i, j);
        }
    }
}

出力:

i = 1, j = 1  
i = 2, j = 1  
i = 3, j = 1  

この例では、j == 2の条件が成立した際に、内側のループではなく外側のループに戻ります。

ラベル付き`continue`の利点

  • 入れ子ループの中でも正確に制御できる。
  • 意図したループに戻る動作を保証できるため、バグを防ぎやすい。
  • 長い条件分岐やネストの回避によってコードが簡潔になる。

次に、具体的なコード例を用いてラベル付きcontinueの詳細な使い方を説明します。

ラベル付き`continue`の使い方をコードで解説


ラベル付きcontinueは、入れ子ループで外側のループに戻る場合などに非常に便利です。ここでは、具体的なコード例を通して、ラベル付きcontinueの使い方を詳しく解説します。

1. 基本例: 入れ子ループで特定のループに戻る


以下は、入れ子ループの中で外側のループに戻る例です。

fn main() {
    'outer: for i in 1..=3 {
        for j in 1..=3 {
            if j == 2 {
                println!("Skipping to next iteration of outer loop");
                continue 'outer; // 外側のループに戻る
            }
            println!("i = {}, j = {}", i, j);
        }
    }
}

出力:

i = 1, j = 1  
Skipping to next iteration of outer loop  
i = 2, j = 1  
Skipping to next iteration of outer loop  
i = 3, j = 1  
Skipping to next iteration of outer loop  

この例では、j == 2の条件が成立した際に、内側のループの残りの反復をスキップして、外側のループの次の反復に進んでいます。

2. 実用例: 条件付き処理をスキップ


以下の例では、特定の条件でスキップすることで、効率的なデータ処理を実現します。

fn main() {
    let data = vec![
        vec![1, 2, 3],
        vec![4, 5, 6],
        vec![7, 8, 9],
    ];

    'outer: for row in &data {
        for &value in row {
            if value % 5 == 0 {
                println!("Skipping to next row due to value: {}", value);
                continue 'outer;
            }
            println!("Processing value: {}", value);
        }
    }
}

出力:

Processing value: 1  
Processing value: 2  
Processing value: 3  
Skipping to next row due to value: 5  
Processing value: 7  
Processing value: 8  
Processing value: 9  

この例では、値が5の倍数の場合に内側のループを終了し、外側のループに戻ります。

3. 無限ループでの使用例


ラベル付きcontinueは、loop内で使用することもできます。

fn main() {
    let mut count = 0;

    'main_loop: loop {
        count += 1;
        if count == 5 {
            println!("Skipping to the next iteration of main loop");
            continue 'main_loop; // 再び無限ループの先頭に戻る
        }
        if count == 10 {
            println!("Breaking out of the loop");
            break;
        }
        println!("Count: {}", count);
    }
}

出力:

Count: 1  
Count: 2  
Count: 3  
Count: 4  
Skipping to the next iteration of main loop  
Count: 6  
Count: 7  
Count: 8  
Count: 9  
Breaking out of the loop  

この例では、count == 5のときに無限ループをスキップして、次の反復に進みます。

4. ラベル付き`continue`の活用ポイント

  • 入れ子ループが深い場合に効果的。
  • 条件付きで外側のループに戻る処理を簡潔に記述できる。
  • 処理フローを明示することで、可読性が向上する。

次に、入れ子ループの中でのラベル付きcontinueのさらなる活用例を詳しく解説します。

入れ子ループでの活用例


入れ子ループで複数のレベルにわたる処理を制御する際、ラベル付きcontinueは非常に有用です。ここでは、特定の条件下で効率的なループ処理を実現する活用例を解説します。

1. 条件を満たす外側ループに戻る例


以下のコードは、複数の入れ子ループの中で特定の条件を満たした際に外側のループに戻るケースです。

fn main() {
    'outer: for i in 1..=3 {
        for j in 1..=3 {
            for k in 1..=3 {
                if k == 2 {
                    println!("Skipping to next iteration of outer loop (i = {})", i);
                    continue 'outer; // 最外のループに戻る
                }
                println!("i = {}, j = {}, k = {}", i, j, k);
            }
        }
    }
}

出力:

i = 1, j = 1, k = 1  
Skipping to next iteration of outer loop (i = 1)  
i = 2, j = 1, k = 1  
Skipping to next iteration of outer loop (i = 2)  
i = 3, j = 1, k = 1  
Skipping to next iteration of outer loop (i = 3)  

この例では、k == 2の条件を満たすと、最内のループを終了し、外側の'outerループに戻ります。

2. 多次元データ処理での使用


ラベル付きcontinueは、多次元データの処理においても役立ちます。次の例では、データ中の特定の条件で処理をスキップしています。

fn main() {
    let matrix = vec![
        vec![1, 2, 3],
        vec![4, 5, 6],
        vec![7, 8, 9],
    ];

    'outer: for row in &matrix {
        for &value in row {
            if value % 3 == 0 {
                println!("Skipping to next row due to value: {}", value);
                continue 'outer; // 行ごとに処理をスキップ
            }
            println!("Processing value: {}", value);
        }
    }
}

出力:

Processing value: 1  
Processing value: 2  
Skipping to next row due to value: 3  
Processing value: 4  
Processing value: 5  
Skipping to next row due to value: 6  
Processing value: 7  
Processing value: 8  
Skipping to next row due to value: 9  

この例では、値が3の倍数である場合、その行の残りの値をスキップして次の行に進みます。

3. 複雑な条件分岐の整理


次の例は、複雑な条件分岐を整理するためにラベル付きcontinueを使用したものです。

fn main() {
    'outer: for i in 1..=5 {
        for j in 1..=5 {
            if i + j > 6 {
                println!("Skipping to next iteration of outer loop (i = {})", i);
                continue 'outer;
            }
            println!("i = {}, j = {}", i, j);
        }
    }
}

出力:

i = 1, j = 1  
i = 1, j = 2  
i = 1, j = 3  
i = 1, j = 4  
i = 1, j = 5  
i = 2, j = 1  
i = 2, j = 2  
Skipping to next iteration of outer loop (i = 2)  
i = 3, j = 1  
Skipping to next iteration of outer loop (i = 3)  
i = 4, j = 1  
Skipping to next iteration of outer loop (i = 4)  
i = 5, j = 1  
Skipping to next iteration of outer loop (i = 5)  

この例では、i + j > 6という条件が満たされると外側のループに制御が戻ります。

4. 活用のポイント

  • 効率的な制御: 条件を満たしたときに不要な計算をスキップできる。
  • 可読性の向上: 条件分岐を明確にし、コードを簡潔にする。
  • デバッグの容易さ: 処理フローが分かりやすいため、エラーの特定が容易になる。

次に、ラベル付きcontinueと似た動作をするラベル付きbreakとの比較を解説します。

ラベル付き`continue`と`break`の比較


Rustでは、ループ制御にcontinuebreakを使用します。特にラベル付きの形式は入れ子ループでの制御に役立ちますが、それぞれの挙動には明確な違いがあります。ここでは、ラベル付きcontinueとラベル付きbreakを比較し、適切な使い分けを解説します。

1. ラベル付き`continue`の動作


ラベル付きcontinueは、指定されたループの次の反復に進みます。現在のループの実行を中断し、次回の実行に制御を移します。

例:

fn main() {
    'outer: for i in 1..=3 {
        for j in 1..=3 {
            if j == 2 {
                println!("Continuing to next iteration of outer loop (i = {})", i);
                continue 'outer;
            }
            println!("i = {}, j = {}", i, j);
        }
    }
}

出力:

i = 1, j = 1  
Continuing to next iteration of outer loop (i = 1)  
i = 2, j = 1  
Continuing to next iteration of outer loop (i = 2)  
i = 3, j = 1  
Continuing to next iteration of outer loop (i = 3)  

動作のポイント:

  • 指定されたループに戻り、その次の反復を実行する。
  • 現在のループ処理をスキップするだけで、ループ全体を終了しない。

2. ラベル付き`break`の動作


ラベル付きbreakは、指定されたループを完全に終了させます。外側のループまで制御を移す際に使われます。

例:

fn main() {
    'outer: for i in 1..=3 {
        for j in 1..=3 {
            if j == 2 {
                println!("Breaking out of outer loop (i = {})", i);
                break 'outer;
            }
            println!("i = {}, j = {}", i, j);
        }
    }
}

出力:

i = 1, j = 1  
Breaking out of outer loop (i = 1)  

動作のポイント:

  • 指定されたループを終了し、その外側に制御を戻す。
  • ループ全体を中断して次の処理に進む。

3. `continue`と`break`の比較表

特性ラベル付きcontinueラベル付きbreak
動作指定されたループの次の反復に進む指定されたループを完全に終了する
使用シナリオ特定の条件で次の反復をスキップしたい場合特定の条件でループ全体を終了したい場合
入れ子ループの制御特定の外側ループに戻る特定の外側ループを終了する
効果処理の一部をスキップする処理全体を中断する

4. 適切な使い分け

  • ラベル付きcontinueを使う場面:
  • 特定の条件で外側ループの次の反復に進みたい場合。
  • 入れ子ループの一部をスキップしつつ、ループ全体を維持したい場合。
  • ラベル付きbreakを使う場面:
  • 特定の条件でループ全体を終了し、次の処理に進みたい場合。
  • 条件に応じて早期にループを抜ける必要がある場合。

5. 実践的な使い分け例


以下のコードでは、continuebreakを使い分けた例を示します。

fn main() {
    'outer: for i in 1..=3 {
        for j in 1..=3 {
            if i == 2 && j == 2 {
                println!("Breaking out of outer loop");
                break 'outer;
            } else if j == 2 {
                println!("Skipping to next iteration of outer loop (i = {})", i);
                continue 'outer;
            }
            println!("i = {}, j = {}", i, j);
        }
    }
}

出力:

i = 1, j = 1  
Skipping to next iteration of outer loop (i = 1)  
i = 2, j = 1  
Breaking out of outer loop  

この例では、i == 2 && j == 2でループ全体を終了し、それ以外の条件では次の外側ループに進む動作を実現しています。

次に、ラベル付きcontinueを使用する際のエラー回避とデバッグのポイントについて解説します。

エラーの回避とデバッグのポイント


ラベル付きcontinueは便利ですが、誤った使い方をすると予期せぬ動作やエラーが発生する可能性があります。ここでは、ラベル付きcontinueを使用する際に注意すべきポイントとデバッグ方法を解説します。

1. ラベル名の一貫性を保つ


Rustでは、ラベル名が一意である必要があります。同じスコープ内で同一のラベル名を使用するとコンパイルエラーが発生します。

誤った例:

fn main() {
    'outer: loop {
        'outer: for i in 1..=5 { // エラー: 同じ名前のラベルを使用
            continue 'outer;
        }
    }
}

エラー内容:

error[E0428]: the label `'outer` is defined multiple times

正しい修正:

fn main() {
    'outer_loop: loop {
        'inner_loop: for i in 1..=5 {
            continue 'outer_loop; // 名前を変えて解消
        }
    }
}

2. 入れ子構造の深さを考慮


入れ子ループが深くなるほど、ラベル付きcontinueの挙動を追跡するのが難しくなります。ラベルの範囲を明確にし、意図通りに制御が行われているか確認しましょう。

デバッグ方法:

  • ラベルの近くにコメントを記述して目的を明示する。
  • ログ出力でラベル付きcontinueが実行される箇所を追跡する。

例:

fn main() {
    'outer: for i in 1..=3 {
        println!("Outer loop start: i = {}", i);
        for j in 1..=3 {
            if j == 2 {
                println!("Skipping to next iteration of outer loop (i = {})", i);
                continue 'outer;
            }
            println!("Inner loop: i = {}, j = {}", i, j);
        }
    }
}

出力を確認することで動作を追跡:

Outer loop start: i = 1  
Inner loop: i = 1, j = 1  
Skipping to next iteration of outer loop (i = 1)  
Outer loop start: i = 2  
Inner loop: i = 2, j = 1  
Skipping to next iteration of outer loop (i = 2)  
Outer loop start: i = 3  
Inner loop: i = 3, j = 1  
Skipping to next iteration of outer loop (i = 3)  

3. 不要なスキップの防止


条件が複雑になると、誤って意図しないラベル付きcontinueが実行される可能性があります。条件式を簡潔にし、コメントを追加して動作を明確化しましょう。

誤った例:

fn main() {
    'outer: for i in 1..=5 {
        for j in 1..=5 {
            if i + j > 6 {
                continue 'outer; // 条件が曖昧で誤解を招く
            }
            println!("i = {}, j = {}", i, j);
        }
    }
}

改善例:

fn main() {
    'outer: for i in 1..=5 {
        for j in 1..=5 {
            if i + j > 6 { // 明確な条件コメントを追加
                println!("Skipping rest of inner loop for i = {}, j = {}", i, j);
                continue 'outer;
            }
            println!("Processing i = {}, j = {}", i, j);
        }
    }
}

4. 無限ループの無限実行を防ぐ


無限ループでラベル付きcontinueを使用する際は、終了条件を必ず設けましょう。

誤った例:

fn main() {
    'outer: loop {
        continue 'outer; // 無条件で無限ループに戻る
    }
}

修正例:

fn main() {
    let mut count = 0;
    'outer: loop {
        count += 1;
        if count > 10 {
            break 'outer; // 終了条件を追加
        }
        println!("Count: {}", count);
        continue 'outer;
    }
}

5. デバッグツールの活用


Rustでは、以下のツールや手法を活用してデバッグを効率化できます。

  • dbg!マクロ: 現在の状態を出力する。
  • ログ出力: 条件付きでprintln!を追加する。
  • IDEのデバッガ: ラベルの挙動をステップ実行で確認する。

まとめ


ラベル付きcontinueを安全かつ効果的に使用するには、ラベルの範囲や条件式を明確にし、デバッグ方法を工夫することが重要です。次に、ラベル付きcontinueの応用例を紹介し、さらに実践的なシナリオでの使い方を解説します。

ラベル付き`continue`の応用例


ラベル付きcontinueは、単なるスキップではなく、複雑な条件付き処理や多次元データの処理など、幅広い応用が可能です。ここでは、実践的なシナリオでの使用例を紹介します。

1. エラーデータをスキップして次の処理へ進む


ラベル付きcontinueは、大量のデータ処理で特定のエラーデータをスキップする際に便利です。

例:

fn main() {
    let data = vec![
        vec![1, 2, -1],  // -1はエラー値
        vec![4, 5, 6],
        vec![7, -1, 9],
    ];

    'outer: for row in &data {
        for &value in row {
            if value == -1 {
                println!("Error detected. Skipping to next row.");
                continue 'outer; // エラーがあれば次の行に進む
            }
            println!("Processing value: {}", value);
        }
    }
}

出力:

Processing value: 1  
Processing value: 2  
Error detected. Skipping to next row.  
Processing value: 4  
Processing value: 5  
Processing value: 6  
Processing value: 7  
Error detected. Skipping to next row.  

応用ポイント:

  • 不正データをスキップして正常なデータのみを処理する。
  • 大量のデータセットでも効率的な処理を実現。

2. 複数条件での動的なループ制御


以下は、条件に応じて複数のループを制御する例です。

例:

fn main() {
    let thresholds = vec![10, 20, 30];
    'outer: for (i, &threshold) in thresholds.iter().enumerate() {
        for j in 1..50 {
            if j == threshold {
                println!("Reached threshold {} at outer loop {}, skipping to next threshold.", threshold, i);
                continue 'outer; // 次の閾値に進む
            }
            if j % 5 == 0 {
                println!("Processing divisible by 5: {}", j);
            }
        }
    }
}

出力:

Processing divisible by 5: 5  
Processing divisible by 5: 10  
Reached threshold 10 at outer loop 0, skipping to next threshold.  
Processing divisible by 5: 15  
Processing divisible by 5: 20  
Reached threshold 20 at outer loop 1, skipping to next threshold.  
Processing divisible by 5: 25  
Processing divisible by 5: 30  
Reached threshold 30 at outer loop 2, skipping to next threshold.  

応用ポイント:

  • 動的な閾値に基づいてループを制御可能。
  • 条件に応じた柔軟な動作が実現できる。

3. 二次元配列の早期終了とスキップ


ラベル付きcontinueを使えば、特定の条件で早期終了とスキップを組み合わせた操作が可能です。

例:

fn main() {
    let matrix = vec![
        vec![1, 2, 3],
        vec![4, 5, 6],
        vec![7, 8, 9],
    ];

    'outer: for (row_idx, row) in matrix.iter().enumerate() {
        for (col_idx, &value) in row.iter().enumerate() {
            if row_idx == 1 && col_idx == 1 {
                println!("Skipping processing for row {}, column {}.", row_idx, col_idx);
                continue 'outer; // 早期に次の行へ
            }
            println!("Processing value at row {}, column {}: {}", row_idx, col_idx, value);
        }
    }
}

出力:

Processing value at row 0, column 0: 1  
Processing value at row 0, column 1: 2  
Processing value at row 0, column 2: 3  
Skipping processing for row 1, column 1.  
Processing value at row 2, column 0: 7  
Processing value at row 2, column 1: 8  
Processing value at row 2, column 2: 9  

応用ポイント:

  • 特定の行や列をスキップしつつ他のデータを処理する。
  • 二次元配列や表形式データの効率的な操作。

4. リソース解放と次のタスクへの移行


複数のリソースを扱う場合に、ラベル付きcontinueを使用してリソースの解放と次のタスクへの移行を効率化できます。

例:

fn main() {
    let tasks = vec!["Task1", "Task2", "ErrorTask", "Task3"];

    'outer: for task in tasks {
        if task == "ErrorTask" {
            println!("Error in task. Moving to next task.");
            continue 'outer;
        }
        println!("Processing: {}", task);
    }
}

出力:

Processing: Task1  
Processing: Task2  
Error in task. Moving to next task.  
Processing: Task3  

応用ポイント:

  • エラー処理の分離と次のタスクへのスムーズな移行。
  • 複雑なタスク管理システムの簡素化。

まとめ


ラベル付きcontinueは、データ処理、タスク管理、条件付き操作など、さまざまなシナリオで強力なツールとなります。この機能を応用することで、効率的かつ直感的なコード設計が可能になります。次に、実際に試せる演習問題を提供し、理解を深めます。

演習問題で理解を深める


ラベル付きcontinueを実践的に使いこなすために、以下の演習問題に挑戦してみましょう。これらの問題を通して、ラベル付きcontinueの動作や応用方法を体感できます。

問題 1: 入れ子ループでのスキップ


次のコードを完成させてください。条件に基づいて特定の行をスキップし、外側のループに戻るようにします。

fn main() {
    let matrix = vec![
        vec![1, 2, 3],
        vec![4, 5, 6],
        vec![7, 8, 9],
    ];

    'outer: for row in &matrix {
        for &value in row {
            // 値が6の場合に外側のループの次の反復に進む
            if value == 6 {
                println!("Skipping to next row due to value: {}", value);
                // ここにコードを追加
            }
            println!("Processing value: {}", value);
        }
    }
}

期待する出力:

Processing value: 1  
Processing value: 2  
Processing value: 3  
Processing value: 4  
Processing value: 5  
Skipping to next row due to value: 6  
Processing value: 7  
Processing value: 8  
Processing value: 9  

問題 2: 条件付きタスク管理


以下のリスト内のタスクを処理し、「Error」が含まれるタスクをスキップしながら実行結果を出力するコードを書いてください。

fn main() {
    let tasks = vec!["Task1", "Task2", "ErrorTask", "Task3", "Task4"];

    'task_loop: for task in &tasks {
        // "ErrorTask"の場合にスキップする
        if task.contains("Error") {
            println!("Error in task: {}. Skipping.", task);
            // ここにコードを追加
        }
        println!("Processing: {}", task);
    }
}

期待する出力:

Processing: Task1  
Processing: Task2  
Error in task: ErrorTask. Skipping.  
Processing: Task3  
Processing: Task4  

問題 3: ラベル付き`continue`を使った数値フィルタリング


次のコードを完成させてください。数値のリストを処理し、偶数をスキップして次の外側のループに進むようにします。

fn main() {
    let numbers = vec![10, 15, 20, 25, 30];

    'outer: for &number in &numbers {
        // 偶数の場合にスキップ
        if number % 2 == 0 {
            println!("Skipping even number: {}", number);
            // ここにコードを追加
        }
        println!("Processing number: {}", number);
    }
}

期待する出力:

Skipping even number: 10  
Processing number: 15  
Skipping even number: 20  
Processing number: 25  
Skipping even number: 30  

ヒント

  • 条件に応じてcontinue 'ラベル名;を使うことで、外側のループに戻れます。
  • 各演習のラベル名を適切に設定し、条件式を正確に記述してください。

解答例と次のステップ


演習問題を解いて、ラベル付きcontinueの使い方を理解した後、結果を比較して正しい動作を確認してください。これにより、ラベル付きcontinueの動作や応用力がさらに高まります。

最後に、これまでの内容を簡潔に振り返るまとめに進みます。

まとめ


本記事では、Rustにおけるラベル付きcontinueについて、その基本的な使い方から応用例まで詳しく解説しました。以下に記事の要点を振り返ります。

  1. ラベル付きcontinueの概要: 入れ子ループの中で特定のループに戻る便利な機能。
  2. 基本的な使い方: ラベルを使用して明示的に外側のループに戻る動作を実現。
  3. 応用例: データ処理、エラー処理、多次元データ操作など、多様なシナリオで有用。
  4. エラー回避とデバッグ: ラベルの一意性、条件設定の明確化、ログ出力を活用。
  5. 演習問題: 理論を実践に応用することで、さらなる理解を深める。

ラベル付きcontinueを使いこなすことで、複雑なループ構造のコードを簡潔にし、処理の効率化を図ることができます。Rustの強力なループ制御機能を活用し、より洗練されたプログラムを設計してみてください。

コメント

コメントする

目次