[bases] booléens, table de verités, syntaxe delphi

Sommaire

    Valeurs des booléens
    Tables de vérité des operateurs booléen
    Operateurs relationnel et d'ensemble
    Exemple d'opérations complexe et tables de vérité
    Exemple d'écriture de code grâce aux operateurs booléen
    Ecriture des booléens dans les conditions

 

Valeurs des booléens

Les booléens on par défaut des valeurs binaire pour définir leurs états (0 ou 1).
Dans de nombreux langages, ces valeurs sont remplacées par des mots  plus "parlant", c'est à dire faux (0) ou vrai (1) (false,true).

Un booléen ne peu avoir que deux états unique donc, vrai ou faux. Ils sont comparables a une lampe qui serait soit allumée, soit éteinte mais ne peut être dans les deux états a la fois. Il faut comprendre par la  que le booléen ne peut pas être "presque" vrai ou "presque" faux, il est soit l'un, soit l'autre...

Tables de vérité des operateurs booléens

NOT (non)

       R = 1 (true) si l'expression est fausse.

       Syntaxe Delphi : NOT A

       A      R
       0      1
       1      0
 

AND (et)                   

       R = 1 (true) si toutes les expressions sont vraies.

       syntax Delphi : (A AND B)

       A      B      R
       0      0      0
       1      0      0
       0      1      0
       1      1      1
 

NOT AND (non-et)

       R = 1 (true) si l'une ou toutes les expressions sont fausse.

       syntax Delphi : NOT (A AND B)

       A      B      R
       0      0      1
       1      0      1
       0      1      1
       1      1      0

OR (ou)

       R = 1 (true) si l'une ou toutes les expressions sont vraie.

       syntax Delphi : (A OR B)

       A      B      R
       0      0      0
       1      0      1
       0      1      1
       1      1      1
 

NOT OR (non-ou)

       R = 1 (true) si toutes les expressions sont fausses.

       syntax Delphi : NOT (A OR B)

       A      B      R
       0      0      1
       1      0      0
       0      1      0
       1      1      0

XOR (ou exclusif)

       R = 1 (true) exclusivement si une seule expression est vraie

       syntax Delphi : (A XOR B)

       A      B      R
       0      0      0
       1      0      1
       0      1      1
       1      1      0

NOT XOR (non-ou exclusif)

       R = 1 (true) exclusivement si une toutes les expressions sont vraie ou fausse

       syntax Delphi : NOT (A XOR B)

       A      B      R
       0      0      1
       1      0      0
       0      1      0
       1      1      1

Operateurs relationnel et d'ensemble

    >      supérieur a
    <      inferieur a
    >=     supérieur ou égale a   //   est un sous-ensemble de
    <=     inferieur ou égale a   //   est un sous-ensemble de
    <>     différent de              
    =      égale a                  
    IN     est dans l'ensemble

Exemple d'opérations complexe et tables de vérité

R := (A AND B) OR (C AND D);

       R = 1 (true) si l'expression AB ou l'expression CD est vraie.

       A      B      C      D      R
       0      0      0      0      0
       0      0      0      1      0
       0      0      1      0      0
       0      0      1      1      1 (par CD)
       0      1      0      0      0
       0      1      0      1      0
       0      1      1      0      0
       0      1      1      1      1 (par CD)
       1      0      0      0      0
       1      0      0      1      0
       1      0      1      0      0
       1      0      1      1      1 (par CD)
       1      1      0      0      1 (par AB)
       1      1      0      1      1 (par AB)
       1      1      1      0      1 (par AB)
       1      1      1      1      1 (par AB ou CD)
                          

R := (A AND B) OR (NOT(C AND D));

       R = 1 (true) si l'expression AB est vrai ou si l'expression CD est fausse

       A      B      C      D      R
       0      0      0      0      1 (par CD)
       0      0      0      1      1 (par CD)
       0      0      1      0      1 (par CD)
       0      0      1      1      0
       0      1      0      0      1 (par CD)
       0      1      0      1      1 (par CD)
       0      1      1      0      1 (par CD)
       0      1      1      1      0
       1      0      0      0      1 (par CD)
       1      0      0      1      1 (par CD)
       1      0      1      0      1 (par CD)
       1      0      1      1      0
       1      1      0      0      1 (par AB ou CD)
       1      1      0      1      1 (par AB ou CD)
       1      1      1      0      1 (par AB ou CD)
       1      1      1      1      1 (par AB)                          

Exemple d'écriture de code grâce aux operateurs booléen

Cette fonction renvois true si V est supérieur ou égale à VMin ET inferieur ou égale à VMax

       function InRange(const V, VMin, VMax :integer) : boolean;
       begin
        result := (V >= VMin) and (V <= VMax);
       end;
 
cette fonction renvois true si V est inferieur a VMin OU superieur a VMax

       function OutRange(const V, VMin, VMax : integer) : boolean;
       begin
         result := (V < VMin) or (V > VMax);
       end;

 
Grace  a cela on peut également remplacer beaucoup de condition IF, Case Of, et de gagner beaucoup de temps, exemple :

Exemple 1 :

       if X = 2 then R := true else R := false;

       on remplacera par :

       R :X 2;

Exemple 2 :

       Case X of
          0,1,4,5 : R := false;
          2,3,6   : R := true;
       End;

       on remplacera par :

       R :(X 2) OR (X = 3) OR (X = 6);

       our encore (pour les trés longues méthodes case ou if), on peu utiliser les ensembles :

       R := X IN [2,3,6 * ;

Attention toute fois, les ensemble [a,b,c,d * ne supportent que les types scalaires.

Ecriture des booléens dans les conditions

Beaucoup font l'erreur d'ecrire leur conditions If, While, Repeat de cette manière :

  if booleen = true then
  while booleen = true then
  repeat ... until booleen = true;

voici donc la bonne méthode :

  if booleen then ... (la condition s'execute seulement si le booléen est égale à true)
  if not booleen then ... (la condition s'execute seulement si le booléen est égale à false)

exemple d'application de cette façon d'écrire :

  if checkbox1.checked then label1.caption := 'l''option est cochée';
  if not checkbox1.checked then label1.caption := 'l''option n'est pas cochée';
  if (checkbox1.checked) and (checkbox2.checked) then label1.caption := 'l''option 1 et 2 sont cochées';

on peu également faire :

const

BTC : array[boolean * of string = ('L’’option est cochée’,’L’’option n’’est pas cochée’) ;

Begin

label1.caption := BTC[checkbox1.checked * ;

end;

Adresse d'origine

Ce document intitulé « [bases] booléens, table de verités, syntaxe delphi » issu de CodeS SourceS (codes-sources.commentcamarche.net) est mis à disposition sous les termes de la licence Creative Commons. Vous pouvez copier, modifier des copies de cette page, dans les conditions fixées par la licence, tant que cette note apparaît clairement.
Rejoignez-nous