Boucle C # while et do ... while (avec des exemples)

Dans cet article, nous allons découvrir les boucles while et do… while en C #, comment les utiliser et les différences entre elles.

En programmation, il est souvent souhaité d'exécuter certains blocs d'instructions un nombre de fois spécifié. Une solution possible sera de taper ces instructions le nombre de fois requis. Cependant, le nombre de répétitions peut ne pas être connu à l'avance (pendant la compilation) ou peut-être assez grand (disons 10000).

La meilleure solution à ce problème est la boucle. Les boucles sont utilisées dans la programmation pour exécuter à plusieurs reprises un certain bloc d'instructions jusqu'à ce qu'une condition soit remplie.

Dans cet article, nous allons apprendre à utiliser les boucles while en C #.

Boucle while C #

Le mot clé while est utilisé pour créer une boucle while en C #. La syntaxe de la boucle while est:

 while (test-expression) (// corps de while)

Comment fonctionne la boucle while?

  1. La boucle while C # se compose d'un fichier test-expression.
  2. Si le test-expressionest évalué à true,
    1. les instructions à l'intérieur de la boucle while sont exécutées.
    2. après exécution, le test-expressionest à nouveau évalué.
  3. Si le test-expressionest évalué à false, la boucle while se termine.

Organigramme de la boucle while

Exemple 1: boucle while

 using System; namespace Loop ( class WhileLoop ( public static void Main(string() args) ( int i=1; while (i<=5) ( Console.WriteLine("C# For Loop: Iteration (0)", i); i++; ) ) ) )

Lorsque nous exécutons le programme, la sortie sera:

 Boucle For C #: Itération 1 Boucle For C #: Itération 2 Boucle For C #: Itération 3 Boucle For C #: Itération 4 Boucle For C #: Itération 5

Initialement, la valeur de i est 1.

Lorsque le programme atteint l'instruction de boucle while,

  • l'expression de test i <=5est évaluée. Puisque i vaut 1 et 1 <= 5est true, il exécute le corps de la boucle while. Ici, la ligne est imprimée sur l'écran avec l'itération 1 et la valeur de i est augmentée de 1 pour devenir 2.
  • Maintenant, l'expression de test ( i <=5) est à nouveau évaluée. Cette fois aussi, l'expression renvoie true(2 <= 5), donc la ligne est imprimée à l'écran et la valeur de i est maintenant incrémentée à 3…
  • Cela va et la boucle while s'exécute jusqu'à ce que i devienne 6. À ce stade, l'expression de test évaluera à falseet donc la boucle se termine.

Exemple 2: boucle while pour calculer la somme des 5 premiers nombres naturels

 using System; namespace Loop ( class WhileLoop ( public static void Main(string() args) ( int i=1, sum=0; while (i<=5) ( sum += i; i++; ) Console.WriteLine("Sum = (0)", sum); ) ) )

Lorsque nous exécutons le programme, la sortie sera:

 Somme = 15

Ce programme calcule la somme des 5 premiers nombres naturels.

  • Initialement, la valeur de somme est initialisée à 0.
  • À chaque itération, la valeur de la somme est mise à jour sum+iet la valeur de i est incrémentée de 1.
  • Lorsque la valeur de i atteint 6, l'expression de test i<=5renvoie false et la boucle se termine.

Voyons ce qui se passe dans le programme donné à chaque itération.

Au départ, i = 1, somme = 0

Pendant les étapes d'exécution de la boucle
Itération Valeur de i i <= 5 Valeur de la somme
1 1 vrai 0 + 1 = 1
2 2 vrai 1 + 2 = 3
3 3 vrai 3 + 3 = 6
4 4 vrai 6 + 4 = 10
5 5 vrai 10 + 5 = 15
6 6 faux La boucle se termine

Ainsi, la valeur finale de la somme sera de 15.

C # faire… boucle while

Le mot clé do et while est utilisé pour créer une boucle do… while. C'est similaire à une boucle while, mais il existe une différence majeure entre eux.

Dans la boucle while, la condition est vérifiée avant que le corps ne soit exécuté. C'est exactement le contraire de la boucle do… while, c'est-à-dire que la condition est vérifiée après l'exécution du corps.

C'est pourquoi, le corps de la boucle do… while s'exécutera au moins une fois indépendamment de l'expression de test.

La syntaxe de la boucle do… while est:

 do (// corps de la boucle do while) while (test-expression);

Comment fonctionne la boucle while?

  1. Le corps de la boucle do… while est d'abord exécuté.
  2. Ensuite, le test-expressionest évalué.
  3. Si le test-expressionest true, le corps de la boucle est exécuté.
  4. Lorsque la boucle test-expressionest false, faites… tandis que la boucle se termine.

faire… en boucle Organigramme

Exemple 3: boucle do… while

 using System; namespace Loop ( class DoWhileLoop ( public static void Main(string() args) ( int i = 1, n = 5, product; do ( product = n * i; Console.WriteLine("(0) * (1) = (2)", n, i, product); i++; ) while (i <= 10); ) ) )

Lorsque nous exécutons le programme, la sortie sera:

 5 * 1 = 5 5 * 2 = 10 5 * 3 = 15 5 * 4 = 20 5 * 5 = 25 5 * 6 = 30 5 * 7 = 35 5 * 8 = 40 5 * 9 = 45 5 * 10 = 50

As we can see, the above program prints the multiplication table of a number (5).

  • Initially, the value of i is 1. The program, then enters the body of do… while loop without checking any condition (as opposed to while loop).
  • Inside the body, product is calculated and printed on the screen. The value of i is then incremented to 2.
  • After the execution of the loop’s body, the test expression i <= 10 is evaluated. In total, the do… while loop will run for 10 times.
  • Finally, when the value of i is 11, the test-expression evaluates to false and hence terminates the loop.

Infinite while and do… while loop

If the test expression in the while and do… while loop never evaluates to false, the body of loop will run forever. Such loops are called infinite loop.

For example:

Infinite while loop

 while (true) (// corps de la boucle while)

Boucle infinie do… while

 do (// corps de la boucle while) while (true);

La boucle infinie est utile lorsque nous avons besoin d'une boucle à exécuter tant que notre programme s'exécute.

Par exemple, si votre programme est une animation, vous devrez l'exécuter constamment jusqu'à ce qu'il soit arrêté. Dans de tels cas, une boucle infinie est nécessaire pour continuer à exécuter l'animation à plusieurs reprises.

Articles intéressants...