En logique, la négation permet de représenter le contraire d'une proposition.

Si quelque chose est vrai, alors son contraire est faux et réciproquement.

En Pascal, l'opérateur de négation se note Not.

La table suivante (que l'on appelle table de vérité) résume l'effet de l'opérateur de négation :

Par exemple, avec deux variables booléennes ArticleDisponible et RuptureDeStock, on pourrait écrire :

ArticleDisponible := Not RuptureDeStock;

Si RuptureDeStock vaut true avant cette affectation, alors ArticleDisponible vaudra false après cette affectation.

Réciproquement, si RuptureDeStock vaut False avant cette affectation, alors ArticleDisponible vaudra true après cette affectation.

La conjonction, représentée en Pascal par l'opérateur And, permet d'exprimer le fait que deux choses sont vraies simultanément.

Voilà la table de vérité de l'opérateur And :

Prenons un exemple.

La variable booléenne AmpouleFonctionne représente le fait qu'une ampoule électrique fonctionne.

Une autre variable booléenne InterrupteurOn est vraie si et seulement si l'interrupteur est en position On.

La variable booléenne LumiereAllumee représente le fait que la lumière est allumée.

Après l'affectation suivante :

LumiereAllumee := AmpouleFonctionne And InterrupteurOn;

la variable LumiereAllumee ne vaudra True que si les variables AmpouleFonctionne et InterrupteurOn valaient également True juste avant l'affectation.

La disjonction de deux propositions est vraie si et seulement si au moins une de ces deux propositions est vraie.

Autrement dit, la disjonction de deux propositions n'est fausse que lorsque ces deux propositions sont fausses.

Par exemple, la proposition « Il est bête ou il ne comprend pas » ne sera fausse que si l'individu en question n'est pas bête et a très bien compris.

L'opérateur de disjonction est représenté en Pascal par le mot-clé Or. Voici sa table de vérité :

Prenons un exemple.

La variable booléenne AmpouleFoutue représente le fait qu'une ampoule électrique ne fonctionne pas.

Une autre variable booléenne InterrupteurOff est vraie si et seulement si l'interrupteur est en position Off.

La variable booléenne LumiereEteinte représente le fait que la lumière est éteinte.

Après l'affectation suivante :

LumiereEteinte := AmpouleFoutue Or InterrupteurOff;

la variable LumiereEteinte ne vaudra True que si la variable AmpouleFoutue et/ou la variable InterrupteurOff avaient la valeur True juste avant l'affectation.

Vous connaissez déjà un cas particulièrement simple d'expression logique : ce sont les noms de variables booléennes.

Par exemple, si la variable LumiereEteinte est déclarée comme une variable booléenne, le simple nom de variable LumiereEteinte peut être considéré comme une expression logique.

On peut également construire des expressions logiques en combinant d'autres expressions logiques avec les opérateurs Not, And, Or.

Supposons, par exemple, que x, y et z soient des variables booléennes. Alors Not x, x And y, x Or y sont des expressions logiques. Tout comme z Or (x And y), (Not z And x) et (x Or y)…

De manière générale :

Il existe encore un autre moyen de construire une expression logique : en utilisant des opérateurs de comparaison.

Les six opérateurs▲

Comparaison d'expressions numériques▲

Comparaison de chaînes de caractères▲

La structure de contrôle If … Then s'écrit de la manière suivante :

If condition Then
Begin
    Instructions à exécuter
    si la condition est vraie
End;

La condition n'est rien d'autre qu'une expression logique.

Les instructions entre begin et end ne seront exécutées que si la condition est vraie.

S'il n'y a qu'une seule instruction à exécuter, on peut omettre les mots clé begin et end :

If condition Then Instruction à exécuter;

Prenons un exemple :

If n > 0 Then n := n - 1;

Si, par exemple, n vaut 5 juste avant l'exécution du If … Then, la condition n > 0 est vérifiée. L'ordinateur va donc exécuter l'affectation n := n - 1. n vaudra donc 4 à la sortie de la conditionnelle.

Si n vaut -1, par contre, la condition n > 0 n'est pas vérifiée. L'affectation ne sera pas exécutée et n vaudra toujours -1 à la sortie de la conditionnelle.

Le If … Then … Else est une autre forme de conditionnelle.

Elle permet d'exécuter certaines instructions si une condition est vraie, et d'autres si elle est fausse.

Voilà sa syntaxe :

If condition Then
begin
    Instructions à exécuter
    si la condition est vraie
End
Else
begin
   Instructions à exécuter 
   si la condition est fausse 
End;

De même, les begin et end ne sont sont pas nécessaires s'il n'y a qu'une seule instruction.

Prenons un exemple :

If n > 0 Then
   n := n - 1
Else
   n := n + 1;

Remarquez que nous n'avons pas mis de point-virgule après la première affectation. Si nous l'avions fait, le compilateur aurait généré une erreur de syntaxe, car il aurait interprété ceci comme un if … then simple suivi du mot clé else, qui n'aurait rien à voir ici dans ce cas.

Par contre, le point-virgule est nécessaire après la deuxième affectation pour marquer la fin de la conditionnelle.

Que se passe-t-il lors de l'exécution de cette conditionnelle ?

Supposons, par exemple, que n vaut 5 juste avant l'exécution du If … Then … Else. La condition n > 0 est vérifiée. L'ordinateur va donc exécuter l'affectation n := n - 1. Par contre, l'affectation n := n + 1 ne sera pas exécutée. n vaudra donc 4 à la sortie de la conditionnelle.

Si n vaut -1, par contre, la condition n > 0 n'est pas vérifiée. L'affectation n := n - 1 n'est donc pas exécutée. Mais comme la condition est fausse, l'affectation n := n + 1 sera exécutée. n vaudra donc 0 à la sortie de la conditionnelle.

Les instructions à l'intérieur d'un If ne sont pas forcément des affectations comme dans les exemples précédents.

On peut également y mettre d'autres structures de contrôle et, en particulier, d'autres Ifs.

Exemple :

If n > 0 Then
    n := n - 1
Else
    If n >= -3 Then
         n := n + 1
    Else
         n := 2 * n;

Pour n = 5, l'instruction exécutée est n := n - 1. n vaudra donc 4 à la sortie de la conditionnelle.

Pour n = -1, l'instruction exécutée est n := n + 1. n vaudra donc 0 à la sortie de la conditionnelle.

Pour n = -4, l'instruction exécutée est n := 2 * n. n vaudra donc -8 à la sortie de la conditionnelle.

Dans l'exemple précédent, on a deux niveaux d'imbrication. Mais on peut avoir autant de niveaux d'imbrication qu'on le souhaite.

L'imbrication de Ifs peut conduire à des programmes plus rapides (voir l'exercice Min-Max-Med), mais elle peut également compliquer l'écriture du code, notamment dans la protection d'un programme contre les erreurs.

Prenons par exemple un programme utilisant une date définie par un jour (nombre entier entre 1 et 31), un mois (nombre entier entre 1 et 12) et une année de ce siècle (nombre entier supérieur à 2000). Ces trois données sont lues depuis trois zones de texte (respectivement ZT_Jour, ZT_Mois et ZT_Annee) dans des variables entières, respectivement Jour, Mois, Annee. Ce traitement est effectué par la procédure évènementielle associéE au bouton BT_GererDate.

Pour tester la validité de ces données avec des Ifs imbriqués, on écrirait le code suivant :

procedure TForm1.BT_GererDateClick(Sender: TObject)
var Jour,Mois,Annee: integer;
begin
 LireEntier (Jour, ZT_Jour);
 If ( Jour < 1) or (Jour > 31) Then
   ShowMessage ('Numéro du jour non valide!')
 Else
 begin
   LireEntier (Mois, ZT_Mois);
   If (Mois < 1) or (Mois > 12) Then
     ShowMessage('Numéro du mois non valide!')
   Else
   Begin
     LireEntier(Annee,ZT_Annee);
     If Annee < 2000 Then
       ShowMessage ('Année non valide!')
     Else
     Begin  
       Traitement de la date
     End
   End 
 End
End;

Pour raccourcir ce genre d'écriture, on peut utiliser l'instruction Exit, qui permet de forcer la fin de l'exécution du sous-programme qui la contient. Avec cette instruction, l'exemple précédent peut être écrit sans aucune imbrication de Ifs :

procedure TForm1.BT_GererDateClick(Sender: TObject)
var Jour,Mois,Annee: integer;
begin
 LireEntier (Jour, ZT_Jour);
 If ( Jour < 1) or (Jour > 31) Then
 Begin ShowMessage ('Numéro du jour non valide!'); Exit End;
 
 LireEntier (Mois, ZT_Mois);
 If (Mois < 1) or (Mois > 12) Then
 Begin ShowMessage('Numéro du mois non valide!'); Exit End;
      
 LireEntier(Annee,ZT_Annee);
 If Annee < 2000 Then
 Begin ShowMessage ('Année non valide!'); Exit End;

  Traitement de la date

End;

Un peu de vocabulaire :

Dans notre exemple, une itération est une exécution des instructions S := S + i; et i := i + 1;.

Dans notre exemple, ce sont les instructions S := 0 et i := 1.

Dans notre exemple, le compteur est représenté par la variable i. À chaque itération, la valeur de i est incrémentée par l'affectation i := i + 1.

Nous allons à présent dérouler la boucle donnée en exemple, c'est-à-dire détailler toutes les instructions qui seront exécutées jusqu'à ce que la boucle s'arrête.

Supposons que n vaut 3 avant d'entrer dans la boucle. Voilà exactement ce qui se passe lorsque cette boucle est exécutée :

Dans une boucle While, la condition d'arrêt est testée avant l'exécution d'une itération.

Donc avant d'entrer la première fois dans la boucle, l'ordinateur va tester la condition i ≤ n. Comme i vaut 1 et n vaut 3, il va rentrer dans la boucle et faire une première itération.

À la fin de la première itération, i vaut 2. La condition i ≤ n est toujours vérifiée. L'ordinateur va donc faire une deuxième itération.

À la fin de la deuxième itération, i vaut 3. La condition i ≤ n est toujours vérifiée. L'ordinateur va donc faire une troisième itération.

À la fin de la 3ème itération, i vaut 4. Ce sera donc la dernière itération car à présent la condition i ≤ n est fausse.