Après avoir précisé la notion d'instruction, nous décrivons les différentes structures de contrôle disponibles en C. Ces structures permettent de contrôler l'ordre dans lequel seront effectuées les instructions.
Le caractère ; termine une instruction. N'importe
quelle expression devient une instruction simple dès qu'elle
est suivie d'un point-virgule.
Les accolades permettent de regrouper une suite de plusieurs instructions (simples ou composées) en une seule instruction composée (ou bloc).
Il est possible de déclarer ou de définir des variables au début de chaque bloc. Ces variables n'existeront que dans ce bloc.
Voici trois exemples d'instructions simples valides qui sont réunies en une instruction composée (ou bloc):
{
a = 1;
x++;
f(x);
}
while
Il y a deux utilisations possibles du while .
La première utilisation évalue une condition puis exécute l'instruction (simple ou composée) qui suit si la condition est vraie. Cette boucle continue tant que la condition reste vraie. Le premier exemple l'illustre avec une instruction simple tandis que le second utilise une instruction composée.
while (condition)
instruction
while (condition) {
instruction 1
...
instruction n
}
La seconde utilisation exécute tout d'abord l'instruction (simple ou composée). Puis la condition est évaluée et, tant qu'elle reste vraie, l'instruction est exécutée à nouveau. Les deux exemples suivants l'illustrent avec une instruction simple et une instruction composée.
do
instruction
while (condition);
do {
instruction 1
...
instruction n
} while (condition);
for
Le mot-clé for permet lui aussi d'effectuer des boucles. Il
pourrait ne pas exister puisqu'on peut le simuler avec
while . Ainsi :
for (expr1; expr2; expr3) {
instruction 1
...
instruction n
}
est équivalent à :
expr1;
while (expr2) {
instruction 1
...
instruction n
expr3;
}
La première expression expr1 est l'expression d'initialisation. La seconde expression expr2 est le test de continuation. La troisième expression expr3 est appelée expression d'incrémentation.
Une utilisation classique d'une boucle for est le
parcours d'un tableau :
int Tab[10], i;
for (i = 0; i < 10; i++) {
/* manipulation du ieme element */
Tab[i] = ...
...
}
Dans un for , chacune des trois expressions peut-être absente
par contre il faut conserver les points-virgules. Si une
expression n'est pas présente tout se passe comme si elle
n'existait pas (en particulier, la seconde expression est
considérée comme vraie si elle n'existe pas). On peut donc
écrire une boucle infinie de la manière suivante :
for (;;) {
instruction 1
...
instruction n
}
Il existe deux instructions particulières pour contrôler l'exécution d'une boucle.
L'instruction break permet de quitter immédiatement
l'exécution d'une boucle (par exemple une boucle infinie).
L'instruction continue permet de passer immédiatement
au test suivant (sauf dans le cas du for où l'expression
expr3 est tout de même évaluée).
L'utilisation des ces deux instructions dans le cadre d'une programmation structurée est déconseillée sauf lorsque cela augmente la lisibilité du programme.
if
Le mot-clé if permet d'effectuer une instruction (simple ou
composée) de manière conditionnelle. Il peut être suivi du
mot-clé else pour spécifier l'instruction à effectuer
lorsque la condition est fausse.
if (condition) {
/* si la condition est vraie */
instruction 1
...
instruction n
}
if (condition) {
/* si la condition est vraie */
instruction 1
...
instruction n
} else {
/* si la condition est fausse */
instruction 1
...
instruction n
}
Il est possible d'enchaîner plusieurs tests successifs grâce à
else if :
if (condition1)
/* si condition1 est vraie */
instruction
else if (condition2)
/* si condition1 est fausse et condition2 est vraie */
instruction
else
/* si les deux conditions sont fausses */
instruction
Le mot-clé switch permet d'effectuer un choix selon les
valeurs possibles d'une expression. On sélectionne une valeur
particulière en la faisant précéder du mot-clé case . Le
mot-clé default permet de spécifier le comportement par
défaut (c'est à dire lorsqu'aucune des valeurs spécifiées n'est
la bonne).
switch (expression) {
case Constante1 :
/* si expression est egale a Constante1 */
instruction 1
...
instruction n
break;
case Constante2 :
/* si expression est egale a Constante2 */
instruction 1
...
instruction n
break;
...
default :
/* cas par defaut */
instruction 1
...
instruction n
break;
}
Attention: n'oubliez pas le break entre chaque cas
sinon l'exécution continue sur le cas suivant. Ceci permet de
spécifier plusieurs valeurs pour une même série
d'instructions.
Dans l'exemple suivant, les valeurs 1, 2 et 3 déclenchent le même traitement. La valeur 4 est traitée séparément :
switch (a) {
case 1 :
case 2 :
case 3 :
b = 100;
break;
case 4 :
b = 200;
break;
default :
b = 0;
break;
}