programmez-en-d/entree.whata

[set
    title       = "Lire depuis l'entrée standard"
    partAs      = chapitre
    translator  = "Raphaël Jakse"
    proofreader = "Stéphane Goujet"
]

Toute donnée lue par le programme doit d'abord être stockée dans une variable. Par exemple, un programme lisant le nombre d'étudiants depuis l'entrée doit d'abord enregistrer cette information dans une variable. Le type de cette variable spécifique peut être [c int].

Comme on l'a vu dans le chapitre précédent, nous n'avons pas besoin de taper [c stdout] quand nous affichons sur la sortie, parce que c'est sous-entendu. De plus, ce qui est à afficher est spécifié comme argument. [c write(nombreEtudiants)] est donc suffisant pour afficher la valeur de [c nombreEtudiants]. Pour résumer~ :

|=flux~ :      | [c stdout]
|=opération~ : | [c write]
|=donnée~ :    | la valeur de la variable nombreEtudiants
|=cible~ :     | communément, la console

L'inverse de [c write] est [c readf]~ ; elle lit depuis l'entrée standard. Le "f" dans son nom vient de "formaté" puisque ce qu'elle lit doit toujours suivre un format précis.

Nous avons également vu dans le chapitre précédent que le flux d'entrée standard est [c stdin].

Dans le cas de la lecture, il manque encore une pièce du puzzle~ : où stocker les données. Pour résumer~ :

|=flux~ :      | [c stdin]
|=opération~ : | [c readf]
|=données~ :   | une information
|=cible~ :     | ?

Le lieu où l'on stocke les données est spécifié par l'adresse d'une variable. L'adresse d'une variable est l'endroit exact dans la mémoire de l'ordinateur où sa valeur est stockée.

En D, le caractère [c &] qui est tapé avant le nom est l'adresse de ce que le nom représente. Par exemple, l'adresse de ce que stocke [c nombreEtudiants] est [c &nombreEtudiants]. Ici, [c &nombreEtudiants] peut être lu comme~ : «~ l'adresse de nombreEtudiants~ » et est la pièce manquante qui va remplacer le point d'interrogation ci-dessus~ :

|=flux~ :      | [c stdin]
|=opération~ : | [c readf]
|=données~ :   | une information
|=cible~ :     | l'endroit de la variable [c nombreEtudiants]

Taper un [c &] devant un nom signifie [* pointer] vers ce que le nom représente. Ce concept est le fondement des références et des pointeurs que nous verrons dans les chapitres suivants.

Je laisserai une particularité à propos de l'utilisation de [c readf] pour plus tard ; pour l'instant, acceptons comme une règle que le premier argument de [c readf] doit être [c=d "%s"] :

[code=d readf("%s", &nombreEtudiants);]

[p Note~ : | Comme expliqué plus bas, dans la plupart des cas, il devrait y avoir une espace~ : [c=d " %s"].]

[c=d "%s"] indique que les données devraient automatiquement être converties d'une manière qui convient pour le type de la variable. Par exemple, quand les caractères '4' et '2' sont lus et enregistrés dans une variable de type [c int], ils sont convertis vers la valeur entière 42.

Le programme ci-dessous demande à l'utilisateur d'entrer le nombre d'étudiants. Vous devez appuyer sur la touche "Entrée" après avoir tapé les données.

[code=d <<<
   import std.stdio;

   void main()
   {
       write("Combien y a-t-il d'étudiants ici ? ");

      /*
       * La définition de la variable qui va être utilisé pour
       * enregistrer l'information qui est lue depuis l'entrée.
       */
       int nombreEtudiants;

       // Stockage de l'entrée dans cette variable.
       readf("%s", &nombreEtudiants);

       writeln("J'ai obtenu : il y a ", nombreEtudiants, " étudiants.");
   }
>>>]

[ = Sauter les caractères blancs

   Même la touche Entrée sur laquelle nous appuyons après avoir tapé les données est stockée comme un code spécial et est placée dans le flux [c stdin]. C'est utile pour les programme pour détecter si l'information a été entrée sur une seule ligne ou plusieurs lignes.

   Même si c'est utile de temps en temps, de tels codes ne sont en général pas important pour le programme et doivent être retirés depuis l'entrée. Autrement, ils bloquent l'entrée et empêchent de lire d'autres données.

   Pour voir ce problème dans un programme, lisons également le nombre d'enseignants depuis l'entrée~ :

   [code=d <<<
      import std.stdio;

      void main()
      {
          write("Combien y a-t-il d'étudiants ici ? ");
          int nombreEtudiants;
          readf("%s", &nombreEtudiants);

          write("Combien y a-t-il d'enseignants ici ? ");
          int nombreEnseignants;
          readf("%s", &nombreEnseignants);

          writeln("J'ai obtenu: Il y a ", nombreEtudiants, " étudiants",
                  " et ", nombreEnseignants, " enseignants.");
      }
   >>>]

   Malheureusement, le programme reste bloqué quand il doit lire le second entier~ :

   [output <<<
      Combien y a-t-il d'étudiants ici ? 100
      Combien y a-t-il d'enseignants ici ? 20

      >>>[color=red ← Le programme reste bloqué ici]
   ]

   Même si l'utilisateur entre un nombre d'enseignants comme 20, le ou les codes spéciaux qui représentent la touche entrée sur laquelle on a appuyé quand on a entré 100 sont toujours dans le flux d'entrée et le bloquent. Les caractères qui sont apparus dans le flux d'entrée sont à peu près ceux-là~ :

   [input 100[color=red <Code d'entrée>]20<code d'entrée>]

   Le code d'entrée qui bloque l'entrée est marqué en rouge.

   La solution à utiliser est l'espace avant [c %s] pour indiquer que le code d'entrée qui apparaît avant la lecture du nombre d'enseignants n'est pas important~ : [c " %s"]. Sans cela, les espaces qui sont dans la chaîne de formatage sont utilisés pour lire et ignorer 0 ou plus de caractères invisibles qui bloqueraient l'entrée. De tels caractères comprennent le caractère espace, le ou les codes qui représentent la touche Entrée, le caractère tabulation, etc. et ils sont appelés les caractères blancs (''whitespace'').

   Comme règle générale, vous pouvez utiliser [c " %s"] pour n'importe quelle donnée lue depuis l'entrée. Le programme précédent marche comme attendu avec les changements suivants :

   [code=d <<<
      // ...
          readf(" %s", &nombreEtudiants);
      // ...
          readf(" %s", &nombreEnseignants);
      // ...
   >>>]

   La sortie :
   [output <<<
      Combien y a-t-il d'étudiants ici ? 100
      Combien y a-t-il d'enseignants ici ? 20
      J'ai obtenu : Il y a 100 étudiants et 20 enseignants.
   >>>]
]
[ = Informations additionnelles

   - [
        Les lignes qui commencent par [c //] sont utiles pour les lignes de commentaires simples. Pour écrire plusieurs lignes comme un seul commentaire, il faut entourer les lignes par [c /*] et [c */].

        Pour commenter du code et même d'autres commentaires, utilisez [c /+] et [c +/]~ :
        [code=d <<<
         /+
            // un commentaire simple d'une ligne

            /*
               Un commentaire
               sur plusieurs lignes
            */

            Un bloc de commentaire qui comprends d'autres commentaires
         +/
        >>>]
   ]
   - [
        La plupart des caractères blancs dans le code source n'ont pas d'importance. Écrire des expressions longues sur plusieurs lignes ou ajouter des espaces en plus pour rendre le code plus lisible est une bonne pratique. Malgré tout, tant que la syntaxe est respectée, les programmes peuvent être écrits sans aucun caractère blanc additionnel~ :

        [code=d import std.stdio;void main(){writeln("Difficile à lire !");}]

        Il est difficile de lire un code source qui présente si peu de caractères blancs.
   ]
]
[ = Exercice

   Entrez un caractère non numérique quand le programme attend des valeurs entières et observez que le programme ne fonctionne pas correctement.

   [[part:corrections/entree | … La solution]]
]