Instructions simples
Une instruction simple est une expression ou une suite d'expressions
(séparées par des virgules) suivie d'un point-virgule.
f(3);
i = 4;
j = i + 5;
3 * 4; // instruction stupide !
; // instruction vide
i = 3, j = 4; // à éviter !
Bloc
Un bloc est un ensemble d'instructions entre accolades.
Test
- if (expr)
instruction_ou_bloc
exécute instruction_ou_bloc
si l'évaluation de expr
renvoie une valeur non nulle.
- if (expr_1)
instruction_ou_bloc_1
else if (expr_2)
instruction_ou_bloc_2
...
else if (expr_k)
instruction_ou_bloc_k
else
instruction_ou_bloc_k+1
exécute instruction_ou_bloc_i
si l'évaluation de expr_i
renvoie une valeur non nulle et toutes les évaluations de expr_j pour j allant de 1 à i-1 sont nulles.
Itération
- while (test)
instruction_ou_bloc
évalue instruction_ou_bloc
tant que l'évaluation de test
est non nulle.
- do
instruction_ou_bloc
while (test);
évalue instruction_ou_bloc
tant que l'évaluation de test
est non nulle. L'évaluation de instruction_ou_bloc a lieu au
moins une fois.
- for (initialisations; test; itérations)
instruction_ou_bloc
évalue la ou les expressions d'initialisations, puis tant que
l'évaluation de test
renvoie une valeur non nulle, évalue instruction_ou_bloc puis la ou
les expressions d'itérations.
Si initialisations ou itérations
possèdent plusieurs expressions, celles-ci sont
séparées par des virgules.
Cette boucle est équivalente à
initialisations;
while (test)
{
instruction_ou_bloc
itérations;
}
Saut
- break / continue
Une instruction break
permet de sortir d'une boucle alors que l'instruction continue fait passer
directement à l'itération suivante.
Par exemple :
for (i = 0; i < n; i++)
{
if (i % 2)
continue; // on saute les itérations impaires.
...
}
est équivalent à
for (i = 0; i < n; i += 2)
// i est incrémentée de 2 en 2
{
...
}
- goto
permet un branchement direct sur une étiquette. A
utiliser avec parcimonie, pour que cela ne nuise pas à la
lisibilité. Un usage typique est un branchement sur une
étiquette "erreur" où un traitement est effectué
avant une sortie avec message d'erreur.
Des exemples de
boucles équivalentes sont données dans boucles.c.
Aiguillage
switch (expr)
{
case (constante1) :
instruction_ou_bloc_1
case (constante2) :
instruction_ou_bloc_2
...
case (constante_k) :
instruction_ou_bloc_k
default :
instruction_ou_bloc_default
}
Si
constante_i est non nulle,
exécute
les instruction_ou_bloc_j
pour tout j supérieur ou égal à i, ainsi que instruction_ou_bloc_default si
l'étiquette default
est présente. L'utilisation de break permet de rendre les cas
exclusifs. Voir main.c.