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

On souhaite très souvent que les programmes aient un comportement dynamique, voir 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 prendrons 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 à 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 ce 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 forcement 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-la 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'autre opérateurs booléens, comme par exemple le XOR, c'est-a-dire le "ou" exclusif, mais il n'est utile dans un premier temps de n'apprendre que les opérateur ci-dessus.

Combiner les tests conditionnels

Nous terminerons ce chapitre par cette remarque. Dans les exemples precedents, je n'ai utilise que des instructions d'affectations dans les blocs. Or, vous pouvez utiliser toute sorte d'instruction a l'interieur 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 detaillee par menu deroulant.

Exercice : Decrivez l'execution du programme suivant.

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

Solution

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 verifiée, mais pas nécéssairement 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 meme manière que y = 0 était en dehors de ces blocs.

Si jamais notre premier test n'est pas verifié, 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 verifié 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ûr que la valeur de x sera 12.