# 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.

# 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 :
Affichera

### 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

Affichera

## 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'.

### 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.
Affichera

### Instruction break (déconseillée)

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

### 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) :

## TP

| Structures conditionnelles | Pointeurs |