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 (expr)
instruction_ou_bloc
évalue instruction_ou_bloc tant que l'évaluation de expr est non nulle.
do
instruction_ou_bloc
while (expr);
évalue instruction_ou_bloc tant que l'évaluation de expr est non nulle. L'évaluation de instruction_ou_bloc a lieu au moins une fois.
for (initialisations; expr; itérations)
    instruction_ou_bloc
évalue la ou les expressions d'initialisations, puis tant que l'évaluation de expr 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 (expr)
    {
        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. De toutes les formes présentées dans ce programme, la première avec for est la plus lisible et c'est donc elle qui doit être utilisée.

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 test_ligne.c (ligne.c , ligne.h).