Boucles en C :instructions de bouclage For, While, Do While [Exemples]

Les conditions de contrôle doivent être bien définies et spécifiées sinon la boucle s'exécutera un nombre infini de fois. La boucle qui n'arrête pas de s'exécuter et traite les instructions un certain nombre de fois est appelée une boucle infinie . Une boucle infinie est également appelée "boucle sans fin .” Voici quelques caractéristiques d'une boucle infinie :

1. Aucune condition de résiliation n'est spécifiée.

2. Les conditions spécifiées ne sont jamais remplies.

La condition spécifiée détermine s'il faut exécuter ou non le corps de la boucle.

Le langage de programmation « C » nous fournit trois types de constructions de boucles :

1. La boucle while

2. La boucle do-while

3. La boucle for

Boucle While en C

Une boucle while est la structure de bouclage la plus simple. Alors que la syntaxe de boucle dans le langage de programmation C est la suivante :

Syntaxe de la boucle While en C :

while (condition) {
             statements;
}

Il s'agit d'une boucle à entrée contrôlée. Dans la boucle while, une condition est évaluée avant de traiter un corps de la boucle. Si une condition est vraie alors et seulement alors le corps d'une boucle est exécuté. Une fois le corps d'une boucle exécuté, le contrôle revient au début et la condition est vérifiée si elle est vraie, le même processus est exécuté jusqu'à ce que la condition devienne fausse. Une fois que la condition devient fausse, le contrôle sort de la boucle.

Après avoir quitté la boucle, le contrôle passe aux instructions qui se trouvent immédiatement après la boucle. Le corps d'une boucle peut contenir plusieurs instructions. S'il ne contient qu'une seule instruction, les accolades ne sont pas obligatoires. C'est une bonne pratique cependant d'utiliser les accolades même si nous n'avons qu'une seule instruction dans le corps.

Dans une boucle while, si la condition n'est pas vraie, alors le corps d'une boucle ne sera pas exécuté, même pas une fois. C'est différent dans la boucle do while que nous verrons bientôt.

Le programme suivant illustre une boucle while dans un exemple de programmation C :

#include<stdio.h>
#include<conio.h>
int main()
{
	int num=1;	//initializing the variable
	while(num<=10)	//while loop with condition
	{
		printf("%d\n",num);
		num++;		//incrementing operation
	}
	return 0;
}

Sortie :

1
2
3
4
5
6
7
8
9
10

Le programme ci-dessus illustre l'utilisation de la boucle while. Dans le programme ci-dessus, nous avons imprimé des séries de nombres de 1 à 10 en utilisant une boucle while.

Boucle While en programmation C

1. Nous avons initialisé une variable appelée num avec la valeur 1. Nous allons imprimer de 1 à 10 donc la variable est initialisée avec la valeur 1. Si vous voulez imprimer à partir de 0, attribuez la valeur 0 lors de l'initialisation.
2. Dans une boucle while, nous avons fourni une condition (num<=10), ce qui signifie que la boucle exécutera le corps jusqu'à ce que la valeur de num devienne 10. Après cela, la boucle sera terminée et le contrôle tombera en dehors la boucle.
3. Dans le corps d'une boucle, nous avons une fonction d'impression pour imprimer notre numéro et une opération d'incrémentation pour incrémenter la valeur par exécution d'une boucle. Une valeur initiale de num est 1, après l'exécution, il deviendra 2, et lors de la prochaine exécution, il deviendra 3. Ce processus continuera jusqu'à ce que la valeur devienne 10 puis il imprimera la série sur la console et terminera la boucle .

\n est utilisé à des fins de formatage, ce qui signifie que la valeur sera imprimée sur une nouvelle ligne.

Boucle Do-While en C

Une boucle do…while en C est similaire à la boucle while sauf que la condition est toujours exécutée après le corps d'une boucle. On l'appelle aussi une boucle contrôlée par la sortie.

La syntaxe de la boucle do while en langage de programmation C est la suivante :

Syntaxe de la boucle Do-While en C :

 do {
  statements
} while (expression);

Comme nous l'avons vu dans une boucle while, le corps est exécuté si et seulement si la condition est vraie. Dans certains cas, nous devons exécuter un corps de la boucle au moins une fois même si la condition est fausse. Ce type d'opération peut être réalisé en utilisant une boucle do-while.

Dans la boucle do-while, le corps d'une boucle est toujours exécuté au moins une fois. Une fois le corps exécuté, il vérifie la condition. Si la condition est vraie, il exécutera à nouveau le corps d'une boucle, sinon le contrôle est transféré hors de la boucle.

Semblable à la boucle while, une fois que le contrôle sort de la boucle, les instructions qui se trouvent immédiatement après la boucle sont exécutées.

La différence essentielle entre les boucles while et do-while est que dans la boucle while, le while est écrit au début. Dans la boucle do-while, la condition while est écrite à la fin et se termine par un point-virgule (;)

Le programme de boucle suivant en C illustre le fonctionnement d'une boucle do-while :

Ci-dessous, une boucle do-while en C pour imprimer un tableau de numéro 2 :

#include<stdio.h>
#include<conio.h>
int main()
{
	int num=1;	//initializing the variable
	do	//do-while loop 
	{
		printf("%d\n",2*num);
		num++;		//incrementing operation
	}while(num<=10);
	return 0;
}

Sortie :

2
4
6
8
10
12
14
16
18
20

Dans l'exemple ci-dessus, nous avons imprimé une table de multiplication de 2 en utilisant une boucle do-while. Voyons comment le programme a pu imprimer la série.

Boucle Do-While en programmation C

1. Tout d'abord, nous avons initialisé une variable 'num' avec la valeur 1. Ensuite, nous avons écrit une boucle do-while.
2. Dans une boucle, nous avons une fonction d'impression qui imprimera la série en multipliant la valeur de num par 2.
3. Après chaque incrément, la valeur de num augmentera de 1 et sera imprimée à l'écran.
4. Initialement, la valeur de num est 1. Dans un corps de boucle, la fonction d'impression sera exécutée de cette façon :2*num où num=1, puis 2*1=2 d'où la valeur deux sera imprimée . Cela continuera jusqu'à ce que la valeur de num devienne 10. Après cette boucle sera terminée et une instruction qui se trouve immédiatement après la boucle sera exécutée. Dans ce cas, retournez 0.

Boucle For en C

Une boucle for est une structure de boucle plus efficace dans la programmation en "C". La structure générale de la syntaxe de la boucle for en C est la suivante :

Syntaxe de la boucle For en C :

for (initial value; condition; incrementation or decrementation ) 
{
  statements;
}

• La valeur initiale de la boucle for n'est exécutée qu'une seule fois.
• La condition est une expression booléenne qui teste et compare le compteur à une valeur fixe après chaque itération, arrêtant la boucle for lorsque false est renvoyé.
• L'incrémentation/décrémentation augmente (ou diminue) le compteur d'une valeur définie.

Le programme suivant illustre la boucle for dans l'exemple de programmation C :

#include<stdio.h>
int main()
{
	int number;
	for(number=1;number<=10;number++)	//for loop to print 1-10 numbers
	{
		printf("%d\n",number);		//to print the number
	}
	return 0;
}

Sortie :

1
2
3
4
5
6
7
8
9
10

Le programme ci-dessus imprime la série de nombres de 1 à 10 en utilisant la boucle for.

Boucle for en programmation C

1. Nous avons déclaré une variable d'un type de données int pour stocker des valeurs.
2. Dans la boucle for, dans la partie initialisation, nous avons attribué la valeur 1 au numéro de variable. Dans la partie condition, nous avons précisé notre condition puis la partie incrémentation.
3. Dans le corps d'une boucle, nous avons une fonction d'impression pour imprimer les nombres sur une nouvelle ligne dans la console. Nous avons la valeur un stockée dans number, après la première itération, la valeur sera incrémentée et deviendra 2. Maintenant, la variable number a la valeur 2. La condition sera revérifiée et puisque la condition est vraie, la boucle sera exécutée, et il en imprimera deux sur l'écran. Cette boucle continuera à s'exécuter jusqu'à ce que la valeur de la variable devienne 10. Après cela, la boucle sera terminée et une série de 1 à 10 sera imprimée à l'écran.

En C, la boucle for peut avoir plusieurs expressions séparées par des virgules dans chaque partie.

Par exemple :

for (x = 0, y = num; x < y; i++, y--) { 
  statements; 
}

De plus, nous pouvons ignorer l'expression de la valeur initiale, la condition et/ou l'incrément en ajoutant un point-virgule.

Par exemple :

int i=0;
int max = 10;
for (; i < max; i++) {
  printf("%d\n", i);
}

Notez que les boucles peuvent également être imbriquées là où il y a une boucle externe et une boucle interne. Pour chaque itération de la boucle externe, la boucle interne répète son cycle entier.

Considérez l'exemple suivant avec plusieurs conditions dans une boucle for, qui utilise une boucle for imbriquée dans la programmation C pour générer une table de multiplication :

#include <stdio.h>
int main() {
int i, j;
int table = 2;
int max = 5;
for (i = 1; i <= table; i++) { // outer loop
  for (j = 0; j <= max; j++) { // inner loop
    printf("%d x %d = %d\n", i, j, i*j);
  }
  printf("\n"); /* blank line between tables */
}}

Sortie :

1 x 0 = 0
1 x 1 = 1
1 x 2 = 2
1 x 3 = 3
1 x 4 = 4
1 x 5 = 5

2 x 0 = 0
2 x 1 = 2
2 x 2 = 4
2 x 3 = 6
2 x 4 = 8
2 x 5 = 10

L'imbrication des boucles for peut être effectuée jusqu'à n'importe quel niveau. Les boucles imbriquées doivent être suffisamment indentées pour rendre le code lisible. Dans certaines versions de "C", l'imbrication est limitée à 15 boucles, mais certaines en proposent davantage.

Les boucles imbriquées sont principalement utilisées dans les applications de tableaux que nous verrons dans d'autres tutoriels.

Instruction de rupture en C

L'instruction break est principalement utilisée dans l'instruction switch. C'est aussi utile pour arrêter immédiatement une boucle.

On considère le programme suivant qui introduit une pause pour sortir d'une boucle while :

#include <stdio.h>
int main() {
int num = 5;
while (num > 0) {
  if (num == 3)
    break;
  printf("%d\n", num);
  num--;
}}

Sortie :

5
4

Continuer l'instruction en C

Lorsque vous souhaitez passer à l'itération suivante mais rester dans la boucle, vous devez utiliser l'instruction continue.

Par exemple :

#include <stdio.h>
int main() {
int nb = 7;
while (nb > 0) {
  nb--;
  if (nb == 5)
    continue;
 printf("%d\n", nb);
}}

Sortie :

6
4
3
2
1

Ainsi, la valeur 5 est ignorée.

Quelle boucle sélectionner ?

La sélection d'une boucle est toujours une tâche difficile pour un programmeur, pour sélectionner une boucle, procédez comme suit :

• Analysez le problème et vérifiez s'il nécessite une boucle de pré-test ou de post-test.
• Si un test préalable est requis, utilisez une boucle while ou for a.
• Si un post-test est requis, utilisez une boucle do-while.

Résumé

• Définir la boucle en C :une boucle est l'un des concepts clés de tout langage de programmation. Les boucles en langage C sont implémentées à l'aide d'instructions conditionnelles.
• Un bloc d'instructions de contrôle de boucle en C est exécuté un certain nombre de fois jusqu'à ce que la condition devienne fausse.
• Les boucles en programmation C sont de 2 types :contrôlées par l'entrée et contrôlées par la sortie.
• Énumérer diverses instructions de contrôle de boucle en C :la programmation en C nous fournit 1) tandis que 2) faire pendant que et 3) pour les instructions de contrôle de boucle.
• La programmation des boucles For et While en C sont des boucles contrôlées par entrée en langage C.
• Do-while est une boucle de contrôle de sortie en C.