suivant: 7. Préprocesseur monter: 6. Instructions précédent: 6.1 Instructions élémentaires Table des matières
Les structures de contröle sont les tests, les boucles et l'aiguillage.
if (expression)
partie-alors
[else
partie-sinon]
La partie-alors et la partie-sinon peuvent être indifféremment une instruction élémentaire ou composée.
La partie-alors sera exécutée si la valeur de l'expression entre parenthèses est non nulle. Sinon, si le test comporte une partie-sinon c'est celle-ci qui sera exécutée.
Si plusieurs tests sont imbriqués, chaque partie-sinon est reliée au if le plus proche qui n'est pas déjà associé à une partie-sinon.
Exemple
if (x > 0) if (x > 0)
ecrire("positif"); ecrire("positif");
else if (x < 0) <==> else
ecrire("négatif"); {
else if (x < 0)
ecrire("nul"); ecrire("négatif");
else
ecrire("nul");
}
while (expression)
corps-de-boucle
do
corps-de-boucle
while (expression);
La partie corps-de-boucle peut être soit une instruction élémentaire soit une instruction composée.
Dans la boucle while le test de continuation s'effectue avant d'entamer le corps-de-boucle qui, de ce fait, peut ne jamais s'exécuter.
Par contre dans la boucle do-while ce test est effectué après le corps-de-boucle, lequel sera alors exécuté au moins une fois.
Exemple
#include <stdio.h>
main()
{
int chiffre = 0;
printf("Boucle \"while\"\n\n");
while (chiffre) {
printf(" %d", chiffre++);
if (!(chiffre%5))
printf("\n");
}
printf("Boucle \"do-while\"\n\n");
do {
printf(" %3d", ++chiffre);
if (!(chiffre%5))
printf("\n");
if (chiffre == 100)
chiffre = 0;
}
while (chiffre);
}
for ([expr1]; [expr2]; [expr3])
corps-de-boucle
L'expression expr1 est évaluée une seule fois, au début de l'exécution de la boucle.
L'expression expr2 est évaluée et testée avant chaque passage dans la boucle.
L'expression expr3 est évaluée après chaque passage.
Ces 3 expressions jouent respectivement le röle :
main()
{
int tab[] = {1, 2, 9, 10, 7, 8, 11};
int i, j;
char buffer[] = "Voici une chaine"
" qui se termine "
"par un blanc ";
char *p;
int t[4][3];
for (i=0; i < sizeof tab / sizeof tab[0]; i++)
printf("tab[%d] = %d\n", i, tab[i]);
for (p=buffer; *p; p++) ;
*--p = '\0';
printf("buffer : %s$\n", buffer);
for (i=0; i < 4; i++)
for (j=0; j < 3; j++)
t[i][j] = i + j;
}
L'instruction switch définit un aiguillage qui permet d'effectuer un branchement à une étiquette de cas en fonction de la valeur d'une expression.
Syntaxe
switch (expression)
{
case etiq1 :
[ liste d'instructions ]
case etiq2 :
[ liste d'instructions ]
...
case etiqn :
[ liste d'instructions ]
[ default:
[ liste d'instructions ]]
}
Les étiquettes de cas (etiq1, etiq2, ..., etiqn) doivent être des expressions constantes.
Une fois le branchement à l'étiquette de cas correspondante effectué, l'exécution se poursuit, par défaut, jusqu'à la fin du bloc switch. L'instruction d'échappement break; permet de forcer la sortie du bloc.
L'expression indiquée au niveau du switch doit être de type entier.
Exemple
#include <stdio.h>
main()
{
char *buffer = "\nCeci est une chaine\n"
"de caracteres\tsur\n\n"
"plusieurs lignes.\n";
int NbCar = 0, NbEsp = 0, NbLignes = 0;
for (; *buffer; buffer++, NbCar++)
switch (*buffer) {
case '\n': NbLignes++;
break;
case '\t':
case ' ' : NbEsp++;
default : break;
}
printf("NbCar = %d, NbEsp = %d, NbLignes = %d\n",
NbCar, NbEsp, NbLignes);
}
Ces instructions permettent de rompre le déroulement séquentiel d'une suite d'instructions.
Le röle de l'instruction continue; est de forcer le passage à l'itération suivante de la boucle la plus proche.
Exemple
#include <stdio.h>
main()
{
char *buffer = "\nCeci est une chaine\n"
"de caracteres\tsur\n\n"
"plusieurs lignes.\n";
int NbCar = 0, NbEsp = 0, NbLignes = 0;
for (; *buffer; buffer++) {
switch (*buffer) {
case '\n': NbLignes++;
break;
case '\t': continue;
case ' ' : NbEsp++;
default : break;
}
NbCar++;
}
printf("NbCar = %d, NbEsp = %d, NbLignes = %d\n",
NbCar, NbEsp, NbLignes);
}
L'instruction break; permet de quitter la boucle ou l'aiguillage le plus proche.
Exemple
#include <stdio.h>
main()
{
char buffer[] = "Wolfgang Amadeus Mozart\n"
" est un musicien divin.\n";
char *p;
for (p=buffer; *p; p++)
if (*p == '\n')
{
*p = '\0';
break;
}
printf("Nom : %s\n", buffer);
}
Syntaxe
return [expression];
Cette instruction permet de sortir de la fonction qui la contient :
#include <stdio.h>
void main()
{
char c;
char majus(char c);
printf("%c\n", majus(c));
return;
}
char majus(char c)
{ return c >= 'a' && c <= 'z' ? c + 'A' - 'a' : c; }
Cette instruction sert à effectuer un transfert inconditionnel vers une autre partie du programme.
Syntaxe
goto etiquette;
Etiquette fait référence à une instruction étiquetée. On utilisera cette instruction avec parcimonie car elle nuit à l'écriture de programme structuré. Elle peut à la rigueur être utilisée lorsque l'on désire sortir de plusieurs boucles imbriquées, ce que ne permet pas l'instruction break;.
Exemple
#include <stdio.h>
main()
{
int tab[][4] = {1, 2, 8, 9, 10, 12, 1, 9, 5};
int i, j;
for (i=0; i < sizeof tab / sizeof tab[0]; i++)
for (j=0; j < 4; j++)
if (tab[i][j] == 10)
goto trouve;
fprintf(stderr, "Elément non trouvé.\n");
return 1;
trouve:
printf("L'élément tab[%d][%d]"
" est égal à 10.\n", i, j);
}
Un programme peut être interrompu au moyen de la fonction exit.
Syntaxe
exit(expression);
L'argument de cette fonction doit être un entier indiquant le code de terminaison du processus.
Exemple
#include <stdio.h>
main()
{
int tab[][4] = {1, 2, 8, 9, 10, 12, 1, 9, 5};
int i, j;
for (i=0; i < sizeof tab / sizeof tab[0]; i++)
for (j=0; j < 4; j++)
if (tab[i][j] == 10) {
printf("L'élément tab[%d][%d]"
" est égal à 10.\n", i, j);
return 0;
}
fprintf(stderr, "Elément non trouvé.\n");
exit(1);
}