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} Sinon {autre 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;