Cours complet pour apprendre à programmer en D

13. Lire à partir de l'entrée standard▲

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

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

	flux :	stdout
	opération :	write
	donnée :	la valeur de la variable nombreÉtudiants
	cible :	habituellement, la console

L'inverse de write est readf ; cette opération lit à partir de l'entrée standard. Le « f » dans son nom vient de « formaté » puisque ce qu'elle lit doit toujours respecter un format précis.

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

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

	flux :	stdin
	opération :	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 où sa valeur est stockée dans la mémoire de l'ordinateur.

En D, le caractère & qui est placé avant le nom indique l'adresse de ce que le nom représente. Par exemple, l'adresse de ce que stocke nombreÉtudiants est &nombreÉtudiants. Ici, &nombreÉtudiants peut être lu comme : « l'adresse de nombreÉtudiants ». C'est la pièce manquante qui va remplacer le point d'interrogation ci-dessus :

	flux :	stdin
	opération :	readf
	données :	une information
	cible :	l'emplacement de la variable nombreÉtudiants

Mettre un & 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 laisse pour plus tard une spécificité relative à l'utilisation de readf ; pour l'instant, considérons que le premier argument de readf doit être "%s" :

Sélectionnez

readf("%s", &nombreÉtudiants);

Comme expliqué plus loin, dans la plupart des cas, il doit y avoir un caractère espace avant le caractère % : « %s ».

"%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 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 saisi les données.

Sélectionnez

import std.stdio;
 
void main()
{
    write("Combien y a-t-il d'étudiants ici ? ");
 
   /*
    * La définition de la variable qui va être utilisée pour
    * enregistrer l'information qui est lue depuis l'entrée.
    */
    int nombreÉtudiants;
 
    // Stockage de l'entrée dans cette variable.
    readf("%s", &nombreÉtudiants);
 
    writeln("J'ai obtenu : il y a ", nombreÉtudiants, " étudiants.");
}

13-1. Sauter les caractères blancs▲

Même la touche Entrée sur laquelle nous appuyons après avoir saisi les données est stockée comme un code spécial puis est placée dans le flux stdin. C'est utile aux programmes pour déterminer si l'information a été saisie en une seule ou plusieurs lignes.

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

Pour observer ce problème dans un programme, lisons également le nombre d'enseignants à partir de l'entrée :

Sélectionnez

import std.stdio;
 
void main()
{
    write("Combien y a-t-il d'étudiants ici ? ");
    int nombreÉtudiants;
    readf("%s", &nombreÉtudiants);
 
    write("Combien y a-t-il d'enseignants ici ? ");
    int nombreEnseignants;
    readf("%s", &nombreEnseignants);
 
    writeln("J'ai obtenu: Il y a ", nombreÉtudiants, " étudiants",
            " et ", nombreEnseignants, " enseignants.");
}

Malheureusement, le programme ne sait pas quoi faire de ce code spécial et reste bloqué alors qu'il attend le deuxième entier :

Sélectionnez

Combien y a-t-il d'étudiants ici ? 100
Combien y a-t-il d'enseignants ici ? 20
← Une exception (erreur) est générée ici

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

Le code qui bloque l'entrée est surligné.

La solution consiste à insérer un caractère espace avant %s pour indiquer que le code d'entrée qui apparaît avant la lecture du nombre d'enseignants n'est pas important : " %s". Les espaces présents dans la chaîne de formatage sont utilisés pour lire et ignorer zéro ou plus caractères invisibles qui sinon bloqueraient l'entrée. Ces caractères sont 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 " %s" pour n'importe quelle donnée lue depuis l'entrée. Le programme précédent fonctionne comme attendu avec les changements suivants :

Sélectionnez

// ...
    readf(" %s", &nombreÉtudiants);
// ...
    readf(" %s", &nombreEnseignants);
// ...

La sortie :

Sélectionnez

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.

13-2. Informations additionnelles▲

Les lignes qui commencent par // sont utiles en tant que lignes de commentaires simples. Pour écrire un commentaire sur plusieurs lignes, entourez ces lignes par /* et */.

Pour commenter du code, y compris d'autres commentaires, utilisez /+ et +/ :

Sélectionnez

/+
       // un commentaire simple d'une ligne
     
       /*
          Un commentaire
          sur plusieurs lignes
       */
     
       Un bloc de commentaire qui inclus d'autres commentaires
    +/

La plupart des caractères blancs présents dans le code source ne sont pas significatifs. Écrire des expressions longues sur plusieurs lignes ou ajouter des espaces en plus pour rendre le code plus lisible est une bonne pratique. Cependant, tant que la syntaxe est respectée, les programmes peuvent être écrits sans aucun caractère blanc additionnel :

Sélectionnez

import std.stdio;void main(){writeln("Difficile à lire !");}

Il peut être difficile de lire un code source qui contient si peu de caractères blancs.

13-3. Exercice▲

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

SolutionLire depuis l'entrée - Correction.