Date et heure de la dernière modification
3. Bases du langage C
3.12 Structure de choix : l’instruction switch
Nous avons vu précédemment qu’il était possible d’utiliser des instructions if pour réaliser un choix multiple (on parle d’un aiguillage). Il existe en C une instruction spécialisée pour cela, le switch. Le programme suivant en donne un exemple.
main() {
int n;
printf("Donnez un nombre entier : ");
scanf("%d", &n);
switch (n) {
case 0 : printf("nul\n");
break ;
case 1 : printf("un\n");
break ;
case 2 : printf("deux\n");
break ;
}
printf("au revoir\n");
}
Ce programme évalue la valeur de l’expression entière se trouvant entre parenthèses après le switch (ici, n). Ensuite, il recherche la branche case qui correspond à cette valeur et exécute la liste d’instructions se trouvant dans cette branche ainsi que toutes les autres branches case se trouvant en dessous. Dans notre exemple, l’instruction break est obligatoire afin de sortir du switch après traitement de la branche correspondant à la valeur de n.
Exercice 3.14 : dans le programme précédent, supprimez le break de la branche case 0.
On entre la valeur 0. Que se passe-t-il ?
Il est possible de définir une branche par défaut pour traiter le cas où la valeur de n serait différente des valeurs testées dans les instructions case. C’est l’étiquette default.
Exemple : main() {
int n;
printf("Donnez un nombre entier positif : ");
scanf("%d", &n);
switch (n) {
case 0 : printf("nul\n");
break ;
case 1 : printf("un\n");
break ;
case 2 : printf("deux\n");
break ;
default : printf("trop grand\n");
}
printf("au revoir\n");
}
Si n est différent de 0, 1 ou 2, c’est la branche default qui est utilisée. Les instructions après un case ne sont pas obligatoires pas plus que le break. Vous pouvez écrire :
switch (n) {
case 0 : printf("nul\n");
break ; case 1 :
case 2 : printf("deux\n");
default : printf("grand\n");
}
La syntaxe générale du switch est : switch (expression) {
case constante_1 : [suite_instructions_1]
case constante_2 : [suite_instructions_2]
case constante_3 : [suite_instructions_3]
[default : suite_instructions_4]
}
Où ce qui est entre crochets est facultatif et :
• expression est une expression entière quelconque (int ou char),
• constante est une expression constante d’un type entier quelconque (int ou char),
• suite_instructions est une suite d’instructions quelconques.
Ainsi le switch peut être utilisé pour traiter des caractères : switch (n) {
case ‘a’ : ...
case ‘X’ : ...
}
3.13 Structure de répétition conditionnelle : l’instruction do... while
Les structures de répétition (on parle aussi de boucles) permettent d’exécuter à plusieurs reprises une suite d’instructions. Dans une structure de répétition conditionnelle, la poursuite de la répétition dépend d’une condition. L’instruction do ... while() permet d’effectuer une répétition dans un programme comme le montre l’exemple suivant :
main() {
int n;
do {
printf("Donnez un nombre entier : ");
scanf("%d", &n);
printf("voici son carré : %d\n", n*n);
}
while (n != 0);
printf("Fin du programme\n ");
}
Elle signifie « exécuter le bloc d’instructions entre {} tant que n est différent de 0 ». La condition entre parenthèse après le while est donc une condition de poursuite et non une condition d’arrêt. D’une façon générale, l’instruction se présente de la manière suivante : do
instruction while (condition);
Attention au ; à la fin du while.
Comme pour le if, l’instruction peut être une instruction simple, une instruction structurée ou bien un bloc d’instructions. Cette instruction est toujours exécutée au moins une fois (puisque le test de la condition se trouve après l’instruction). Il est possible de faire une boucle infinie en écrivant :
do
instruction while (1);
En effet, en C, la condition vraie vaut ≠ 0 et la condition fausse vaut 0. C’est la raison pour laquelle on définit souvent un type booléen (qui n’existe pas en C) comme un char qui peut prendre la valeur 0 ou 1 ainsi que des valeurs TRUE et FALSE comme suit :
#define BOOL char /* les lignes commençant par # sont */
#define TRUE 1 /* destinées au preprocesseur et pas au */
#define FALSE 0 /* compilateur */
main() {
int n;
BOOL toto = TRUE ;
do {
printf("Donnez un nombre entier : ");
scanf("%d", &n);
printf("voici son carré : %d\n", n*n);
}
while (toto == TRUE);
printf("Fin du programme\n ");
}
Dans ce programme, le préprocesseur va remplacer chaque occurrence de BOOL par char, de TRUE par 1 et de FALSE par 0. Le programme obtenu après remplacement sera ensuite compilé.
3.14 Structure de répétition conditionnelle : l’instruction while...
La décision de poursuite de la répétition dans l’instruction do... while se trouve à la fin de la boucle d’exécution des instructions. En C, il existe une autre structure de répétition conditionnelle où ce test a lieu au début de la boucle, l’instruction while. Le programme de la page précédente a été modifié pour utiliser un while au lieu d’un do... while.
main() {
int n;
printf("Donnez un nombre entier : ");
scanf("%d", &n); /* ou bien n = 1 par exemple */
printf("voici son carré : %d\n", n*n);
while (n != 0) {
printf("Donnez un nombre entier : ");
scanf("%d", &n);
printf("voici son carré : %d\n", n*n);
}
printf("Fin du programme\n ");
}
Comme le test a lieu en premier, il faut commencer par saisir une valeur de n avant de rentrer dans le while (sinon, n n’est pas initialisé) ou bien initialiser n avec une valeur différente de 0 pour forcer le programme à rentrer dans le while.
Conclusion : les variables intervenant dans la condition doivent être initialisées avant le while, ce qui n’est pas forcement nécessaire pour un do... while (cela peut être fait dans le premier tour de la boucle). D’une façon générale, l’instruction se présente de la manière suivante :
while (condition) instruction
Attention, il n’y a plus de ;.
D’une manière générale, on démontre que tout programme peut s’écrire avec une structure de choix et une structure de répétition conditionnelle. Les instructions while et do ...
while sont donc redondantes, mais commodes à utiliser.
3.15 Structure de répétition inconditionnelle : l’instruction for...
Dans une structure de répétition inconditionnelle, la répétition est effectuée un nombre fixe de fois, ce nombre dépendant d’un compteur. Pour imposer un nombre de tours fixe dans un while, il faut définir un compteur de boucle et tester une condition sur sa valeur pour sortir du while. Comme par exemple dans le programme suivant :
main() {
int i;
i = 0;
while (i < 5) {
printf("Voici un nombre entier : %d\n", i);
printf("Voici son carré : %d\n", i*i);
i = i + 1;
}
printf("Fin du programme\n ");
}
Le programme va tourner 5 fois dans la boucle pour i = 0, 1, 2, 3 et 4. Pour cela, trois éléments doivent être définis :
1) la valeur de départ (i = 0), 2) la valeur d’arrivée (i=5), 3) et l’incrément (ici, 1).
Il est possible de paramétrer le nombre de tours dans la boucle en écrivant : main()
{
int i, stop;
printf("Donnez le nombre de tours : ");
scanf("%d", &stop);
i = 0;
while (i < stop) {
printf("Voici un nombre entier : %d\n", i);
printf("Voici son carré : %d\n", i*i);
i = i + 1;
}
printf("Fin du programme\n ");
}
Le nombre de tours dans la boucle n’est plus connu à l’écriture du programme, mais seulement au moment de son exécution.
L’instruction for permet de simplifier l’écriture de la boucle inconditionnelle avec compteur.
main() {
int i;
for(i = 0; i < 5; i = i + 1) {
printf("Voici un nombre entier : %d\n", i);
printf("Voici son carré : %d\n", i*i);
}
printf("Fin du programme\n ");
}
Il est à noter que l’instruction d’incrémentation i = i + 1; s’écrit aussi i++;. D’une façon générale, l’instruction se présente de la manière suivante :
for (avant; condition; fin_de_tour) instruction
où :
• avant est une instruction simple qui sera exécutée avant le premier tour de boucle. C’est généralement l’initialisation du compteur.
• condition est la condition de poursuite de la boucle examinée avant chaque tour de boucle (y compris le premier).
• fin_de_tour est une instruction simple qui sera exécutée à la fin de chaque tour de boucle. C’est généralement l’incrémentation du compteur.
• instruction est une instruction au sens large. Il peut s’agir d’un autre for (les for imbriqués sont tout à fait utilisables).
Cette instruction est strictement équivalente à : avant;
while (condition) { instruction fin_de_tour;
}
Il est possible d’utiliser un for pour faire autre chose qu’une simple boucle avec compteur.
Ceci est fortement déconseillé pour préserver la lisibilité et donc faciliter la maintenance du programme. Il est aussi fortement conseillé de ne pas modifier la valeur du compteur de boucle dans la boucle sous peine d’obtenir un comportement hasardeux durant l’exécution.
L’instruction break (vu avec le switch) est utilisable dans une boucle. Elle permet de
quitter la boucle en cours d’exécution. Vous n’avez le droit de l’utiliser que si vous pouvez démontrer que le programme n’est pas faisable autrement (c’est-à-dire jamais).
Exercice 3.15 : modifiez le programme de la page 54 (boucle paramétrée) pour utiliser une boucle for à la place du while. Insérez l’instruction i = i - 1; à la fin de la boucle.
Que va-t-il se passer ?
Exercice 3.16 : écrivez un programme qui affiche un nombre n d’entiers consécutifs à partir d’une valeur p, n et p étant lues en données.