« Introduction au langage C/Structures répétitives » : différence entre les versions

Une page de Wikiversité, la communauté pédagogique libre.
Contenu supprimé Contenu ajouté
m Bot : Remplacement de texte automatisé (-<br/> +<br />); changement de type cosmétique
Thierry46 (discussion | contributions)
Ligne 5 : Ligne 5 :


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

[[b:Conseils de codage en C/Lisibilité des sources|c_lis_13]], [[b:Conseils de codage en C/Lisibilité des sources|c_lis_14]], [[b:Conseils de codage en C/Recherche des erreurs#Sortie de boucle (c_rec_2)|c_rec_2]], [[b:Conseils de codage en C/Recherche des erreurs#for pour contrôler les boucles (c_rec_3)|c_rec_3]], [[b:Conseils de codage en C/Recherche des erreurs#Les variables ne doivent pas se masquer (c_rec_11)|c_rec_11]], [[b:Conseils de codage en C/Robustesse des programmes#switch et clause default (c_rob_2)|c_rob_2]].


{{loupe|amorce=Voir aussi les structures répétitives dans le WikiLivre |b:Programmation C/Itérations{{!}}Programmation C, chapitre Itérations}}
{{loupe|amorce=Voir aussi les structures répétitives dans le WikiLivre |b:Programmation C/Itérations{{!}}Programmation C, chapitre Itérations}}

Version du 27 juin 2008 à 19:58

Début de la boite de navigation du chapitre
Structures répétitives
Icône de la faculté
Chapitre no {{{numéro}}}
Leçon : Langage C
Chap. préc. :Structures conditionnelles
Chap. suiv. :Pointeurs
fin de la boite de navigation du chapitre
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.

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 tout 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 :<br\>

for (expr1; expr2; expr3) instruction

  • Pour exécuter un bloc d'instruction dans le corps de la boucle :<br\>

for (expr1; expr2; expr3)<br\> {<br\> suite d'instructions<br\> }

  • expr1 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;
  • expr2 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.;
  • expr3 est habituellement l'incrémentation ou la décrementation d'une ou de plusieurs variables

Exemple

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

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

Affichera

i = 0
i = 1
i = 2

Remarques

  • expr1, expr2, ou expr3 sont facultatifs.
  • Si expr2 est omis, la condition est considérée comme toujours vraie.
  • expr1 et expr3 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 francais 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 :<br\>

while ( expression ) statement

  • Pour exécuter un bloc d'instruction dans le corps de la boucle :<br\>

while ( expression )<br\> {<br\> suite d'instructions<br\> }

  • 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 evaluaée a 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 dons déconseillées.
  • Les boucles avec des test 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.

for (int 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 à faux. Ce type de boucle bloquera votre programme. Tout ce qui suit ce type de boucle ne sera jamais exécuter. L'instruction break permet d'en sortir.

Exemple de boucle infinie (déconseillée) :

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