Programmation en C# – Les boucles

Vous pouvez rencontrer des situations, quand un bloc de code doit être exécuté plusieurs fois. En général, les instructions sont exécutées séquentiellement.

Dans tous les langages de programmation, les boucles sont utilisées pour exécuter un ensemble d’instructions plusieurs fois jusqu’à ce qu’une condition particulière soit satisfaite.

 
 
Une séquence d’instructions est exécutée jusqu’à ce qu’une condition soit vraie. Cette séquence d’instructions à exécuter est à l’intérieur des accolades {  } appelées le corps de la boucle. Après chaque exécution du corps de la boucle, la condition est vérifiée, et si elle est trouvée « true », le corps de la boucle est exécuté à nouveau. Lorsque la vérification retourne « false », le corps de la boucle ne sera pas exécuté.

Le langage de programmation C# fournit différents façon pour déclarer des boucles.

Description des différents types de boucles
La boucle while
Répète une instruction ou un groupe d’instruction jusqu’à ce qu’une condition donnée est vraie. Il teste la condition avant d’exécuter le corps de la boucle.
La boucle for
Exécute une séquence d’instructions plusieurs fois avec  un code abrégé.
La boucle do…while
Il ressemble à la déclaration while, sauf qu’elle teste la condition à la fin du corps de la boucle.
Les boucles imbriquées
Vous pouvez utiliser une ou plusieurs boucles à l’intérieur d’une autre boucle while, for ou do..while

 

La boucle while

Tandis que la boucle while peut être traitée comme une boucle de contrôle. Il est complété en 3 étapes.
1- Initialisation de la variable (par exemple, int x = 0;)
2- Condition (par exemple while(x <= 100))
3- Incrémentation ou décrémentation de la variable (x ++ ou x– ou x = x + 4)

La syntaxe :

initialisation de la variable;

while (condition)
{
    bloc d'instructions;
    incrementation ou decrementation de la variable; 
}
Exemple:
using System;
namespace Boucle
{
   class Test
   {
      static void Main(string[] args)
      {
         /* Définition de la variable locale */
         int a = 10;

         /* l'exécution de la boucle */
         while (a < 20)
         {
            Console.WriteLine("valeur de a: {0}", a);
            a++;
         }
         Console.ReadLine();
      }
   }
}

La sortie :

valeur de a: 10
valeur de a: 11
valeur de a: 12
valeur de a: 13
valeur de a: 14
valeur de a: 15
valeur de a: 16
valeur de a: 17
valeur de a: 18
valeur de a: 19

 
 

La boucle for

La boucle for est utilisé pour exécuter un ensemble d’instructions de façon répétitive jusqu’à ce qu’une condition particulière soit satisfaite. Le format général est,

for(initialisation; condition ; incrementation/decrementation)
{
   Bloc d'instructions;
}

Dans la boucle for nous avons exactement deux points-virgules, un après l’initialisation et la deuxième après la condition. Dans cette boucle, nous pouvons avoir plus d’une initialisation ou une incrémentation ou décrémentation séparés par des virgules. Une boucle for ne peut avoir qu’une seule condition.

Exemple :

using System;
namespace Boucle
{
   class Test
   {
      static void Main(string[] args)
      {
         /* l'exécution de la boucle for*/
         for (int a = 10; a < 20; a = a + 1)
         {
            Console.WriteLine("valeur de a: {0}", a);
         }
         Console.ReadLine();
      }
   }
} 


La sortie :

valeur de a: 10
valeur de a: 11
valeur de a: 12
valeur de a: 13
valeur de a: 14
valeur de a: 15
valeur de a: 16
valeur de a: 17
valeur de a: 18
valeur de a: 19

 

La boucle do…while

Dans certaines situations, il est nécessaire d’exécuter le corps de la boucle avant de tester la condition. Ces situations peuvent être traitées avec la boucle do…while. Do permet d’évaluer le corps de la boucle en premier, la condition est vérifiée en utilisant l’instruction while. Le format général de la boucle do…while est,

do
{
 ....
 .....
}
while(condition)
Exemple:
using System;
namespace Boucle
{
   class Test
   {
      static void Main(string[] args)
      {
         /* Définition de la variable locale */
         int a = 10;
         
         /* l'exécution de la boucle do */
         do
         {
            Console.WriteLine("valeur de a: {0}", a);
            a = a + 1;
         } 
         while (a < 20);
         Console.ReadLine();
      }
   }
} 

La sortie :

valeur de a: 10
valeur de a: 11
valeur de a: 12
valeur de a: 13
valeur de a: 14
valeur de a: 15
valeur de a: 16
valeur de a: 17
valeur de a: 18
valeur de a: 19

 
 

Les boucles imbriquées

Nous pouvons également avoir des boucles imbriquées, c’est-à-dire une boucle à l’intérieur d’une autre boucle. La syntaxe de base est,

for(initialization; condition; increment/decrement)
{
  for(initialization; condition; increment/decrement)
     {
        statement ;
     }
}
Exemple:

Le programme suivant utilise une boucle imbriquée pour trouver les nombres premiers de 2 à 100:

using System;
namespace Boucle
{
   class Test
   {
      static void Main(string[] args)
      {
         /* Définition de la variable locale */
         int i, j;
         for (i = 2; i < 100; i++)
         {
            for (j = 2; j <= (i / j); j++)
            if ((i % j) == 0) break; // si le facteur trouvé, donc c'est un nombre premier
            if (j > (i / j))
            Console.WriteLine("{0} est un nombre premier", i);
         }
         Console.ReadLine();
      }
   }
}

La sortie :

2 est un nombre premier
3 est un nombre premier
5 est un nombre premier
7 est un nombre premier
11 est un nombre premier
13 est un nombre premier
17 est un nombre premier
19 est un nombre premier
23 est un nombre premier
29 est un nombre premier
31 est un nombre premier
37 est un nombre premier
41 est un nombre premier
43 est un nombre premier
47 est un nombre premier
53 est un nombre premier
59 est un nombre premier
61 est un nombre premier
67 est un nombre premier
71 est un nombre premier
73 est un nombre premier
79 est un nombre premier
83 est un nombre premier
89 est un nombre premier
97 est un nombre premier

 
 

La boucle infinie

Une boucle devient une boucle infinie si une condition ne devient jamais fausse, elle est toujours vraie. ou vous pouvez faire une boucle infinie en laissant l’expression conditionnelle vide.

using System;
namespace Boucle
{
   class Test
   {
      static void Main(string[] args)
      {
         for (; ; )
         {
            Console.WriteLine("Cette une boucle infinie");
         }
      }
   }
} 

Lorsque l’expression conditionnelle est absente, elle est supposée vraie. Vous pouvez avoir une expression d’initialisation et d’incrémentation, mais les programmeurs C# utilisent plus souvent la syntaxe for (;;) pour signifier une boucle infinie.

Vous pouvez terminer une boucle infinie en appuyant sur les touches Ctrl + C.

 

Voire aussi :

 
 

Partagez cet article

Laisser un commentaire

Votre adresse e-mail ne sera pas publiée. Les champs obligatoires sont indiqués avec *