break et continue en C : fonctionnement et cas d'usage

Deux façons de modifier le flux d'une boucle

La condition d'une boucle décide quand elle se termine, mais parfois la vraie réponse surgit au milieu du corps. Vous cherchez dans un tableau et vous trouvez l'élément au troisième rang - pourquoi vérifier les 997 autres ? Ou vous traitez une liste et une entrée est vide - sautez-la et continuez.

Le C a un mot-clé pour chaque cas :

• break - quitter la boucle maintenant. L'exécution reprend à la première instruction qui la suit.
• continue - abandonner seulement ce passage. Passer au suivant.

#include <stdio.h>

int main(void) {
    printf("break a 5 :    ");
    for (int i = 1; i <= 10; i++) {
        if (i == 5) {
            break;
        }
        printf("%d ", i);
    }
    printf("\n");

    printf("continue a 5 : ");
    for (int i = 1; i <= 10; i++) {
        if (i == 5) {
            continue;
        }
        printf("%d ", i);
    }
    printf("\n");

    return 0;
}

La première boucle affiche 1 2 3 4 et s'arrête. La seconde affiche 1 2 3 4 6 7 8 9 10 - elle a sauté une valeur et a poursuivi.

break dans une boucle

L'usage canonique est une recherche qui s'arrête dès qu'elle réussit :

#include <stdio.h>

int main(void) {
    int data[] = {14, 3, 88, 27, 5, 62};
    int n = sizeof(data) / sizeof(data[0]);
    int target = 27;
    int found = -1;

    for (int i = 0; i < n; i++) {
        if (data[i] == target) {
            found = i;
            break;              /* aucune raison de regarder le reste */
        }
    }

    if (found >= 0) {
        printf("%d trouve a l'indice %d\n", target, found);
    } else {
        printf("%d n'est pas dans le tableau\n", target);
    }

    return 0;
}

Parce que found est affecté avant le break, le code après la boucle peut distinguer « trouvé » de « plus d'éléments ». Cet appariement - une variable de résultat plus un break - est l'idiome standard de recherche en C. Le compteur de boucle lui-même n'est pas utilisable ensuite quand il est déclaré dans l'en-tête, puisqu'il sort de portée à l'accolade fermante.

break quitte toujours une boucle : le for, while, do-while ou switch englobant le plus proche.

continue dans une boucle

continue sert aux entrées qu'il faut sauter plutôt que d'arrêter le travail :

#include <stdio.h>

int main(void) {
    int values[] = {12, -3, 0, 45, -7, 8};
    int n = sizeof(values) / sizeof(values[0]);
    int sum = 0, counted = 0;

    for (int i = 0; i < n; i++) {
        if (values[i] <= 0) {
            continue;           /* ignorer zero et les negatifs */
        }
        sum += values[i];
        counted++;
    }

    printf("Somme de %d valeurs positives : %d\n", counted, sum);
    return 0;
}

L'endroit où continue saute dépend de la boucle :

for        -> la partie mise a jour de l'en-tete (le compteur avance donc quand meme)
while      -> le test de condition (rien d'autre du corps ne s'execute)
do-while   -> le test de condition, en bas

Cette différence n'est pas académique. Dans une boucle for, continue ne peut jamais sauter l'incrémentation du compteur, parce que celle-ci est dans l'en-tête. Dans une boucle while, si :

/* BUG: continue saute i++, donc cela bloque au premier nombre pair */
int i = 0;
while (i < 10) {
    if (i % 2 == 0) {
        continue;
    }
    printf("%d ", i);
    i++;
}

Soit vous déplacez i++ au-dessus du continue, soit vous l'écrivez en boucle for, où l'en-tête rend l'erreur impossible.

Un break dans un switch n'est pas un break de la boucle

break termine la boucle ou le switch englobant le plus proche - le plus proche des deux. Placez un switch dans une boucle et chaque break qu'il contient appartient au switch :

#include <stdio.h>

int main(void) {
    char commands[] = "aabqcc";

    for (int i = 0; commands[i] != '\0'; i++) {
        switch (commands[i]) {
            case 'a':
                printf("ajouter\n");
                break;          /* termine le switch ; la boucle continue */
            case 'b':
                printf("retour\n");
                break;
            case 'q':
                printf("sortie demandee\n");
                break;          /* egalement le switch seulement ! */
            default:
                printf("inconnu : %c\n", commands[i]);
                break;
        }
    }

    printf("boucle terminee\n");
    return 0;
}

La commande q affiche son message et la boucle continue de tourner sur cc. Si sortir était censé terminer la boucle, ce break ne l'a pas fait. Les solutions sont un drapeau, un goto, ou le déplacement de la boucle dans une fonction avec return - toutes montrées ci-dessous.

S'échapper de boucles imbriquées

Un simple break quitte un niveau. Dans deux boucles imbriquées, il ne termine que la boucle interne, et la boucle externe entame son passage suivant comme si de rien n'était.

#include <stdio.h>

int main(void) {
    int grid[3][4] = {
        {1, 2, 3, 4},
        {5, 6, 7, 8},
        {9, 10, 11, 12}
    };

    /* break ne quitte que la boucle interne - l'externe continue */
    for (int r = 0; r < 3; r++) {
        for (int c = 0; c < 4; c++) {
            if (grid[r][c] == 7) {
                printf("break interne a la ligne %d\n", r);
                break;
            }
        }
    }
    printf("(la boucle externe a parcouru les 3 lignes)\n");
    return 0;
}

Le C n'a ni break 2 ni break étiqueté. Trois options honnêtes :

Un drapeau. Portable, évident et un peu bruyant :

#include <stdio.h>

int main(void) {
    int grid[3][4] = {{1,2,3,4}, {5,6,7,8}, {9,10,11,12}};
    int found = 0;

    for (int r = 0; r < 3 && !found; r++) {
        for (int c = 0; c < 4; c++) {
            if (grid[r][c] == 7) {
                printf("7 trouve a la ligne %d, colonne %d\n", r, c);
                found = 1;
                break;
            }
        }
    }

    return 0;
}

Le drapeau apparaît à deux endroits - la condition externe et l'affectation - ce qui en est le coût. Avec trois niveaux d'imbrication, cela devient franchement désagréable.

goto. Le saut tant décrié du C, et c'est le seul cas où les programmeurs C expérimentés l'utilisent sans s'excuser :

#include <stdio.h>

int main(void) {
    int grid[3][4] = {{1,2,3,4}, {5,6,7,8}, {9,10,11,12}};

    for (int r = 0; r < 3; r++) {
        for (int c = 0; c < 4; c++) {
            if (grid[r][c] == 7) {
                printf("7 trouve a la ligne %d, colonne %d\n", r, c);
                goto done;
            }
        }
    }
    printf("non trouve\n");

done:
    printf("recherche terminee\n");
    return 0;
}

Un goto vers l'avant, vers une étiquette juste après les boucles, fait exactement ce qu'un break étiqueté ferait dans d'autres langages, en une ligne et sans drapeau à maintenir. La réputation de goto est méritée par les sauts en arrière et les sauts au milieu d'autres blocs, qui produisent réellement un flux de contrôle illisible. Un unique saut vers l'avant hors de boucles imbriquées, ce n'est pas cela. Le noyau Linux utilise le même motif pour ses chemins de nettoyage. Utilisez-le délibérément et avec parcimonie ; ne laissez pas le tabou vous pousser vers une alternative à trois drapeaux plus difficile à lire.

Une fonction et return. Généralement la meilleure réponse, car une recherche mérite un nom :

#include <stdio.h>

/* renvoie 1 et ecrit la position si trouve, 0 sinon */
int findValue(int grid[3][4], int target, int *outRow, int *outCol) {
    for (int r = 0; r < 3; r++) {
        for (int c = 0; c < 4; c++) {
            if (grid[r][c] == target) {
                *outRow = r;
                *outCol = c;
                return 1;       /* quitte les DEUX boucles d'un coup */
            }
        }
    }
    return 0;
}

int main(void) {
    int grid[3][4] = {{1,2,3,4}, {5,6,7,8}, {9,10,11,12}};
    int row, col;

    if (findValue(grid, 7, &row, &col)) {
        printf("7 trouve a la ligne %d, colonne %d\n", row, col);
    } else {
        printf("7 n'est pas dans la grille\n");
    }

    return 0;
}

return déroule toutes les boucles de la fonction, ne demande ni drapeau ni étiquette, et le code de recherche a maintenant un nom et peut être testé isolément. Quand l'imbrication est assez profonde pour que s'en échapper pose problème, c'est souvent le signe que le bloc voulait être une fonction de toute façon.

Quand ils aident, et quand ils nuisent

break et continue justifient leur place quand ils permettent à une boucle de dire « ce cas est réglé » une fois, près du début, au lieu d'envelopper tout le corps dans un if. Comparez :

/* avec continue : le vrai travail n'est pas indente */
for (int i = 0; i < n; i++) {
    if (!isValid(a[i])) continue;
    if (isDuplicate(a[i])) continue;
    process(a[i]);
}

/* sans : chaque garde ajoute un niveau */
for (int i = 0; i < n; i++) {
    if (isValid(a[i])) {
        if (!isDuplicate(a[i])) {
            process(a[i]);
        }
    }
}

Ils nuisent quand ils sont nombreux. Une boucle avec cinq break éparpillés et trois continue a une condition de sortie qui n'est écrite nulle part - un lecteur doit simuler tout le corps pour savoir quand elle s'arrête. Deux règles qui tiennent bien : gardez les gardes continue groupées en haut du corps, et si une boucle a plus d'un ou deux break, demandez-vous si la condition de l'en-tête n'aurait pas dû faire ce travail.

Deux pièges plus petits. continue dans un do-while saute au test du bas, qui est de toute façon la prochaine étape - inoffensif, mais cela surprend. Et un break hors de toute boucle ou switch est une erreur de compilation, la seule erreur ici que le compilateur attrape pour vous.