Introduction générale à la programmation/Tests conditionnels

Début de la boite de navigation du chapitre

fin de la boite de navigation du chapitre

Premier test conditionnel : Si ... Alors

(Note : dans les exemples qui suivent, les déclarations de variables, vues au chapitre précédent, ne sont pas réécrites pour faciliter la lecture. Mais elle seraient écrites avant ces instructions dans un 'vrai' programme.)

On souhaite très souvent que les programmes aient un comportement dynamique, voire interactif, c'est-à-dire que leur exécution se fasse en fonction d'évènements intervenant au cours de l'exécution. Ceci est possible par les tests conditionnels, notamment avec l'instruction simple Si (expression) Alors {suite d'instructions}. Ici expression désigne quelque chose que l’on peut évaluer comme étant vrai ou faux. Par exemple, x > 5 est vrai si x est égal à 10, mais faux si x est égal à 3.

Illustrons cette instruction par l'exemple suivant

Si (x > 5) Alors
  {
    y = 0;
    z = 1;
  }

Nous voyons que les variables y et z prendront respectivement les valeurs 0 et 1 si l’expression x > 5 est vérifiée. En effet, le fait d'évaluer l’expression x > 5 comme vraie implique l'exécution de la suite d'instructions entre les accolades { et }, ce que nous appellerons par la suite un bloc d'instructions.

Si l’expression x > 5 n'est justement pas vérifiée, que se passe -t-il ici ? Rien... nous voyons ici un premier exemple de non-séquentialité du code, puisque les instructions d'affectations y = 0 et z = 1 seront sautées, et par conséquent non exécutées. Pour pouvoir exécuter un bloc d'instructions si l’expression x > 5 se révèle fausse, nous pouvons utiliser le code suivant

Si (x > 5) Alors
  {
    y = 0;
    z = 1;
  }
Si (x <= 5) Alors
  {
    y = 5;
    z = 7;
  }

où le symbole <= désigne l'opérateur "inférieur ou égal". Cependant, un tel code n’est pas très esthétique et efficace : Si l’expression x > 5 est fausse alors l’expression x <= 5 sera forcément vraie, et réciproquement. Dans ce cas, pourquoi évaluer une expression que l’on sait d'avance vraie ou fausse ? Pour éviter cette maladresse, il existe un test conditionnel un peu plus élaboré : le Si ... Alors ... Sinon.

Second test conditionnel : Si ... Alors ... Sinon

Si vous avez compris la première partie de ce chapitre, alors cette partie-là vous semblera enfantine. Le plus simple est peut être de directement illustrer le test conditionnel Si ... Alors ... Sinon en reprenant l'exemple précédent.

Si (x > 5) Alors
  {
    y = 0;
    z = 1;
  }
Sinon
  {
    y = 5;
    z = 7;
  }
suite du programme...

L'exécution de ce code est simple : si l’expression x > 5 est vraie, alors nous aurons 0 comme valeur pour y et 1 pour z, et l'exécution du programme rependra à la ligne où j’ai écris "suite du programme". Si au contraire x > 5 est faux, alors le programme exécutera directement les instructions comprises dans le bloc {...} après Sinon. Ainsi, sans évaluation d'autres expressions, nous aurons 5 comme valeur pour y et 7 pour z.

Opérateurs booléens

Un opérateur booléen (du nom du mathématicien George Boole) est une opération dont la valeur rendue est soit vraie, soit fausse. Par exemple, dans l’expression x > 5, l'opérateur > est un opérateur booléen. Nous noterons les opérateurs booléens de ce cours de la façon suivante :

• >, désignant l'opérateur "supérieur à",
• >=, désignant l'opérateur "supérieur ou égal à",
• <, désignant l'opérateur "inférieur à",
• <=, désignant l'opérateur "inférieur ou égal à",
• ==, désignant l'opérateur "égal à", (à ne pas confondre avec un seul = qui est l'instruction d'affectation !),
• !=, désignant l'opérateur "diffèrent de",
• !, désignant l'opérateur "négation". Par exemple !(x>5) est l’expression "x n’est pas supérieur à 5",
• &&, désignant l'opérateur "et". Par exemple (x>5) && (y==2) est l’expression "x est supérieur à 5 ET y est égal à 2",
• ||, désignant l'opérateur "ou".

Il existe d'autres opérateurs booléens, comme par exemple le XOR, c'est-à-dire le "ou" exclusif, mais il est utile dans un premier temps de n'apprendre que les opérateurs ci-dessus.

Combiner les tests conditionnels

Nous terminerons ce chapitre par cette remarque. Dans les exemples précédents, je n'ai utilisé que des instructions d'affectation dans les blocs. Or, vous pouvez utiliser toutes sortes d'instructions à l'intérieur de ces blocs, y compris de nouveaux tests conditionnels !

Si vous avez bien compris ce chapitre, essayez de faire l'exercice suivant. La solution vous sera détaillée par menu déroulant.

Exercice : Decrivez l'exécution du programme suivant.

integer x;
integer y;
integer z;

Si ( (x > 5) || (z<= 9) ) Alors
  {
    y = 0;
    Si (z > 5) Alors
      {
        x = 4;
        y = 1;
      }
    Sinon
      {
        x = 5;
      }
    z = 42;
  }
x = 12;    

Solution

Après avoir déclaré trois variables entières x, y et z, nous rentrons dans le bloc du premier Si si nous avons x strictement supérieur à 5 ou si z est inférieur ou égal à 9. J'insiste sur le fait que seulement l'une de ces deux conditions doit être vérifiée, mais pas nécessairement les deux.

Si nous rentrons dans ce bloc, on donne 0 comme valeur à y, puis on teste si z est supérieur à 5. Si c’est le cas, alors on affecte la valeur 4 à x et 1 à y. Si ce n’est pas le cas, on met 5 comme valeur à x. Dans ces deux derniers cas, l'affectation z = 42 sera effectuée puisqu'elle est en dehors des blocs de Si et Sinon, de la même manière que y = 0 était en dehors de ces blocs.

Si jamais notre premier test n’est pas vérifié, donc si x est inférieur ou égal à 5 et si z est strictement supérieur à 9, alors on n'exécute rien en particulier : on continue tout bonnement le programme. Que ce premier test soit vérifié ou non, nous exécutons dans les deux cas l'affectation x = 12, puisque cette affectation est en dehors de tout bloc d'une conditionnelle.

Ainsi, à la fin de notre programme, on ne peut pas connaître les valeurs de y et z puisqu'elles sont assujetties aux résultats des tests conditionnels du programme. Par contre, nous pouvons être sûrs que la valeur de x sera 12.