1.4 Instructions conditionnelles
1.4.1 Le if / else
 |
Les instructions que nous avons vues jusqu'à présent permettent de lire des entiers, faire des calculs sur ces entiers et afficher le résultat de ces calculs, ainsi que du texte. Un ordinateur n'est cependant pas une simple calculatrice et peut faire beaucoup plus que de simples calculs. En particulier, nous allons voir comment il est possible de lui faire prendre des décisions, grâce aux instructions conditionnelles, qui permettent de déterminer le comportement d'un programme en fonction du résultat d'un test.
|
Pour commencer, on va écrire un programme qui demande à l'utilisateur un nombre entier et qui affiche "positif" ou "négatif" en fonction du signe de ce nombre. Les mots du langage C que nous allons utiliser sont le if et le else, qui se traduisent en français "si" et "sinon".
Dans la description qui suit, on utilise le mot "bloc" pour signifier "un groupe d'instructions".
if (...la condition...)
(...bloc du if...)
else
(...bloc du else...)
Fonctionnement de la structure if, else :
Voyons comment écrire le programme qui affiche si un nombre entré par l'utilisateur est positif ou négatif :
#include <stdio.h>
int main()
{
int nombre;
scanf("%d", &nombre);
if (nombre < 0)
{
printf("négatif");
}
else
{
printf("positif");
}
return 0;
}
Voici les éléments nécessaires pour utiliser une telle structure :
-
La condition peut s'exprimer sous la forme d'une comparaison de valeurs. Ici, la condition nombre < 0 est vraie si la valeur stockée dans la variable nombre est inférieure à 0. D'autres types de comparaisons sont possibles : "==" pour l'égalité, "!=" pour la différence, "<" et ">" pour les comparaisons strictes, "<=" et ">=" pour les comparaisons larges (inférieur ou égal / supérieur ou égal).
-
Afin de délimiter les blocs, chacun d'eux commence par le caractère "{" (accolade ouvrante) et se termine par le caractère "}" (accolade fermante). Entre ces deux accolades, on peut placer autant d'instructions qu'on le souhaite, y compris aucune.
1.4.2 Portée
Les déclarations réalisées jusqu'à maintenant consistaient à associer un nom à une valeur dans toute la suite du programme. Ce cas n'est pas général : il arrive qu'un nom soit associé à une valeur uniquement durant un petit morceau du programme. On dit alors que la "portée" de la déclaration est limitée.
On a vu plus tôt que les déclarations de variables devaient toujours se trouver avant tout autre type d'instruction. Il faut en fait être plus précis : une déclaration de variable doit toujours se trouver avant tout autre type d'instruction du bloc dans lequel elle se trouve.
Par exemple, le programme suivant, qui calcule la valeur absolue d'un nombre, est tout à fait correct :
#include <stdio.h>
int main()
{
int nombre;
scanf("%d", &nombre);
if (nombre < 0)
{
int valeurAbsolue;
valeurAbsolue = -nombre;
printf("Votre nombre est négatif et a pour valeur absolue %d", valeurAbsolue);
}
else
{
printf("Votre nombre est positif et a pour valeur absolue %d", nombre);
}
return 0;
}
La déclaration int valeurAbsolue est en effet la toute première instruction du bloc du if et est donc valide, même s'il y a d'autres types d'instructions avant le début du bloc.
Regardez maintenant le code suivant, qui n'est pas valide :
#include <stdio.h>
int main()
{
int nombre;
scanf("%d", &nombre);
if (nombre < 0)
{
int valeurAbsolue;
valeurAbsolue = -nombre;
printf("Votre nombre est négatifn");
}
else
{
printf("Votre nombre est positifn");
}
printf("La valeur absolue de votre nombre est %dn", valeurAbsolue);
return 0;
}
Si ce code était autorisé, lorsque nombre est positif, seul le bloc du else serait exécuté, et la déclaration de la variable valeurAbsolue ne serait alors jamais été exécutée. Que devrait-on alors afficher à la dernière ligne ? Vaudrait-il mieux afficher zéro, ne rien afficher, ou afficher un message d'erreur lors de l'exécution ? Aucune de ces possibilités n'est satisfaisante.
Afin d'éviter ce genre de problèmes, on interdit tout simplement d'utiliser des identifiants dont on n'est pas certain qu'ils aient été déclarés. Voici la règle à retenir :
Une déclaration effectuée dans un bloc a une portée limitée à ce bloc.
Ainsi le code suivant est tout à fait correct, mais après la première accolade fermante, l'identifiant "a" n'est plus associé à rien, et après la deuxième accolade fermante, l'identifiant "b" n'est plus associé à rien.
#include <stdio.h>
int main()
{
int nombre;
scanf("%d", &nombre);
if (nombre < 0)
{
int a = 5;
printf("%d", a);
}
else
{
int b = 6;
printf("%d", b);
}
return 0;
}
1.4.3 Exercices
Exercice : écrivez un programme qui lit un nombre au clavier puis affiche "égal à 4" si le nombre fourni par l'utilisateur est égal à 4, et "différent de 4" sinon. Dans les deux cas, affichez ensuite un retour à la ligne.
Solution :
#include <stdio.h>
int main()
{
int nombre;
scanf("%d", &nombre);
if (nombre == 4)
{
printf("égal à 4n");
}
else
{
printf("différent de 4n");
}
return 0;
}
Exercice : écrivez un programme qui lit deux nombres au clavier et affiche le premier nombre, puis "et", le second nombre, puis "sont" et enfin "égaux" ou "différents" selon les cas.
Attention à bien mettre un espace entre chacun des éléments affichés. Par exemple si l'utilisateur tape les nombres 21 et 42, votre programme devra afficher précisément :
21 et 42 sont différents
Solution :
#include <stdio.h>
int main()
{
int nombre1;
int nombre2;
scanf("%d%d", &nombre1, &nombre2);
printf("%d et %d sont ", nombre1, nombre2);
if (nombre1 == nombre2)
{
printf("égauxn");
}
else
{
printf("différentsn");
}
return 0;
}
Exercice : écrivez un programme qui demande deux nombres à l'utilisateur et qui affiche la valeur du plus grand d'entre eux.
Solution :
#include <stdio.h>
int main()
{
int nombre1;
int nombre2;
scanf("%d%d", &nombre1, &nombre2);
if (nombre1 > nombre2)
{
printf("%dn", nombre1);
}
else
{
printf("%dn", nombre2);
}
return 0;
}
Remarque : on peut aussi faire le test nombre1 >= nombre2, vu que lorsque nombre1 est égal à nombre2, chacun des deux blocs affiche un résultat correct.
1.4.4 Réduction des blocs
Il est possible d'alléger les notations dans les structures conditionnelles (avec if) lorsque des blocs sont formés d'une seule instruction. Par exemple, le code suivant :
scanf("%d%d", &nombre1, &nombre2);
if (nombre1 > nombre2)
{
printf("%dn", nombre1);
}
else
{
printf("%dn", nombre2);
}
Peut s'écrire de la manière suivante :
scanf("%d%d", &nombre1, &nombre2);
if (nombre1 > nombre2)
printf("%dn", nombre1);
else
printf("%dn", nombre2);
(nombre == 0)
{
}
else
printf("Le nombre est différent de zéro");
(nombre == 0)
;
else
printf("Le nombre est différent de zéro");
(nombre != 0)
printf("Le nombre est différent de zéro");
else
;
(nombre != 0)
printf("Le nombre est différent de zéro");
Voici la règle à retenir :
Lorsqu'un bloc ne contient qu'une seule instruction, les accolades peuvent être retirées.
Il est important de noter que cette simplification ne fonctionne que si le bloc réduit ne contient qu'une instruction. Dès qu'il y a plusieurs instructions, les accolades sont obligatoires.
1.4.5 Blocs vides, else implicite
De même que pour un bloc ne contenant qu'une seule instruction, il est possible de simplifier un bloc ne contenant aucune instruction. Il suffit d'utiliser l'instruction vide, constituée uniquement d'un point virgule. Si par exemple on ne veut rien afficher si un nombre est égal à zéro, et afficher un message sinon, on peut écrire le code suivant :
if
On peut aussi le simplifier, et l'écrire de la manière suivante :
if
La règle à retenir est :
Lorsqu'un bloc ne contient aucune instruction, on peut le remplacer par un simple point virgule.
Attention : si on ne met pas le point virgule, le compilateur considèrera l'instruction qui suit comme faisant partie du bloc du if.
Pour toute condition, il est possible d'écrire la condition inverse. Le code précédent peut ainsi s'écrire :
if
Dans ce cas, il est cependant possible de simplifier encore plus l'écriture, en se passant tout simplement du bloc du else :
if
Exercice : écrivez un programme qui lit un entier et affiche "positif" si celui-ci est positif ou nul, et rien sinon.
Solution :
#include <stdio.h>
int main()
{
int nombre;
scanf("%d", &nombre);
if (nombre >= 0)
printf("positif");
return 0;
}
Exercice : comment pourriez-vous simplifier le code suivant ?
#include <stdio.h>
int main()
{
int nombre1, nombre2;
printf("Entrez votre code secret numérique :n");
scanf("%d", &nombre1);
printf("Confirmez votre code secret numérique : n");
scanf("%d", &nombre2);
if (nombre1 == nombre2)
{
}
else
{
printf("Erreur : les deux nombres sont différentsn");
}
return 0;
}
Indication : pensez à utiliser le test de différence, qui s'écrit "!=".
Solution : on peut dans ce cas utiliser la condition contraire en remplaçant "==" par "!=", ce qui permet de supprimer le bloc du else. On simplifie également le bloc ne contenant qu'une instruction.
#include <stdio.h>
int main()
{
int nombre1, nombre2;
printf("Entrez votre code secret numérique :n");
scanf("%d", &nombre1);
printf("Confirmez votre code secret numérique : n");
scanf("%d", &nombre2);
if (nombre1 != nombre2)
printf("Erreur : les deux nombres sont différentsn");
return 0;
}
1.4.6 Le else if
Exercice : écrivez un programme qui lit un nombre et affiche "c'est 4", ou bien "c'est 8", ou alors "c'est une autre valeur", selon l'entier fourni.
Indication : on peut placer un if à l'intérieur des accolades d'un bloc d'un autre if.
Solution :
#include <stdio.h>
int main()
{
int nombre;
scanf("%d", &nombre);
if (nombre == 4)
printf("c'est 4");
else
{
if (nombre == 8)
printf("c'est 8");
else
printf("c'est une autre valeur");
}
return 0;
}
Remarque : la solution n'est pas unique, on peut très bien aboutir à un résultat correct avec des tests différents.
Il est possible de simplifier le code précédent grâce à la règle suivante :
Lorsque le bloc du else contient lui-même une structure if, on peut enlever les accolades de ce bloc.
Observez ce que l'on obtient pour le code précédent et la manière dont on le présente :
#include <stdio.h>
int main()
{
int nombre;
scanf("%d", &nombre);
if (nombre == 4)
printf("c'est 4");
else if (nombre == 8)
printf("c'est 8");
else
printf("c'est une autre valeur");
return 0;
}
Ce principe peut être généralisé, avec autant de "else if" qu'on le souhaite :
if (...1ère condition...)
(...bloc du if...)
else if (...2ème condition...)
(...bloc du 1er else if...)
else if (...3ème condition)
(...bloc du 2ème else if...)
...
...
else
(...bloc du else...)
Remarque : le dernier else peut être enlevé si le bloc associé est vide.
Fonctionnement de la structure if avec des else if :
- Evaluer la condition du premier if.
- Si celle-ci est vraie, on exécute le bloc juste après et on continue l'exécution après le dernier bloc de la structure.
- Dans le cas contraire, aller jusqu'au
else if qui suit et recommencer selon le même principe.
- Si aucune des conditions de la structure n'est vraie, alors on exécute le bloc du
else, s'il y en a un.
Remarque : si plusieurs des conditions de la structure sont vraies, seul le bloc de la première sera exécuté.
Exercice : écrivez un programme qui lit un nombre et affiche "strictement positif" si le nombre est positif et non nul, "strictement négatif" s'il est négatif et non nul, et "nul" s'il est égal à zéro.
Solution :
#include <stdio.h>
int main()
{
int nombre;
scanf("%d", &nombre);
if (nombre > 0)
printf("strictement positif");
else if (nombre < 0)
printf("strictement négatif");
else
printf("nul");
return 0;
}
- Evaluer la condition qui se trouve après le if.
- Si cette condition est vraie, on exécute le bloc du if, mais pas le bloc du else.
- Dans le cas contraire, on exécute le bloc du else, mais pas le bloc du if.
- Dans les deux cas, on exécute ensuite les instructions qui suivent le bloc du else.
