• 10 heures
  • Moyenne

Ce cours est visible gratuitement en ligne.

course.header.alt.is_video

Ce cours existe en livre papier.

course.header.alt.is_certifying

J'ai tout compris !

Mis à jour le 25/01/2022

Répétez des instructions grâce aux boucles

Connectez-vous ou inscrivez-vous gratuitement pour bénéficier de toutes les fonctionnalités de ce cours !

Comme pour les conditions, il y a plusieurs façons de réaliser des boucles. Nous allons voir trois types de boucles courantes en C :

  1. while

  2. do… while

  3. for

Dans tous les cas, le principe est le même :

Schéma d'une boucle
Schéma d'une boucle

Voici ce qu'il se passe, dans l'ordre :

  1. L'ordinateur lit les instructions de haut en bas (comme d'habitude).

  2. Puis, une fois arrivé à la fin de la boucle, il repart à la première instruction.

  3. Il recommence alors à lire les instructions de haut en bas…

  4. … Et il repart au début de la boucle.

Et c'est là qu'on retrouve… les conditions !

Comme je vous l'ai dit, il y a plusieurs manières de s'y prendre. Voyons voir sans plus tarder comment on réalise une boucle de type while en C.

Créez un boucle  while

Voici comment on construit une boucle while  :

while (/* Condition */)
{
// Instructions à répéter
}

Faisons un test simple : on va demander à l'utilisateur de taper le nombre 47. Tant qu'il n'a pas tapé le nombre 47, on lui redemande le nombre. Le programme ne pourra s'arrêter que si l'utilisateur tape le nombre 47 (je sais, je sais, je suis diabolique) :

int nombreEntre = 0;
while (nombreEntre != 47)
{
printf("Tapez le nombre 47 ! ");
scanf("%d", &nombreEntre);
}

Voici maintenant le test que j'ai fait (j'ai fait exprès de me tromper 2-3 fois avant de taper le bon nombre) :

Tapez le nombre 47 ! 10
Tapez le nombre 47 ! 27
Tapez le nombre 47 ! 40
Tapez le nombre 47 ! 47

Cette boucle while se répète donc tant qu'on n'a pas tapé 47.

Maintenant, essayons quelque chose de plus intéressant : on veut que notre boucle se répète un certain nombre de fois. On va pour cela créer une variable compteur qui vaudra 0 au début du programme et que l'on va incrémenter au fur et à mesure.

C'est quoi déjà, l'incrémentation ?

Ça consiste à ajouter 1 à la variable en faisant variable++;.

Regardez attentivement ce bout de code et, surtout, essayez de le comprendre :

int compteur = 0;
while (compteur < 10)
{
printf("Bienvenue sur OpenClassrooms !\n");
compteur++;
}

Résultat :

Bienvenue sur OpenClassrooms !
Bienvenue sur OpenClassrooms !
Bienvenue sur OpenClassrooms !
Bienvenue sur OpenClassrooms !
Bienvenue sur OpenClassrooms !
Bienvenue sur OpenClassrooms !
Bienvenue sur OpenClassrooms !
Bienvenue sur OpenClassrooms !
Bienvenue sur OpenClassrooms !
Bienvenue sur OpenClassrooms !

Ce code répète 10 fois l'affichage de "Bienvenue sur OpenClassrooms !".

Comment ça marche exactement ?

  1. Au départ, on a une variable compteur initialisée à 0. Elle vaut donc 0 au début du programme.

  2. La boucle while ordonne la répétition TANT QUE compteur est inférieur à 10. Comme compteur vaut 0 au départ, on rentre dans la boucle.

  3. On affiche la phrase « Bienvenue sur OpenClassrooms ! » via un printf.

  4. Grâce à compteur++; , on incrémente la valeur de la variable compteur (qui valait 0, elle vaut maintenant 1).

  5. On arrive à la fin de la boucle (accolade fermante) : on repart donc au début, au niveau du while pour refaire le test : « Est-ce que compteur est toujours inférieure à 10 ? ». Oui car compteur vaut 1. On recommence donc les instructions de la boucle.

  6. Et ainsi de suite : compteur va valoir progressivement 0, 1, 2, 3… 8, 9, et 10. Lorsque compteur vaut 10, la condition compteur < 10est fausse. Comme l'instruction est fausse, on sort de la boucle.

On pourrait d'ailleurs voir que la variable compteur augmente au fur et à mesure dans la boucle, en l'affichant dans le printf:

int compteur = 0;
while (compteur < 10)
{
printf("La variable compteur vaut %d\n", compteur);
compteur++;
}
La variable compteur vaut 0
La variable compteur vaut 1
La variable compteur vaut 2
La variable compteur vaut 3
La variable compteur vaut 4
La variable compteur vaut 5
La variable compteur vaut 6
La variable compteur vaut 7
La variable compteur vaut 8
La variable compteur vaut 9

Voilà : si vous avez compris ça, vous avez tout compris !

Vous pouvez vous amuser à augmenter la limite du nombre de boucles : < 100  au lieu de < 10. Cela m'aurait été d'ailleurs utile plus jeune pour rédiger les punitions que je devais réécrire 100 fois.

Voici un exemple de boucle infinie :

while (1)
{
printf("Boucle infinie\n");
}

Souvenez-vous des booléens : 1 = vrai, 0 = faux. Ici, la condition est toujours vraie, ce programme affichera donc « Boucle infinie » sans arrêt !

Que faire si on a lancé une boucle infinie par erreur ?

Nous allons voir dans la vidéo suivante comment créer votre première boucle while en faisant attention à ne pas tomber dans le piège de la boucle infinie :

Créez une boucle  do… while

Ce type de boucle est moins utilisé. La seule chose qui change par rapport à une boucle while  , c'est la position de la condition : au lieu d'être au début de la boucle, la condition est à la fin :

int compteur = 0;
do
{
printf("Bienvenue sur OpenClassrooms !\n");
compteur++;
} while (compteur < 10);

Qu'est-ce que ça change ?

Il est donc parfois utile de faire des boucles de ce type, pour s'assurer que l'on rentre au moins une fois dans la boucle.

La vidéo montre la différence entre la boucle while et la boucle do...while :

Créez une boucle  for

En théorie, while permet de réaliser toutes les boucles que l'on veut.

Toutefois, comme switch pour les conditions, il est parfois utile d'avoir un autre système de boucle, plus « condensé », plus rapide à écrire. Pour cela, on a les boucles  for  .

Pour rappel, voici un exemple de boucle while que nous avons vu tout à l'heure :

int compteur = 0;
while (compteur < 10)
{
printf("Bienvenue sur OpenClassrooms !\n");
compteur++;
}

Voici maintenant l'équivalent en boucle for :

int compteur;
for (compteur = 0 ; compteur < 10 ; compteur++)
{
printf("Bienvenue sur OpenClassrooms !\n");
}

Quelles différences y a-t-il ?

  • On n'a pas initialisé la variable compteur à 0 dès sa déclaration (mais on aurait pu le faire).

  • Il y a beaucoup de choses entre les parenthèses après for  (nous allons détailler ça après).

  • Il n'y a plus de compteur++;  dans la boucle.

Intéressons-nous à ce qui se trouve entre les parenthèses, car c'est là que réside tout l'intérêt de la boucle for : il y a trois instructions condensées, séparées par un point-virgule :

  1. L'initialisation : cette première instruction est utilisée pour préparer notre variable compteur. Dans notre cas, on initialise la variable à 0.

  2. La condition : comme pour la boucle while, c'est la condition qui dit si la boucle doit être répétée ou non. Tant que la condition est vraie, la boucle for continue.

  3. L'incrémentation : cette dernière instruction est exécutée à la fin de chaque tour de boucle pour mettre à jour la variable compteur. La plupart du temps, on fera une incrémentation, mais on peut aussi faire une décrémentation (variable--), ou encore n'importe quelle autre opération (variable += 2; pour avancer de 2 en 2, par exemple).

Bref ! for n'est rien d'autre qu'un condensé. 

Pour terminer ce chapitre, je vous propose une dernière vidéo qui montre comment utiliser une boucle  for   , et les erreurs à éviter :

En résumé

  • Les boucles sont des structures qui nous permettent de répéter une série d'instructions plusieurs fois.

  • Il existe plusieurs types de boucles : whiledo… while et for. Certaines sont plus adaptées que d'autres selon les cas.

  • for est probablement celle qu'on utilise le plus. On y fait très souvent des incrémentations ou des décrémentations de variables.

Vous êtes maintenant au point avec l’ensemble des concepts de base du langage. Voyons maintenant une notion très importante de la programmation. Comment créer une fonction ?

Exemple de certificat de réussite
Exemple de certificat de réussite