Cours complet pour apprendre à programmer en D

Les expressions logiques sont les expressions qui sont utilisées en arithmétique booléenne. Les expressions logiques sont ce qui fait qu'un programme prend des décisions comme « si la réponse est oui, j'enregistrerai ce fichier ».

Les expressions logiques ne peuvent prendre qu'une valeur parmi les deux possibles : false (faux) qui indique que l'expression est fausse et true (vrai) qui indique que l'expression est vraie.

J'utiliserai des expressions writeln dans les exemples qui suivent. Si une ligne se finit par true, cela voudra dire que ce qui est affiché sur la ligne est vrai. De même, false voudra dire que ce qui est sur la ligne est faux. Par exemple, si la sortie d'un programme est la suivante :

Il y a du café : true

Cela voudra dire qu'« il y a du café ». De même,

Il y a du café : false

voudra dire qu'« il n'y a pas de café ». Notez que le fait que « il y a » apparaît sur la gauche de la ligne ne veut pas dire que du café est présent. J'utilise la construction « Il y a… : false » pour dire « il n'y a pas » ou « c'est faux ».

Les expressions logiques sont utilisées de façon intensive dans les instructions conditionnelles, les boucles, les paramètres de fonctions, etc. Il est essentiel de comprendre comment elles fonctionnent. Heureusement, les expressions logiques sont très faciles à expliquer et utiliser.

Les opérateurs logiques qui sont utilisés dans les expressions logiques sont les suivants :

• l'opérateur == répond à la question « est égal à ? ». Il compare les deux expressions à sa droite et à sa gauche et produit true si elles sont égales et false si elle ne sont pas égales. Par définition, la valeur que == produit est une expression logique.
  Par exemple, supposons que nous ayons les deux variables suivantes :

   

  Sélectionnez

  int joursDansUneSemaine = 7;
  int moisDansUneAnnée = 12;

• Les expressions suivantes sont deux expressions logiques qui utilisent ces valeurs :

   

  Sélectionnez

  joursDansUneSemaine == 7      // true
  moisDansUneAnnée == 11        // false

• l'opérateur != répond à la question « n'est pas égal à ? ». Il compare les deux expressions contiguës et produit l'opposé de ==
  .

   

  Sélectionnez

  joursDansUneSemaine != 7      // false
  moisDansUneAnnée != 11        // true

• l'opérateur || veut dire « ou » et produit true si l'une ou l'autre des expressions qui sont à ses côtés est vraie.
  Si la valeur de l'expression de gauche est true, il produit la valeur true sans même évaluer l'autre expression. Si l'expression du côté gauche est fausse, alors l'opérateur produit la valeur de l'expression de droite. Cet opérateur est similaire à la conjonction « ou » du français dans le sens où si l'une, l'autre ou les deux expressions sont vraies, alors il produit true.
  Toutes les valeurs possibles des deux côtés de cet opérateur et leur résultat sont présentés dans cette table de vérité :

  Expression de gauche	Expression de droite	Résultat
  false	false	false
  false	true	true
  true	false (non évalué)	true
  true	true (non évalué)	true

   

  Sélectionnez

  import std.stdio;
   
  void main()
  {
       // false veut dire « non », true veut dire « oui »
   
      bool ilYADuCafé = false;
      bool ilYADuThé = true;
   
      writeln("Il y a une boisson chaude : ",
              ilYADuCafé || ilYADuThé);
  }

  Du fait qu'une des deux expressions est vraie, l'expression logique de ce programme produit true.

  • L'opérateur && signifie « et », et produit true si les deux expressions sont vraies.
    Si la valeur de l'expression de gauche est fausse, il produit false sans même évaluer l'expression qui est à sa droite. Si l'expression de gauche est vraie, alors il produit la valeur de l'expression de droite. Cet opérateur est similaire à la conjonction « et » du français : si la valeur de gauche et la valeur de droite sont toutes les deux true, alors il produit true.

    Expression de gauche	Expression de droite	Résultat
    false	false (non évalué)	false
    false	true (non évalué)	false
    true	false	false
    true	true	true

     

    Sélectionnez

    writeln("Je vais boire du café: ",
          jeVeuxBoireDuCafé && ilYADuCafé);

    Le fait que les opérateurs || et && peuvent ne pas évaluer l'expression de droite est appelé « comportement raccourci ». Le seul autre opérateur qui a ce comportement est l'opérateur ternaire ? : qui sera vu dans un prochain chapitre. Tous les autres opérateurs évaluent et utilisent toujours toutes leurs expressions.

• l'opérateur ^ répond à la question « l'un ou l'autre ? ». Cet opérateur produit true si seule une expression est vraie, mais pas les deux.

  Expression de gauche	Expression de droite	Résultat
  false	false	false
  false	true	true
  true	false	true
  true	true	false

• Par exemple, la logique qui représente mon choix de jouer aux échecs si un seul de mes deux amis arrive peut être codé ainsi :

   

  Sélectionnez

  writeln("Je jouerai aux échecs : ", jimEstApparu ^ bobEstApparu);

• l'opérateur < répond à la question « est plus petit que ? » (ou « vient avant dans l'ordre de tri ? »).

   

  Sélectionnez

  writeln("Nous gagnons : ", leurScore < notreScore);

• l'opérateur > répond à la question «  est plus quand que ? » (ou « vient après dans l'ordre de tri ? »).

   

  Sélectionnez

  writeln("Ils gagnent : ", leurScore > notreScore);

• l'opérateur <= répond à la question « est inférieur ou égal ? » (ou « vient avant ou au même endroit que ? »). Cet opérateur est l'opposé de l'opérateur >.

   

  Sélectionnez

  writeln("Nous n'avons pas été vaincus : ", leurScore <= notreScore);]

• l'opérateur >= répond à la question « est supérieur ou égal à ? » (ou « vient après ou au même endroit que ? »). Cet opérateur est l'opposé de l'opérateur <.

   

  Sélectionnez

  writeln("Nous n'avons pas gagné : ", leurScore >= notreScore);

• l'opérateur ! veut dire « l'opposé de ». Différent des autres opérateurs logiques, il prend une seule expression et produit true si cette expression est fausse, et false si cette expression est vraie.

writeln("Je marcherai : ", !ilYAUnVélo);

12-1-1. Grouper les expressions▲

writeln("Je suis content : ",
   (ilYADuCafé || ilYADuThé) && (ilYADesCookies || ilYADesPains));

writeln("Je suis content : ",
   ilYADuCafé || ilYADuThé && ilYADesCookies || ilYADesPains);

writeln("Je suis content : ",
   ilYADuCafé || (ilYADuThé && ilYADesCookies) || ilYADesPains);

12-1-2. Lire un booléen en entrée▲

12-1-3. Exercices▲

import std.stdio;
import std.conv;
import std.string;
 
void main()
 {
    write("Combien sommes-nous ? ");
    int nombrePersonnes;
    readf(" %s", &nombrePersonnes);
 
    write("Combien y a-t-il de vélos ? ");
    int nombreVélos;
    readf(" %s", &nombreVélos);
 
    write("À quelle distance est la mer ? ");
    int distance;
    readf(" %s", &distance);
 
    bool existeUneVoiture = read_bool("Y a-t-il une voiture ? ");
    bool existeUnPermis =
      read_bool("Y a-t-il un permis de conduire ? ");
 
    /*
      Remplacez la valeur 'true' ci-dessous par une expression logique qui
      produit la valeur true quand l'une des conditions
      listées dans la question est satisfaite :
   */
    writeln("Nous allons à la mer : ", true);
}
 
/*
Cette fonction utilise des fonctionnalités qui seront
expliquées dans des chapitres suivants.
*/
bool read_bool(string message)
{
    // Afficher le message
    write(message, "(false ou true) ");
 
    // Lire une ligne comme une chaîne
    string input;
    while (input.longueur == 0) {
      input = chomp(readln());
    }
 
    // Produire une valeur 'bool' depuis cette chaîne
    bool résultat = to!bool(input);
 
    // Retourner le résultat
    return résultat;