245 lines
10 KiB
Plaintext
245 lines
10 KiB
Plaintext
[set
|
||
title = "Instruction [c if]"
|
||
partAs = chapitre
|
||
translator = "Raphaël Jakse"
|
||
proofreader = "Stéphane Goujet"
|
||
]
|
||
|
||
Nous avons appris que ce que fait le programme est effectué par les expressions. Toutes les expressions de tous les programmes que nous avons vu jusqu'à maintenant ont commencé avec la fonction [c main] et étaient exécutés jusqu'à la fin de [c main].
|
||
|
||
Les instructions, d'un autre côté, sont des éléments qui affectent l'exécution des expressions. Les instructions ne produisent pas de valeurs et n'ont pas d'effets de bords en elles-mêmes. Elles déterminent si et dans quel ordre les expressions sont exécutées. Les instructions utilisent parfois des expressions logiques pour prendre de telles décisions.
|
||
|
||
[p Note : | d'autres langages de programmation peuvent avoir des définitions différentes pour les expressions et les instructions, alors que d'autres peuvent ne pas faire de distinction du tout.]
|
||
|
||
[ = Le bloc [c if] et sa portée
|
||
|
||
L'instruction [c if] détermine si une ou plusieurs expressions doivent être exécutées. Elle prend cette décision en évaluant une expression logique. Elle a le même sens que le mot français "si" dans la phrase "s'il y a du café alors je boirai du café".
|
||
|
||
[c if] prend une expression logique entre parenthèses. Si la valeur de cette expression logique est [c true], alors il exécute les expressions qui sont dans les accolades qui suivent. À l'inverse, si l'expression logique est [c false], les expressions entre accolades ne seront pas exécutées.
|
||
|
||
|
||
L'étendue entre accolades est appelée [* bloc].
|
||
|
||
Voici la syntaxe de l'instruction [c if]~ :
|
||
|
||
[code=d <<<
|
||
if (une_expression_logique)
|
||
{
|
||
// ... La ou les expressions à exécuter si l'expression logique est vraie
|
||
}
|
||
>>>]
|
||
|
||
Par exemple, la construction qui représente "s'il y a du café alors boire le café et laver la tasse" peut être écrite comme suit~ :
|
||
|
||
[code=d <<<
|
||
import std.stdio;
|
||
|
||
void main()
|
||
{
|
||
bool ilyaDuCafé = true;
|
||
|
||
if (ilyaDuCafé) {
|
||
writeln("Boire le café");
|
||
writeln("Laver la tasse");
|
||
}
|
||
}
|
||
>>>]
|
||
|
||
Si la valeur de [c ilyaDuCafé] était [c false], alors les expressions qui sont dans le bloc seraient ignorées et le programme n'afficherait rien.
|
||
|
||
Notez également qu'ouvrir les accolades sur la même ligne que le mot clé [c if] est un style de codage répandu.
|
||
|
||
]
|
||
[ = Le bloc [c else] et sa portée
|
||
|
||
Il y a parfois des opérations à exécuter quand l'expression logique de l'instruction [c if] est fausse. Par exemple, il y a toujours une opération à exécuter dans une décision du type «~ s'il y a du café, je boirai du café, sinon je boirai du thé~ ».
|
||
|
||
Les opérations à exécuter dans le cas [c false] sont placées dans un bloc après le mot clé [c else]~ :
|
||
|
||
[code=d <<<
|
||
if (une_expression_logique)
|
||
{
|
||
// ... expression(s) à exécuter si vrai
|
||
}
|
||
else
|
||
{
|
||
// ... expression(s) à exécuter si faux
|
||
}
|
||
>>>]
|
||
|
||
Par exemple, en supposant qu'il y a toujours du thé :
|
||
|
||
[code=d <<<
|
||
if(ilyaDuCafé) {
|
||
writeln("Boire du café");
|
||
} else {
|
||
writeln("Boire du thé");
|
||
}
|
||
>>>]
|
||
|
||
Dans cet exemple, soit la première, soit la deuxième chaîne de caractère sera affichée selon la valeur de [c ilyaDuCafé].
|
||
|
||
Notez également comment les accolades sont placées autour de [c else]~ ; c'est aussi un style de codage répandu.
|
||
|
||
[c else] lui-même n'est pas une instruction mais une clause optionnelle de l'instruction [c if]~ ; elle ne peut pas être utilisée toute seule.
|
||
]
|
||
[ = Utilisez toujours les accolades pour entourer les blocs
|
||
|
||
Ce n'est pas recommandé, mais il est possible d'omettre les accolades s'il n'y a qu'une instruction dans un bloc. Comme les blocs [c if] et [c else] qui précèdent n'ont qu'une instruction, ce code peut être écrit comme suit~ :
|
||
|
||
[code=d <<<
|
||
if (ilyaDuCafé)
|
||
writeln("Boire du café");
|
||
|
||
else
|
||
writeln("Boire du thé");
|
||
>>>]
|
||
|
||
Les programmeurs les plus expérimentés utilisent des accolades même pour une seule instruction (un des exercices de ce chapitre est à propos de leur omission). J'insiste sur cette règle de toujours utiliser des accolades parce que je vais maintenant vous montrer le seul cas où il est préférable d'omettre les accolades.
|
||
]
|
||
[ = La chaîne "[c if], [c else if], [c else]"
|
||
|
||
Une des forces des instructions et des expressions est la possibilité de les utiliser de manière plus complexe. En plus des expressions, les blocs peuvent contenir d'autres instructions. Par exemple, un bloc [c else] peut contenir une instruction [c if]. Combiner les instructions et les expressions nous permet de réaliser des programmes qui se comportent selon ce pour quoi ils sont écrits.
|
||
|
||
Ce qui suit est un code plus complexe écrit selon la supposition qu'aller à un bon troquet en vélo est mieux que marcher vers un mauvais troquet~ :
|
||
|
||
[code=d <<<
|
||
if (ilyaDuCafé) {
|
||
writeln("Boire du café à la maison");
|
||
|
||
} else {
|
||
|
||
if (ilyaUnVélo) {
|
||
writeln("Aller au bon endroit");
|
||
|
||
} else {
|
||
writeln("marcher vers le mauvais endroit");
|
||
}
|
||
}
|
||
>>>]
|
||
|
||
Le code ci-dessus représente la phrase~ : «~ s'il y a du café, boire à la maison~ ; sinon, s'il y a un vélo, aller à la bonne place~ ; sinon marcher vers le mauvais endroit~ ».
|
||
Compliquons cette décision~ : au lieu de devoir marcher au mauvais endroit, essayer d'abord le voisin~ :
|
||
|
||
[code=d <<<
|
||
if (ilyaDuCafé) {
|
||
writeln("Boire du café à la maison");
|
||
|
||
} else {
|
||
|
||
if (ilyaUnVélo) {
|
||
writeln("Aller au bon endroit");
|
||
|
||
} else {
|
||
|
||
if (voisinEstChezLui) {
|
||
writeln("Prendre le café chez le voisin");
|
||
|
||
} else {
|
||
writeln("Marcher vers le mauvais endroit");
|
||
}
|
||
}
|
||
}
|
||
>>>]
|
||
|
||
Des décisions comme "si ce cas, sinon si cet autre cas, sinon si cet autre autre cas, etc." sont communes dans les programmes. Malheureusement, quand la règle de toujours utiliser des accolades est suivie aveuglément, le code fini par avoir trop d'espacement horizontal et vertical~ : en ignorant les lignes vides, les 3 instructions [c if] et les 4 expressions [c writeln] ci-dessus occupent un total de 13 lignes.
|
||
|
||
Pour écrire de telles constructions d'une façon plus compacte, quand un bloc [c else] contient seulement une instruction [c if], les accolades de ce bloc [c else] sont omises.
|
||
|
||
Je laisse le code suivant mal écrit en tant qu'étape intermédiaire avant de le montrer sous une meilleure forme. Aucun code ne devrait être écrit comme cela. (Je le laisse également non coloré pour indiquer qu'il est inacceptable écrit de cette manière).
|
||
|
||
Ce qui suit est ce à quoi le code ressemble après avoir supprimé les accolades des deux blocs [c else] qui ne contiennent qu'une instruction [c if]~ :
|
||
|
||
[code=crado <<<
|
||
if (ilyaDuCafé) {
|
||
writeln("Boire du café à la maison");
|
||
|
||
} else
|
||
|
||
if (ilyaUnVélo) {
|
||
writeln("Aller en vélo au bon endroit");
|
||
|
||
} else
|
||
|
||
if (voisinEstChezLui) {
|
||
writeln("Prendre le café chez le voisin");
|
||
|
||
} else {
|
||
writeln("Marcher jusqu'au mauvais endroit");
|
||
}
|
||
>>>]
|
||
|
||
Si maintenant nous déplaçons ces instructions [c if] sur la même ligne que le [c else] qui les précède et que nous nettoyons le code, nous finissons par avoir quelque chose de plus lisible~ :
|
||
|
||
[code=d <<<
|
||
if (ilyaDuCafé) {
|
||
writeln("Boire du café à la maison");
|
||
|
||
} else if (ilyaUnVélo) {
|
||
writeln("Aller en vélo au bon endroit");
|
||
|
||
} else if (voisinEstChezLui) {
|
||
writeln("Prendre le café chez le voisin");
|
||
|
||
} else {
|
||
writeln("Marcher jusqu'au mauvais endroit");
|
||
}
|
||
>>>]
|
||
|
||
Supprimer les accolades permet au code d'être plus compact et de regrouper les expressions pour une meilleure lisibilité. Les expressions logiques, l'ordre dans lequel elles sont évaluées, et les opérations qui sont exécutées quand elle sont vraies sont maintenant plus faciles à voir d'un coup d'œil.
|
||
|
||
Cette structure de programmation courante est appelée la chaîne "[c if], [c else if], [c else]".
|
||
]
|
||
|
||
[ = Exercices
|
||
|
||
# [
|
||
Puisque l'expression logique ci-dessous est vraie, nous pourrions nous attendre à ce que le programme boive de la limonade et lave le verre.
|
||
|
||
[code=d <<<
|
||
import std.stdio;
|
||
|
||
void main()
|
||
{
|
||
bool ilyaDeLaLimonade = true;
|
||
|
||
if (ilyaDeLaLimonade) {
|
||
writeln("Boire de la limonade");
|
||
writeln("Laver le verre");
|
||
|
||
} else
|
||
writeln("Manger de la tarte");
|
||
writeln("Laver l'assiette");
|
||
}
|
||
>>>]
|
||
|
||
Mais si vous lancez ce programme, vous verrez qu'il lave aussi l'assiette~ :
|
||
|
||
[output <<<
|
||
Boire de la limonade
|
||
Laver le verre
|
||
Laver l'assiette
|
||
>>>]
|
||
|
||
Pourquoi~ ? Corrigez le programme pour ne laver l'assiette que quand l'expression logique est fausse.
|
||
]
|
||
# [ Écrivez un programme qui joue à un jeu avec l'utilisateur (évidemment avec de la confiance). L'utilisateur lance un dé et entre sa valeur. L'utilisateur ou le programme gagne selon la valeur du dé :
|
||
|
||
|<= Valeur du dé |<= Sortie du programme
|
||
| 1 | Vous gagnez
|
||
| 2 | Vous gagnez
|
||
| 3 | Vous gagnez
|
||
| 4 | Je gagne
|
||
| 5 | Je gagne
|
||
| 6 | Je gagne
|
||
| N'importe quelle autre valeur | ERREUR : Valeur non valide
|
||
|
||
Bonus~ : faire en sorte que ce programme mentionne aussi la valeur quand celle-ci est invalide. Par exemple~ : [output ERREUR : 7 est invalide]
|
||
]
|
||
# [
|
||
Changez le jeu pour que l'utilisateur entre une valeur entre 1 et 1000. Maintenant, l'utilisateur gagne quand la valeur est dans l'intervalle 1-500 et l'ordinateur gagne quand la valeur est dans l'intervalle 501-1000. Est-ce que le programme précédent peut être facilement modifié pour fonctionner de cette manière~ ?
|
||
]
|
||
|
||
[[part:corrections/if | … Les solutions]
|
||
]
|