**Structures répétitives**
Leçon : Introduction au langage C

Chapitre n^o 8
Chap. préc. :	Structures conditionnelles
Chap. suiv. :	Pointeurs

En raison de limitations techniques, la typographie souhaitable du titre, « Introduction au langage C : Structures répétitives
Introduction au langage C/Structures répétitives », n'a pu être restituée correctement ci-dessus.

Introduction aux structures répétitives

Les structures répétitives, ou les boucles, servent comme leur nom l'indique à "répéter" un certain nombre de fois une instruction ou un bloc d'instructions. (Un bloc d'instructions est une série d'instructions qui se suivent et qui sont délimitées par des accolades "{ }")

Itération : Un cycle d’un processus répétitif.

Conseils de codage à respecter : c_lis_13, c_lis_14, c_rec_2, c_rec_3, c_rec_11, c_rob_2.

Voir aussi les structures répétitives dans le WikiLivre Programmation C, chapitre Itérations.

Types de boucle

Il existe trois grands types de structures répétitives qui se retrouve dans quasiment tous les langages de programmation. Chaque structure peut renvoyer le même résultat avec quelques astuces que nous ne détaillerons pas ici.

La boucle for

Description

La particularité de la boucle for est que lors de son écriture, elle centralise dans une seule instruction 3 éléments qui sont utilisés dans la plupart des boucles.

L'instruction for obéit aux syntaxes suivantes :

Pour n'exécuter qu'une seule instruction dans le corps de la boucle :
for (expr₁; expr₂; expr₃) instruction
Pour exécuter un bloc d'instruction dans le corps de la boucle :
for (expr₁; expr₂; expr₃)
{
suite d'instructions
}
expr₁ est habituellement une initialisation de variable.
Le standard C99 permet de déclarer ces variables ici et de les rendre ainsi visibles seulement dans la boucle ;
expr₂ est la condition qui permet d'entrer dans la boucle et maintient cette dernière active, habituellement une expression logique. À chaque itération la condition est évaluée. Tant que celle-ci est vrai la boucle est répétée une nouvelle fois ;
expr₃ est habituellement l'incrémentation ou la décrémentation d'une ou de plusieurs variables.

Exemple

Un exemple en C99 d'une boucle qui affiche les nombres entiers de 0 à 2 :

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

Affichera

i = 0
i = 1
i = 2

Remarques

expr₁, expr₂, ou expr₃ sont facultatifs.
Si expr₂ est omis, la condition est considérée comme toujours vraie.
expr₁ et expr₃ peuvent être constituées par une suite d'instructions C, séparées par des , (virgules).
Cette structure permet de concentrer sur une ligne toutes les conditions de contrôle d'une boucle : initialisations, test d'entrée, opérations pour passer à l'itération suivante.
La déclaration des variables de contrôle de la boucle dans l'instruction for (introduite par C99), permet de limiter la portée de ces variables au seul corps de boucle et permet d’éviter les erreurs dues aux effets de bord.

La boucle while

Description

La boucle while, comme la boucle for, permet de répéter une instruction ou une suite d'instructions. Seul le test d'entrée en début d'itération est défini dans l'instruction while. En français while se traduit par tant que : la boucle s'exécute tant que la condition est vraie.

Une boucle while (tant que) obéit au format suivant :

Pour n'exécuter qu'une seule instruction dans le corps de la boucle :
while ( expression ) instruction
Pour exécuter un bloc d'instruction dans le corps de la boucle :
while ( expression )
{
suite d'instructions
}
Expression est évaluée à l'exécution du programme ;
si elle est vraie (différente de zéro), le corps de la boucle (instruction ou bloc), est exécuté ;
expression est évaluée à nouveau et si elle est vraie, le corps de boucle est exécuté à nouveau ;
l'exécution ne s'arrêtera que si expression est fausse (zéro). Le programme exécutera alors l'instruction située après le corps de boucle.

Exemple simple

int i = 0;
while(i < 3)
{
    (void)printf("i = %d\n",i);
    i++;
}

Affichera

i = 0
i = 1
i = 2

La boucle Do While

Description

Cette instruction do ... while se traduit en français par répéter ... tant que. le bloc d'instruction s'exécutera au moins une fois, même si la condition est toujours fausse. L'instruction ou le bloc d'instructions sont exécutés de façon répétitives tant que le test est vrai.

Voici ses formats :

Pour exécuter un corps de boucle ne contenant qu'une seule instruction :
do instruction while ( expression ) ;
Pour exécuter un corps de la boucle contenant un bloc d'instruction :
do
{
suite d'instructions
} while ( expression ) ;

Exemple

Le programme do.c suivant contient une boucle do ... while qui va lire les lettres tapées par l'utilisateur jusqu'à ce qu’il entre la lettre 'q' ou 'Q'.

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

int main(void)
{	
	char str[_POSIX_MAX_INPUT];
	do
	{
		(void)printf("Presser 'q' suivi de la touche entree pour arreter : ");
		(void)scanf("%s", str);
	} while ( str[0] != 'q' && str[0] != 'Q' );

	(void)printf("Bravo, vous avez entre %c !\n", str[0]);
	return EXIT_SUCCESS;
}

MacMini-TM:~/Documents/developpement/c thierry$ gcc -Wall -o do.exe do.c
MacMini-TM:~/Documents/developpement/c thierry$ ./do.exe
Presser 'q' suivi de la touche entree pour arreter : a
Presser 'q' suivi de la touche entree pour arreter : Q
Bravo, vous avez entre Q !
MacMini-TM:~/Documents/developpement/c thierry$

Remarques

Le do ... while est la seule structure répétitive qui nécessite un point virgule a la fin.

Supplément

Remarques qualité

Les constructions ci-dessous sont sources d'erreurs.
Il est déconseillé de sortir d'une structure itérative dans le corps de boucle. La sortie doit se faire par la condition de test de la boucle, ce qui facilite la mise au point des programmes.
Les boucles infinies nécessitent de faire appel à ces mécanismes douteux et sont donc déconseillées.
Les boucles avec des tests d'égalité de nombres réels sont déconseillés, possibilité d'erreurs d'arrondis.

Instruction continue (déconseillée)

On peut à tout moment passer à l'itération suivante sans finir celle en cours.

int i;
for (i = 0; i < 5 ; ++i)
{
  if(i % 2) continue;  // ⟺ if((i % 2) != 0) continue;
  (void)printf("Iteration n ° %d\n",i);
}

Affichera

Iteration n ° 0
Iteration n ° 2
Iteration n ° 4

Instruction break (déconseillée)

Il existe la possibilité d'arrêter une boucle en cours d'exécution avec l'instruction break;

for (int i = 0; i < 10 ; ++i)
{
  (void)printf("Iteration n ° %d\n",i+1);
  if(i == 3) break;
}

Affichera

Iteration n ° 1
Iteration n ° 2
Iteration n ° 3

Les boucles infinies (déconseillées)

Il est important de vérifier si aucune boucle n'est infinie; c'est-à-dire une boucle où la condition est toujours évaluée à vrai. Ce type de boucle bloquera votre programme. Tout ce qui suit ce type de boucle ne sera jamais exécuté. L'instruction break permet d’en sortir.

Exemple de boucles infinies (déconseillés) :

for (;;)
for (i=0;i<10;--i)

i=0;
while ( i != 10 ) i += 3; // Souvent un probleme

while (true) // true est defini dans stdbool.h en C99

while (1)

TP

Faîtes les exercices du WikiLivre Exercices en langage C sur les structures de répétitives.

Introduction au langage C

Structures conditionnelles

Pointeurs