Cours langage C: Les boucles

Facebook Tweet Pin Email

Les boucles :
Les boucles sont des structures qui permettent d’exécuter plusieurs fois la même série d’instructions jusqu’à ce qu’une condition ne soit plus réalisée… On appelle parfois ces structures instructions répétitives ou bien itérations.
La façon la plus commune de faire une boucle, est de créer un compteur (une variable qui s’incrémente, c’est-à-dire qui augmente de 1 à chaque tour de boucle) et de faire arrêter la boucle lorsque le compteur dépasse une certaine valeur.
La boucle for :
L’instruction for permet d’exécuter plusieurs fois la même série d’instructions: c’est une boucle!
Dans sa syntaxe, il suffit de préciser le nom de la variable qui sert de compteur (et éventuellement sa valeur de départ, la condition sur la variable pour laquelle la boucle s’arrête (basiquement une condition qui teste si la valeur du compteur dépasse une limite) et enfin une instruction qui incrémente (ou décrémente) le compteur.
La syntaxe de cette expression est la suivante:
for (compteur; condition; modification du compteur) { liste d’instructions }
Par exemple:
using System;
public class tp41
{
   Fichier « tp41.cs »
static void Main(string[] args)
{
   for (int i=1; i<6; i++) {
Console.WriteLine((char)i);
}
}
}
Cette boucle affiche 5 fois la valeur de i, c’est-à-dire 1,2,3,4,5. Elle commence à i=1, vérifie que i est bien inférieur à 6, etc… jusqu’à atteindre la valeur i=6, pour laquelle la condition ne sera plus réalisée, la boucle s’interrompra et le programme continuera son cours. Comme vous le voyez à l’écran, ce que je viens de vous expliquer ressemble à une blague…. A vous de corriger ;-)) D’autre part, C# autorise la déclaration de la variable de boucle dans l’instruction for elle-même!
L’instruction while :
L’instruction while représente un autre moyen d’exécuter plusieurs fois la même série d’instructions.
La syntaxe de cette expression est la suivante:
while (condition réalisée)
{
liste d’instructions
}
Cette instruction exécute la liste d’instructions tant que (while est un mot anglais qui signifie tant que) la condition est réalisée.
using System;
public class tp42
{
static void Main(string[] args)
{
Fichier « tp42.cs »
    t int fin=10;// ceci est une constante, mot clé const cons
int somme=0;
int i=0;
while (i<fin){
   somme=+i; //Pour rigoler essayez aussi somme+=i. Avez
vous une explication ?
   i++;
}
Console.WriteLine(« La somme vaut : »+somme);
}
}
L’instruction do/while :
A l’instar de la boucle while, la boucle do/while exécute une série d’instructions tant qu’une expression de contrôle est vrai. La grande différence tient au fait que la boucle while effectue la vérification avant le corps, alors que dans la boucle do/while la vérification s’effectue en fin de boucle. La conséquence est simple : avec la boucle while, le corps ne sera jamais exécuté si la condition est fausse au début de la première itération, alors qu’avec une boucle do/while vous êtes assuré que le corps sera exécuté au moins une fois. Dans l’exemple suivant, on lit une variable au clavier tant que la valeur de celle-ci n’est pas comprise dans un intervalle déterminé.
using System;
public class tp43
{
static void Main(string[] args)
{
int valeur;
const int valinf=5;
const int valsup=10;
do
{
Console.WriteLine(« Saisissez une valeur »);
valeur=System.Convert.ToInt32(System.Console.ReadLine());
}
while ((valeur<valinf)||(valeur>valsup));
}
}
Saut inconditionnel :
Il peut être nécessaire de faire sauter à la boucle une ou plusieurs valeurs sans pour autant mettre fin à celle-ci.
La syntaxe de cette expression est « continue; » (cette instruction se place dans une boucle ! ), on l’associe généralement à une structure conditionnelle, sinon les lignes situées entre cette instruction et la fin de la boucle seraient obsolètes.
Exemple: Imaginons que l’on veuille imprimer pour x allant de 1 à 10 la valeur de 1/(x-7) … il est évident que pour x=7 il y aura une erreur. Heureusement, grâce à l’instruction continue il est possible de traiter cette valeur à part puis de continuer la boucle!