Instruction break et continue en langage C

Instructions break et continue

C fournit deux instructions de contrôle de flux permettant de modifier le comportement normal d'une boucle en cours d'exécution : break pour quitter la boucle et continue pour sauter l'itération courante.

1. Instruction break

while (condition) {
    if (critere_sortie) {
        break;       /* quitte la boucle immédiatement */
    }
    /* instructions normales */
}

Exemple n°1 — Sortir d'un for quand i == 5

#include <stdio.h>

int main(void)
{
    int i;

    for (i = 0; i < 10; i++) {
        if (i == 5) {
            break;           /* sortie dès que i vaut 5 */
        }
        printf("i = %d\n", i);
    }

    printf("bye\n");
    return 0;
}

i = 0
i = 1
i = 2
i = 3
i = 4
bye

À la 6ᵉ itération, i vaut 5. La condition i == 5 est vraie : break est exécuté, la boucle se termine et le programme affiche bye. Sans break, la boucle aurait parcouru les 10 valeurs (0 à 9).

Exemple n°2 — Application : recherche dans un tableau

#include <stdio.h>

int main(void)
{
    int tab[] = {14, 37, 8, 52, 99, 3, 76, 21};
    int n      = 8;
    int cible  = 99;
    int trouve = 0;

    for (int i = 0; i < n; i++) {
        if (tab[i] == cible) {
            printf("Trouvé : %d à l'indice %d\n", cible, i);
            trouve = 1;
            break;          /* inutile de continuer */
        }
    }

    if (!trouve)
        printf("%d non trouvé\n", cible);

    return 0;
}

Trouvé : 99 à l'indice 4

break dans les boucles imbriquées

Exemple n°3 — break dans une boucle imbriquée

#include <stdio.h>

int main(void)
{
    int i, j;

    for (i = 0; i < 3; i++) {
        printf("i = %d\n", i);
        for (j = 0; j < 4; j++) {
            if (j == 2) {
                break;       /* quitte uniquement la boucle interne (j) */
            }
            printf("  j = %d\n", j);
        }
    }

    printf("bye\n");
    return 0;
}

i = 0
  j = 0
  j = 1
i = 1
  j = 0
  j = 1
i = 2
  j = 0
  j = 1
bye

Pour chaque valeur de i, la boucle interne s'arrête à j == 2. La boucle externe, elle, continue jusqu'à i == 2 inclus. Le break n'a aucun effet sur la boucle externe.

2. Instruction continue

for (init; condition; mise_a_jour) {
    if (critere_saut) {
        continue;    /* saute au pas suivant : exécute mise_a_jour, puis teste condition */
    }
    /* instructions ignorées si continue est exécuté */
}

Exemple n°4 — Afficher 0..9 sauf 5 avec continue

#include <stdio.h>

int main(void)
{
    int i;

    for (i = 0; i < 10; i++) {
        if (i == 5) {
            continue;   /* saute printf pour i == 5 uniquement */
        }
        printf("i = %d\n", i);
    }

    printf("bye\n");
    return 0;
}

i = 0
i = 1
i = 2
i = 3
i = 4
i = 6
i = 7
i = 8
i = 9
bye

Quand i == 5, continue est exécuté : le printf est ignoré, mais i++ s'exécute normalement — la boucle reprend avec i == 6. Contrairement à break, la boucle continue jusqu'à son terme.

Exemple n°5 — Application : somme des entiers pairs de 1 à 20

#include <stdio.h>

int main(void)
{
    int i, somme = 0;

    for (i = 1; i <= 20; i++) {
        if (i % 2 != 0) {
            continue;    /* ignorer les impairs */
        }
        somme += i;
        printf("Ajout de %d  — somme partielle : %d\n", i, somme);
    }

    printf("Somme des pairs : %d\n", somme);
    return 0;
}

Ajout de 2  — somme partielle : 2
Ajout de 4  — somme partielle : 6
Ajout de 6  — somme partielle : 12
...
Ajout de 20 — somme partielle : 110
Somme des pairs : 110

Exemple n°6 — continue dans des boucles imbriquées

#include <stdio.h>

int main(void)
{
    int i, j;

    for (i = 0; i < 3; i++) {
        printf("i = %d\n", i);
        for (j = 0; j < 4; j++) {
            if (j == 2) {
                continue;   /* saute j==2, continue avec j==3 */
            }
            printf("  j = %d\n", j);
        }
    }

    printf("bye\n");
    return 0;
}

i = 0
  j = 0
  j = 1
  j = 3
i = 1
  j = 0
  j = 1
  j = 3
i = 2
  j = 0
  j = 1
  j = 3
bye

Pour chaque valeur de i, la valeur j == 2 est sautée, mais j == 3 est bien affiché — la boucle interne n'est pas quittée, seulement l'itération j == 2 est ignorée.

3. Comparaison break vs continue

/* Dangereux — boucle infinie si i == 5 */
int i = 0;
while (i < 10) {
    if (i == 5) continue;   /* i++ jamais exécuté ! */
    printf("%d\n", i);
    i++;
}

/* Correct — incrémenter AVANT continue */
while (i < 10) {
    i++;
    if (i == 5) continue;
    printf("%d\n", i);
}