Menu

Boucles en C #: instructions de contrôle et diverses boucles avec des exemples

  • Principal
  • Autre
  • Boucles en C #: instructions de contrôle et diverses boucles avec des exemples

loops c control statements

Essayez Notre Instrument Pour Éliminer Les Problèmes

Les boucles en C # permettent au programme d'exécuter plusieurs fois un bloc de code. Ce didacticiel explique diverses boucles telles que les boucles While, les boucles For, etc. avec des exemples:

Dans notre tutoriel précédent, nous avons découvert différents Opérateurs C # qui peut être utilisé en conjonction avec les instructions de prise de décision pour suivre un flux d'exécution requis.

Dans ce didacticiel, nous discuterons des instructions de boucle C # qui permettent au programme d'exécuter une logique itérative.

=> Consultez notre guide de formation ultime C # ici

boucles en C #

Ce que vous apprendrez:

Boucles en C #: un aperçu complet

Toutes les instructions écrites en C # sont exécutées séquentiellement, mais il peut y avoir un scénario où le programme doit exécuter un certain extrait de code plusieurs fois, pour gérer ce genre de situation, C # offre des instructions de contrôle qui peuvent être utilisées pour gérer des flux d'exécution compliqués .

Une boucle permet au programme d'exécuter un bloc de code plusieurs fois en suivant une instruction générale en C #. C # propose différents types de boucles pour gérer différentes exigences d'exécution de la programmation.

Déclaration de contrôle

Avant de commencer à travailler sur des boucles, nous devons savoir ce qu'est une instruction de contrôle. Une instruction de contrôle permet à la boucle de changer de cours par rapport à sa séquence normale. Le langage de programmation C # propose les instructions de contrôle de boucle de base suivantes.

Continuer la déclaration

L'instruction Continue en C # est utilisée pour les raisons suivantes:

  • Pour exécuter la prochaine itération de la boucle en ignorant tout code intermédiaire.

La syntaxe de l'instruction continue est ' Continuez;'

Déclaration de rupture

L'instruction Break en C # est utilisée pour les raisons suivantes:

c ++, fonction de veille linux
  • Il est utilisé pour terminer une boucle afin que le programme puisse continuer avec l'instruction de boucle suivante. Dans les boucles imbriquées, il peut être utilisé pour arrêter l'exécution de la boucle interne, fournissant ainsi le contrôle du programme à l'instruction suivante après le code actuel.
  • Il peut être utilisé pour terminer une instruction dans le Boîtier de commutation.

La syntaxe de l'instruction break est ' Pause;'

Alors que la boucle

La boucle while valide une condition, puis exécute le bloc de code tant que la condition définie dans le while est vraie.

Syntaxe

While(Boolean Condition) { //code block// }

Pointeurs importants:

  • L'instruction booléenne est validée avant l'exécution du code.
  • Si l'expression booléenne est validée comme true, alors seulement le code est exécuté.
  • Une fois le bloc de code exécuté, le contrôle retournera à une instruction booléenne pour évaluation.
  • La boucle continuera à s'exécuter tant que l'expression booléenne évaluera true.
  • Si l'expression booléenne a la valeur false, le bloc de code est ignoré et la ligne suivante du code en dehors de la boucle while est exécutée.
  • Assurez-vous toujours de mettre à jour la variable utilisée avec une expression booléenne, afin qu'elle reconnaisse la fin de la boucle à l'itération attendue.
  • Si la variable associée à la boucle while n'est pas mise à jour ou renvoie toujours une valeur vraie, alors elle deviendra une boucle infinie.

Exemple de boucle While simple:

int a = 0; while (a <5) { Console.WriteLine(“The value of a is :”+a); a++; } Console.WriteLine(“The while block has been executed”);

Explication du code

Dans le programme ci-dessus, nous avons fourni l'expression booléenne sous la forme (a<5) for “while”. It means that the loop will continue to execute the code snippet as long as the value of “a” is less than 5.

Dans le bloc de code, nous imprimons la valeur de «a», puis nous avons ajouté l'opérateur d'incrémentation. Comme nous l'avons vu précédemment dans notre précédent didacticiel, l'opérateur d'incrémentation est utilisé pour augmenter la valeur de l'entier de 1. Par conséquent, une fois que la valeur de «a» est imprimée sur la console, le contrôle passera par l'opérateur d'incrémentation, ce qui augmentera sa taille par 1.

Maintenant, le contrôle se déplacera pour évaluer l'expression booléenne. Pour l'exemple actuel, comme nous avons déjà défini la valeur initiale de a comme «0», elle sera incrémentée de «1». Ainsi, l'expression booléenne deviendra (1<5) which will evaluate to “true” and the code block inside the loop will get executed.

Une fois que la valeur de «a» atteint 5, l'exécution s'arrêtera car l'expression booléenne se lira désormais comme false. Une fois que l'expression booléenne retourne false, le contrôle existera en boucle et exécutera la prochaine ligne de code en dehors du bloc while.

Si le programme est exécuté, la sortie sera comme indiqué ci-dessous:

Production

La valeur de a est: 0
La valeur de a est: 1
La valeur de a est: 2
La valeur de a est: 3
La valeur de a est: 4
Le bloc while a été exécuté

Faire une boucle

La boucle Do while est similaire à la boucle while avec une différence, la condition est évaluée à la fin de la boucle au lieu de commencer comme nous l'avons discuté dans le cas d'une boucle while. Cela donne une caractéristique unique à cette boucle, c'est-à-dire qu'elle exécutera l'instruction à l'intérieur de la limite de la boucle au moins une fois.

Alors que d'autre part, d'autres boucles évaluent l'expression booléenne au début, ce qui signifie que si l'expression est fausse, la boucle ne s'exécutera pas.

Syntaxe

do { //code block for execution// } while( Boolean expression );

Pointeurs importants:

tests alpha et bêta en génie logiciel
  • «Do while» fonctionne comme une boucle while. Le mot clé Do est placé au début du bloc de code et le while est placé après le bloc de code.
  • L'expression booléenne est évaluée à la fin de la boucle au lieu du début. Si la condition est vraie, la boucle continue. Si l'expression renvoie false, la boucle se termine là-bas.
  • «Do while» exécute le bloc de code à l'intérieur des limites de la boucle au moins une fois.

Exemple de boucle Do-While simple:

int nmbr = 5; /* do loop starts*/ do { Console.WriteLine('value of nmbr is '+ nmbr); nmbr++; } while (nmbr <10); Console.ReadLine();

Explication du code

Dans le code ci-dessus, nous avons déclaré un entier, «nmbr» avec la valeur 5. Ensuite, nous avons commencé la boucle en plaçant le mot-clé «Do». Après le Do et à l'intérieur des accolades, nous avons défini le code que nous voulons exécuter. Ici, nous imprimons simplement la valeur de l'entier nmbr à la console. Vous pouvez écrire votre propre code complexe entre les crochets.

Comme nous pouvons le voir, après avoir imprimé la valeur de nmbr, nous l'incrémentons. Une fois le bloc de code traité, le contrôle passe à «while», où l'expression booléenne est évaluée. Ici, jusqu'à ce que le nmbr ait une valeur inférieure à 10, il continuera à itérer la boucle.

Donc, si nous exécutons cet extrait de code, la sortie suivante peut être observée:

Production

la valeur de nmbr est 5
la valeur de nmbr est 6
la valeur de nmbr est 7
la valeur de nmbr est 8
la valeur de nmbr est 9

Une fois, la valeur du nmbr a atteint 10 (en incrémentant à chaque itération). Ensuite, la condition while renverra une valeur fausse car elle n'est plus inférieure à 10. Cela amènera le contrôle à quitter la boucle «Do while» et le contrôle passera à la ligne de code suivante.

Pour la boucle

La boucle For en C # suit une syntaxe assez différente de la boucle «while». La condition de la boucle «for» contient l'initialisation et la modification de la condition à l'intérieur de la syntaxe elle-même. La boucle «for» est très utile si vous connaissez le nombre exact d'itérations que vous devez effectuer pour la boucle.

La définition à l'intérieur de la parenthèse de la boucle contient trois parties séparées les unes des autres par des points-virgules. La première partie est l'initialisation, puis nous avons une expression booléenne suivie de la liste d'itérations.

Syntaxe

for(initializer; boolean expression; iteration list) { //code block for execution// }

La première partie de l'expression est le bloc d'initialisation. Cette expression est utilisée pour initialiser la variable entière. Cela fournira la valeur au début de la boucle.

La deuxième partie est l'expression booléenne qui est utilisée pour évaluer la condition vrai ou faux pour la continuation de la boucle, tout comme la boucle while.

La troisième expression est la partie itération. Ici, nous pouvons utiliser les opérateurs d'incrémentation ou de décrémentation pour augmenter ou diminuer la valeur de la variable initialisée selon les exigences d'exécution.

Pointeurs importants:

  • Les boucles For en C # permettent aux programmeurs de définir le nombre exact d'itérations à effectuer.
  • La boucle For contient également des expressions d'initialisation et d'itération ainsi que l'expression booléenne pour fournir une condition pour la boucle.
  • La boucle For est utilisée lorsque nous connaissons clairement le nombre d'itérations requises par la boucle.
  • L'initialisation de la variable se produit au début de la boucle.
  • Après l'initialisation, le contrôle est passé à la deuxième section pour valider l'expression booléenne. L'expression booléenne peut être aussi complexe que vous le souhaitez, mais le résultat doit toujours renvoyer true ou false en tant que valeur.
  • Une fois que l'expression booléenne est évaluée comme true, le bloc de code entre accolades est exécuté et le contrôle se déplace à nouveau vers le haut de la boucle et l'opérateur d'incrémentation ou de décrémentation est exécuté.
  • Une fois la liste d'itérations exécutée, le contrôle se déplace à nouveau vers l'expression booléenne pour évaluation et la boucle est itérée si elle renvoie «true» ou la ligne de code suivante en dehors de la boucle est exécutée si elle renvoie false.

Exemple de boucle For simple:

/* for loop starts*/ for(int i=0; i<5; i++) { Console.WriteLine('value of i is '+ i); }

Explication du code

Dans le code ci-dessus, nous avons initialisé l'entier i à 0. Ensuite, nous avons fourni l'expression booléenne pour évaluer si i est inférieur à 0 et un opérateur d'incrémentation.

L'initialisation se produit au début de la boucle, puis la condition booléenne est évaluée suivie de l'exécution du bloc de code entre accolades. Le contrôle est ensuite à nouveau passé à l'opérateur d'incrémentation en haut, qui augmente la valeur de i de 1 à chaque itération.

Jetons un œil à la sortie pour plus de clarté.

Production

la valeur de i est 0
la valeur de i est 1
la valeur de i est 2
la valeur de i est 3
la valeur de i est 4

Pour chaque boucle

Une boucle For Each est utilisée lorsqu'un programme doit parcourir le contenu d'une liste. Il peut être utilisé pour des collections telles que des listes de tableaux ou des tableaux.

Syntaxe

foreach(item_type iterative_variable in list_type) { //code block for execution// }

Le «type_élément» dans la syntaxe est le type de l'élément contenu dans la liste. Par exemple, si nous utilisons un tableau d'entiers, le type sera entier ou int.

«Iterative_variable» est un nom de variable que vous avez choisi et «in» est un mot-clé utilisé.

Le 'list_type' est le type de liste que vous utilisez. Par exemple, si nous utilisons un tableau d'entiers, le list_type sera le nom du tableau int.

Pointeurs importants:

  • Pour chaque boucle exécute le bloc de code sur chaque élément présent dans la collection spécifiée.
  • Pour chaque boucle est en lecture seule, par conséquent, il ne vous permet pas de modifier la variable d'itération pendant l'exécution.
  • Pour chaque itération utilisant cette boucle récupère une nouvelle valeur dans la liste. La valeur est ensuite placée dans la variable en lecture seule.
  • Une fois que tous les éléments de la liste ont été épuisés lors de l'itération, le contrôle passera à la ligne de code suivante.

Exemple d'un simple pour chaque boucle:

/* specifies list*/ int() list = {1,2,3,4,5}; /* foreach loop starts*/ foreach (int nmbr in list) { Console.WriteLine('Numbers present in list are '+ nmbr); }

Explication du code

Dans un premier temps, nous avons défini un tableau «liste» dans la première ligne. Ensuite, nous avons utilisé une boucle for each pour itérer et imprimer toutes les valeurs du tableau.

À l'intérieur de l'instruction de boucle, nous avons déclaré une variable de type entier «nmbr» suivie du mot-clé «in» qui est ensuite suivi par le même du tableau. Donc, ici ce que nous voulons dire, c'est que nous recherchons un entier «nmbr» à l'intérieur de «list».

Ensuite, l'instruction est un simple bloc de code pour imprimer toutes les valeurs. Nous imprimons la variable «nmbr» et, comme indiqué précédemment, il s'agit d'une variable en lecture seule et stocke une nouvelle valeur à chaque itération.

Jetons un œil au résultat pour une meilleure compréhension.

Production

j2ee entretien questions et réponses pdf

Les nombres présents dans la liste sont 1
Les nombres présents dans la liste sont 2
Les nombres présents dans la liste sont 3
Les nombres présents dans la liste sont 4
Les nombres présents dans la liste sont 5

Boucle infinie

Une boucle peut continuer pendant un temps infini si la condition définissant la boucle ne renvoie jamais une valeur fausse. En général, la boucle for ou while peut être utilisée pour effectuer une opération de boucle infinie.

Boucle infinie utilisant la boucle For

Nous pouvons utiliser «for loop» pour effectuer une opération en boucle infinie car aucune des trois instructions n'est obligatoire. Par conséquent, si nous laissons toutes les instructions vides, cela créera une boucle infinie.

/* for loop starts*/ for (; ;) { Console.WriteLine('infinite loop”); }

Cette boucle continuera à imprimer une «boucle infinie» dans la console pendant un temps infini.

Boucle infinie utilisant la boucle While

La boucle While peut également être utilisée pour effectuer des opérations en boucle infinie. Nous pouvons le faire en fournissant une condition qui ne peut jamais être fausse.

Par exemple x> 0 et incrémenter x à chaque fois à partir de 1.

/* while loop starts*/ int x = 1; while(x>0) { Console.WriteLine('infinite loop”); x++; }

Cela continuera à imprimer «boucle infinie» sur la console car la valeur de x restera toujours supérieure à 1. Par conséquent, la condition while retournera toujours la valeur «vraie», et le bloc de code à l'intérieur de while continuera à s'exécuter.

Conclusion

La boucle vous permet d'itérer un bloc de code encore et encore. Le langage de programmation C # propose différentes instructions pour utiliser une boucle comme «for», «while», «do while» et «for each».

La boucle While exécute un bloc de code tant que l'expression à l'intérieur du bloc while est vraie. La boucle Do While permet à l'utilisateur d'exécuter un bloc de code au moins une fois, puis il continuera à itérer jusqu'à ce que l'expression à l'intérieur de tout retourne false.

La boucle For est utilisée lorsque nous connaissons déjà le nombre de fois que nous devons itérer le code. Pour chaque boucle est utilisé pour exécuter chaque élément à l'intérieur d'une liste / collection en utilisant un bloc de code donné.

Normalement, une boucle s'exécute jusqu'à ce que l'expression de contrôle retourne true, mais l'instruction continue ou break peut être utilisée pour modifier son flux d'exécution.

Il est également possible de créer des boucles infinies en utilisant des instructions for ou while pour exécuter un bloc de code un nombre infini de fois. Ces blocs de code continueront à s'exécuter car l'expression définissant l'instruction de boucle retournera toujours true.

=> Recherchez le guide de formation Easy C # ici

lecture recommandée

^