Boucle while en C : Votre Porte d'entrée vers un Programming Répetitif

Salut là, future superstar du codage ! Prêt à plonger dans le merveilleux monde des boucles ? Aujourd'hui, nous allons explorer l'un des concepts les plus fondamentaux de la programmation : la boucle while en C. Fais-moi confiance, une fois que tu auras maîtrisé cela, tu vas te sentir comme si tu avais déverrouillé un superpouvoir en codage !

Qu'est-ce qu'une Boucle while ?

Avant de rentrer dans les détails, comprenons ce qu'est une boucle while. Imagine que tu joues à un jeu vidéo où tu dois battre 10 ennemis pour terminer un niveau. Plutôt que d'écrire le même code "attaquer" 10 fois, ne serait-il pas sympa de pouvoir dire "Continue à attaquer tant qu'il reste des ennemis" ? C'est exactement ce que fait une boucle while en programmation !

Une boucle while te permet de répéter un bloc de code aussi longtemps qu'une certaine condition est vraie. C'est comme dire à ton ordinateur : "Eh, continue de faire cela jusqu'à ce que je te dise d'arrêter !"

Syntaxe de la Boucle while en C

Regardons la structure de base d'une boucle while en C :

while (condition) {
// code à répéter
}

C'est simple ! La condition est vérifiée avant chaque itération de la boucle. Si elle est vraie, le code à l'intérieur des accolades {} est exécuté. Ce processus se répète jusqu'à ce que la condition devienne fausse.

Diagramme de Flux de la Boucle while en C

Pour visualiser comment fonctionne une boucle while, regardons un diagramme de flux :

┌─────────────┐
│   Début     │
└──────┬──────┘
│
▼
┌─────────────────┐
│ Vérifier la     │
│ condition       │
└────────┬────────┘
│
▼
┌───────────┐    Non
┌───┤ Condition ├────────┐
│   │   vraie ? │        │
│   └───────────┘        │
│         │ Oui          │
│         ▼              │
│  ┌──────────────┐      │
│  │ Exécuter le  │      │
│  │ code         │      │
│  └──────┬───────┘      │
│         │              │
└─────────┘              │
▼
┌──────────┐
│   Fin    │
└──────────┘

Ce diagramme de flux montre que la condition est vérifiée en premier. Si elle est vraie, le code est exécuté, puis nous retournons pour vérifier la condition à nouveau. Ce cycle continue jusqu'à ce que la condition devienne fausse.

Fonctionnement de la Boucle while en C

Décomposons le processus :

1. Le programme rencontre la boucle while.
2. Il vérifie la condition à l'intérieur des parenthèses.
3. Si la condition est vraie, il exécute le code à l'intérieur de la boucle.
4. Après avoir exécuté le code, il retourne à l'étape 2.
5. Si la condition est fausse, il saute la boucle et continue avec le reste du programme.

Exemple de Boucle while en C

Il est temps pour notre premier exemple ! Créons un simple programme de compte à rebours :

#include <stdio.h>

int main() {
int comptearebours = 5;

while (comptearebours > 0) {
printf("%d...\n", comptearebours);
comptearebours--;
}

printf("Décollage !\n");
return 0;
}

Sortie :

5...
4...
3...
2...
1...
Décollage !

Décomposons cela :

1. Nous démarçons avec comptearebours = 5.
2. La boucle while vérifie si comptearebours > 0 (ce qui est vrai).
3. Elle imprime la valeur actuelle du compte à rebours.
4. Nous décrémentons comptearebours de 1 en utilisant comptearebours--.
5. Les étapes 2-4 se répètent jusqu'à ce que comptearebours devienne 0.
6. Lorsque comptearebours est 0, la condition devient fausse, et nous quittons la boucle.
7. Enfin, nous imprimeons "Décollage !"

Utilisation de la Boucle while comme Boucle Conditionnelle

La boucle while est parfaite pour les situations où tu ne sais pas exactement combien de fois tu dois répéter quelque chose. Regardons un exemple où nous demandons à l'utilisateur de deviner un nombre :

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

int main() {
srand(time(0));  // Initialisation pour la génération de nombres aléatoires
int secret = rand() % 100 + 1;  // Nombre aléatoire entre 1 et 100
int guess = 0;
int tentatives = 0;

printf("Je pense à un nombre entre 1 et 100. Peux-tu le deviner ?\n");

while (guess != secret) {
printf("Entrez votre devinette : ");
scanf("%d", &guess);
tentatives++;

if (guess < secret) {
printf("Trop bas ! Essaye encore.\n");
} else if (guess > secret) {
printf("Trop haut ! Essaye encore.\n");
}
}

printf("Félicitations ! Tu as deviné le nombre en %d tentatives !\n", tentatives);
return 0;
}

Dans cet exemple, nous ne savons pas combien de tentatives l'utilisateur aura besoin, donc une boucle while est parfaite. La boucle continue tant que la devinette ne correspond pas au nombre secret.

Boucle while avec break et continue

Parfois, tu pourrais vouloir sortir d'une boucle tôt ou sauter à l'itération suivante. C'est là que break et continue deviennent utiles.

break

L'instruction break sort immédiatement de la boucle. Voici un exemple :

#include <stdio.h>

int main() {
int i = 1;
while (1) {  // Cela crée une boucle infinie
printf("%d ", i);
if (i == 5) {
break;  // Sort de la boucle lorsque i atteint 5
}
i++;
}
printf("\nFin de la boucle !\n");
return 0;
}

Sortie :

1 2 3 4 5
Fin de la boucle !

continue

L'instruction continue saute le reste de l'itération actuelle et passe à la suivante. Voici comment elle fonctionne :

#include <stdio.h>

int main() {
int i = 0;
while (i < 10) {
i++;
if (i % 2 == 0) {
continue;  // Saut les nombres pairs
}
printf("%d ", i);
}
printf("\nFin de la boucle !\n");
return 0;
}

Sortie :

1 3 5 7 9
Fin de la boucle !

Plus d'Exemples de Boucle while en C

Regardons quelques autres exemples pour solidifier notre compréhension :

Exemple 1 : Somme des Nombres

#include <stdio.h>

int main() {
int num, sum = 0;

printf("Entrez des nombres à additionner (entrez 0 pour finir):\n");

while (1) {
scanf("%d", &num);
if (num == 0) {
break;
}
sum += num;
}

printf("La somme est : %d\n", sum);
return 0;
}

Ce programme continue à additionner des nombres jusqu'à ce que l'utilisateur entre 0.

Exemple 2 : Suite de Fibonacci

#include <stdio.h>

int main() {
int n, premier = 0, second = 1, suivant;

printf("Entrez le nombre de termes de Fibonacci à générer : ");
scanf("%d", &n);

printf("Suite de Fibonacci :\n");

int i = 0;
while (i < n) {
if (i <= 1) {
suivant = i;
} else {
suivant = premier + second;
premier = second;
second = suivant;
}
printf("%d ", suivant);
i++;
}

printf("\n");
return 0;
}

Ce programme génère la suite de Fibonacci jusqu'à n termes.

Boucle while vs Boucles do while

Avant de conclure, comparons rapidement les boucles while avec leur cousin, la boucle do-while :

Fonctionnalité	Boucle while	Boucle do-while
Vérification de la Condition	Au début	À la fin
Exécutions Minimales	0 (si la condition est initialement fausse)	1 (toujours exécute au moins une fois)
Syntaxe	while (condition) { ... }	do { ... } while (condition);
Meilleur Cas d'Utilisation	Quand tu ne sais pas si tu as besoin d'exécuter la boucle	Quand tu sais que tu dois exécuter la boucle au moins une fois

La différence principale est que la boucle do-while vérifie la condition à la fin, ce qui garantit qu'elle exécute son code bloc au moins une fois.

Et voilà, mon apprenti codage ! Tu viens de déverrouiller la puissance des boucles while en C. souviens-toi, la pratique rend parfait, alors n'hésite pas à expérimenter avec ces concepts. Avant de t'en rendre compte, tu seras un as des boucles ! Bon codage ! ??

Credits: Image by storyset