Comment utiliser la déclaration de rupture en C ++
Quelle est la déclaration de rupture en c++
Le défaut de rupture est une déclaration de flux de contrôle qui vous permet de quitter une instruction en boucle ou en commutateur avant sa terminaison naturelle. Il est utilisé pour briser le flux d'exécution lorsqu'une condition particulière est remplie. Lorsqu'un défaut de rupture est rencontré, le contrôle est immédiatement transféré à la première instruction après la boucle ou le bloc de commutateur.
Syntaxe de l'instruction BREAK
La syntaxe pour le défaut de rupture en C ++ est assez simple, ce qui est donné ci-dessous:
casser; // Syntaxe en langue C ++
La syntaxe ci-dessus est utilisée dans la boucle ou l'instruction de commutation pour terminer l'exécution du bloc.
Comment fonctionne une déclaration de rupture en C++?
UN défaut de rupture est une commande de programmation qui indique à l'ordinateur d'arrêter d'exécuter une instruction en boucle ou de commutation et passer à la commande suivante. Lorsqu'un défaut de rupture apparaît dans une boucle, il empêche la boucle de s'exécuter et passe à la commande suivante après la boucle. Ceci est utile pour sortir rapidement d'une boucle lorsqu'une certaine condition est remplie.
Le défaut de rupture Peut également être utilisé avec la déclaration IF-Else, mais elle doit toujours être déclarée dans le corps de la boucle et uniquement utilisée pour une condition à la fois.
Dans Instructions de commutation, le défaut de rupture est généralement utilisé à la fin de chaque cas pour s'assurer que le programme ne continue pas d'exécuter des cas ultérieurs. Quand le défaut de rupture est rencontré, le programme saute de l'instruction Switch et passe à la commande suivante.
Le défaut de rupture Peut être utilisé dans les types de boucles suivants:
- pour boucle
- pendant la boucle
- Boucle à faire
- Casse de commutation
Exemples d'énoncés de rupture dans les programmes C ++
Regardons quelques exemples de casser les déclarations En langage de programmation C ++.
Exemple 1: Déclaration de rupture avec une boucle simple
#inclure
Utilisation de Namespace Std;
int main()
pour (int a = 1; a <= 20; a++)
if (a == 10)
casser;
couter << a << " ";
retour 0;
Le code ci-dessus définit une fonction principale qui utilise une boucle pour itérater les entiers de 1 à 20. La boucle est sortie prématurément en utilisant le défaut de rupture Lorsque la variable de boucle a égal à 10. Le programme imprime ensuite les entiers de 1 à 9 à la console.
Sortir
Exemple 2: Déclaration de rupture avec le cas de commutateur
#inclure
Utilisation de Namespace Std;
int main()
int a = 3;
commutateur (a)
cas 1:
couter << "Case 1: Today is Monday" << endl;
casser;
Cas 2:
couter << "Case 2: Today is Tuesday" << endl;
casser;
Cas 3:
couter << "Case 3: Today is Wednesday" << endl;
casser;
Cas 4:
couter << "Case 4: Today is Thursday" << endl;
casser;
Cas 5:
couter << "Case 5: Today is Friday" << endl;
casser;
retour 0;
Dans l'exemple ci-dessus, lorsque le programme exécute l'instruction Switch, le cas 3 sera exécuté comme "un" est initialisé à 3. Le défaut de rupture Aide à terminer l'instruction Switch sans exécuter les autres cas.
Sortir
Exemple 3: Déclaration de rupture avec une boucle à faire
#inclure
Utilisation de Namespace Std;
int main()
int num;
faire
couter << "Enter a positive number (-1 to exit): ";
cin >> num;
if (num == -1)
casser;
couter << "You entered: " << num << endl;
while (num> 0);
couter << "Program exited." << endl;
retour 0;
Le programme ci-dessus invite l'utilisateur à saisir un nombre positif, et si l'utilisateur entre -1, la boucle est sortie en utilisant le défaut de rupture. Si l'utilisateur entre un nombre positif, le programme affiche le nombre et la boucle continue jusqu'à ce que l'utilisateur entre -1.
Notez que la boucle à faire dans cet exemple garantit que la boucle est exécutée au moins une fois, même si l'utilisateur entre -1 lors de la première itération.
Sortir
Avantages de la déclaration de pause
Le défaut de rupture est utile dans un programme car il vous permet de résilier une instruction de boucle ou de commutation prématurément, sur la base d'une condition. Le principal avantage de l'utilisation d'un défaut de rupture est qu'il peut économiser du temps et des ressources de traitement en permettant au programme de quitter une instruction en boucle ou de commutation dès que l'état souhaité est rempli, plutôt que de continuer à évaluer la condition dans les itérations ultérieures.
Conclusion
En C ++, le défaut de rupture peut rendre votre code plus efficace en vous permettant de quitter une instruction en boucle ou commutation dès que l'état souhaité est rempli, plutôt que de continuer à évaluer la condition inutilement. Dans cet article, nous avons fourni le concept, la syntaxe, le travail et quelques exemples de casser les déclarations dans For-Bop, Switch Case et Do-While.