Tableau de comparaison:
| Base de comparaison | Pause | continuer |
|---|---|---|
| Tâche | Il termine l'exécution de l'itération restante de la boucle. | Il ne termine que l'itération en cours de la boucle. |
| Contrôle après pause / continuer | 'break' reprend le contrôle du programme jusqu'à la fin de la boucle contenant cette 'break'. | 'continue' reprend le contrôle du programme jusqu'à la prochaine itération de cette boucle contenant 'continue'. |
| Les causes | Cela provoque une fin précoce de la boucle. | Cela provoque l'exécution précoce de la prochaine itération. |
| Continuation | 'break' arrête la poursuite de la boucle. | 'continue' n'arrête pas la poursuite de la boucle, cela n'arrête que l'itération en cours. |
| Autres utilisations | 'break' peut être utilisé avec 'switch', 'label'. | 'continue' ne peut pas être exécuté avec 'switch' et 'labels'. |
Définition de pause
En C ++, break n'a que deux utilisations: en premier lieu, il est utilisé pour «mettre fin à l'exécution d'une instruction case in switch». Deuxièmement, «terminez la boucle et reprenez le contrôle à l'instruction suivante qui suit la boucle». Mais en Java, break a trois utilisations d’abord, il met fin à la casse dans le commutateur, ensuite à la boucle et troisième, comme indiqué précédemment, Java ne fournissant pas d’instruction 'goto', mais la rupture de forme étendue peut être utilisée dans lieu de 'goto'.
Voyons, chaque utilisation de 'pause' en détail.
Première utilisation pour terminer l'exécution de la casse dans switch. Le commutateur de rodage n’affecte que le commutateur qui l’enveloppe, il n’affecte pas la boucle entourant le commutateur.
// Dans le contexte de C ++. // utilisation de break in switch dans le contexte de C ++. commutateur (expression entière) {cas 1: ..... ..... break; cas 2: ..... ..... pause; cas 3: ..... ..... pause; défaut: ....... ....... } Deuxième utilisation, pour terminer de force la boucle et reprendre à la prochaine instruction de la boucle. Dès que l'instruction break est rencontrée à l'intérieur de la boucle, cette boucle est immédiatement terminée sans exécuter le code restant dans le corps de cette boucle et le contrôle du programme passe à l'instruction suivante écrite après cette boucle.
// utilisation de break pour sortir de la boucle dans le contexte de la classe Java main_class {public static void main (string args []) {for (int i = 0; i <100; i ++) {system.out.println ("i:" + i); si (i == 10) pause; // comme condition à l'intérieur de 'if' satistfies control sort de la boucle 'pour'. } system.out.println ("La boucle casse ici"); }} break uniquement, laissez le programme sortir de la boucle qui l'englobe. Si la rupture est utilisée avec une boucle imbriquée, elle ne se détache que de la boucle la plus interne et n'affecte pas la boucle externe.
La troisième utilisation, en utilisant la pause comme forme de goto. Java utilise break comme forme de goto sans problème. Comme goto fournit un branchement non structuré qui est difficile à comprendre et interdit également l'optimisation du compilateur, Java utilise une forme de pause étendue similaire à celle de goto et permet de sortir de plusieurs blocs à la fois et de reprendre le contrôle du programme à fin du bloc étiqueté, mentionné avec l'instruction break.
Déclaration:
étiquette de rupture;
Ici, "label" est le nom d'un certain bloc de code ou un identifiant en Java, et ce bloc libellé doit inclure l'instruction break. L'instruction break étiquetée est utilisée pour sortir de l'ensemble de la boucle imbriquée. Lorsque l'instruction break étiquetée est rencontrée, le contrôle quitte le bloc étiqueté qui est mentionné avec l'instruction break.
Voyons cela pratiquement.
// utilisation de break comme forme de goto dans le contexte de la classe Java main_class {public static void main (string args []) {boolean t = true; premier {deuxième {troisième {system.out.println ("ce troisième bloc"); si (t) casse d'abord; } system.out.println ("ce second bloc"); } system.out.println ("ce premier bloc"); } system.out.println ("ce bloc principal"); }} // sortie: c'est le troisième bloc c'est le bloc principal Dans ce code, lorsque le contrôle atteint le troisième bloc, son instruction print est exécutée et ensuite, le contrôle revient à l'instruction 'if' et, lorsqu'il est satisfait, l'instruction break avec le libellé est exécutée. Le libellé attaché avec break est le premier; le contrôle reprend donc l’instruction écrite après la fin du bloc, c’est-à-dire dans le bloc principal qui est une instruction print et qui est exécutée.
Définition de Continuer
Comme break termine l'itération restante de la boucle et permet au contrôle de sortir de la boucle, ici, continuer fonctionne un peu comme une pause. L'instruction continue arrête l'exécution du code restant dans la boucle pour cette itération en cours et reprend le contrôle à l'itération suivante de cette boucle. L'instruction continue ignore le code de l'itération en cours et passe le contrôle à l'itération suivante de la boucle.
Comprenons-le avec un exemple.
// utilisation de continue dans le contexte en C ++. // il affiche le nombre pair jusqu'à 100. class main_class {public static void main (string args []) {for (int i = 0; i <100; i ++) {if (i% 2! = 0) continue; // continue le contrôle à la prochaine itération de la boucle system.out.println ("i:" + i); }}} Dans le programme ci-dessus, si l'instruction 'if' est satisfaite, l'instruction continue est exécutée; elle ne permet pas à l'instruction print suivante de s'exécuter et reprend le contrôle à l'itération suivante de la boucle 'pour'. Si i = 1, la condition 'if' est remplie et continue est exécuté, sans exécuter l'instruction print pour la valeur impaire de 'i' et le contrôle reprend à la prochaine itération de la boucle 'pour i = 2'. Si i = 2, l'instruction 'if' n'est donc pas satisfaite; continue n'exécute pas et print instruction affiche la valeur de 'i' qui est paire.
Principales différences entre Break et Continue
- Fondamentalement, le mot-clé break met fin au reste des itérations restantes de la boucle. D'autre part, le mot-clé continue ne termine que l'itération en cours de la boucle.
- Une fois que le mot-clé break est exécuté, le contrôle du programme sort de la boucle et reprend l'instruction suivante. En cas de mot-clé continue, le contrôle du programme reprend à la prochaine itération de la boucle.
- L’étape ci-dessus conclut qu’après l’exécution du contrôle de rupture de la sortie du programme en sortie de boucle, il est clairement compris que la rupture provoque la fin anticipée de toute boucle. D'autre part, continue ne met fin qu'à l'itération actuelle et reprend à la prochaine itération de la boucle. Nous pouvons donc dire que la poursuite entraîne l'exécution anticipée de la prochaine itération de la boucle.
- Le mot-clé break met fin à l'itération restante après son exécution. Nous pouvons donc dire qu'il arrête la poursuite de la boucle, tandis que le mot-clé continue continue l'exécution de la boucle.
- Le mot clé break peut être utilisé avec les instructions «switch» ainsi que «label», alors que le mot clé continue ne peut pas être utilisé avec «switch» et «label».
Conclusion:
Les instructions break et continue sont toutes deux les instructions jump qui transfèrent le contrôle à une autre partie du programme. Là où l'instruction break laisse le contrôle quitter la boucle, l'instruction continue permet au contrôle de passer à l'itération suivante de cette boucle.
