Boucles en C : For, While, Do Whileping Déclarations [Exemples]

Qu’est-ce que la boucle en C ?

Cabinetsping En C, une instruction exécute une séquence d'instructions plusieurs fois jusqu'à ce que la condition spécifiée devienne fausse. Une boucle en C se compose de deux parties : le corps de la boucle et une instruction de contrôle. L'instruction de contrôle est une combinaison de conditions qui déterminent si le corps de la boucle doit s'exécuter jusqu'à ce que la condition spécifiée devienne fausse. Le but d'une boucle en C est de répéter le même code un certain nombre de fois.

Types de boucles en C

Selon la position d'une instruction de contrôle dans un programme, looping Les instructions en C sont classées en deux types :

1. Boucle d'entrée contrôlée
2. Quitter la boucle contrôlée

Dans une boucle de contrôle d'entrée en C, une condition est vérifiée avant l'exécution du corps de la boucle. On parle également de boucle de pré-vérification.

Dans une boucle à condition de sortie, une condition est vérifiée après l'exécution du corps de la boucle. On parle également de boucle à post-vérification.

Exemple de boucle

Les conditions de contrôle doivent être clairement définies et spécifiées, sinon la boucle s'exécutera indéfiniment. Une boucle qui ne s'arrête jamais et traite les instructions un nombre infini de fois est appelée boucle infinie. On parle également de « boucle sans fin ». Voici quelques caractéristiques d'une boucle infinie :

1. Aucune condition de fin n'est spécifiée.
2. Les conditions spécifiées ne sont jamais réunies.

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 propose 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 méthode la plus simple pour les toilettes.ping Structure. La syntaxe de la boucle while en langage 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, alors les accolades ne sont pas obligatoires. C'est une bonne pratique cependant d'utiliser les accolades même si nous avons 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é, pas même une seule fois. C'est différent dans la boucle do while que nous verrons bientôt.

Le programme suivant illustre la 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é un variable On appelle cette variable « num » la valeur 1. On va afficher les nombres de 1 à 10, c'est pourquoi la variable est initialisée à 1. Si vous voulez afficher les nombres à partir de 0, assignez-lui 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 de 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 à chaque exécution d'une boucle. Une valeur initiale de num est 1, après l'exécution, elle deviendra 2, et lors de la prochaine exécution, elle 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 .

Le caractère '\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 également boucle contrôlée en 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 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 son état. Si la condition est vraie, alors 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 critique entre les boucles while et do-while est que dans la boucle while, le while est écrit au début. Dans une 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 :

Vous trouverez ci-dessous un exemple de boucle do-while en C pour imprimer un tableau du 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 à l'aide d'une boucle do while. Voyons comment le programme a pu imprimer la série.

Boucle Do-While dans la 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 va imprimer 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 print sera exécutée de cette manière : 2*num où num=1, puis 2*1=2 donc 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, renvoie 0.

Boucle For en C

Une boucle for est une structure de boucle plus efficace dans la programmation « 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;
}

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

Le programme suivant illustre la boucle for dans un 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 de type int pour stocker les 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ément.
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 le nombre, après la première itération la valeur sera incrémentée et elle deviendra 2. Maintenant la variable numéro 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 se terminera 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ù se trouvent une boucle externe et une boucle interne. Pour chaque itération de la boucle externe, la boucle interne répète tout son cycle.

Prenons 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 est possible à n'importe quel niveau. Les boucles imbriquées doivent être correctement indentées pour une meilleure lisibilité du code. Dans certaines versions de C, l'imbrication est limitée à 15 boucles, tandis que d'autres en autorisent davantage.

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

Au-delà des trois types de boucles, le langage C propose deux instructions qui modifient le fonctionnement d'une boucle de l'intérieur.

Instruction Break en C

L'instruction break est utilisée principalement dans le instruction switchIl est également utile pour arrêter immédiatementping une boucle.

On considère le programme suivant qui introduit un break 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 :

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

FAQ