Lecture et affichage

Données et résultats d'un traitement

De nombreux traitements informatiques peuvent se schématiser suivant les trois étapes suivantes:

Lecture-Traitement-Resultat.jpg, 29kB
L'image du sourd-muet qui ne sais pas additionner

Pour bien comprendre le sens des termes lecture, traitement et affichage, mettez vous à la place de l'ordinateur. Votre rôle est d'additionner mentalement deux nombres pour un sourd-muet qui ne sait pas calculer (l'utilisateur).

Comme il ne peut pas parler, il vous écrit les deux nombres à additionner sur un bout de papier, qui joue le role de l'écran.

Vous ne pouvez pas additionner les deux nombres si vous ne les connaissez pas. Il faut donc commencer par les lire. C'est la première étape de lecture des données.

A présent, les deux nombres à additionner sont dans votre mémoire. Vous pouvez donc effectuer le traitement, qui consiste à additionner mentalement ces deux nombres. C'est l'étape de traitement des données.

Vous avez le résultat. Mais si vous ne le communiquez pas à l'utilisateur, c'est comme si vous n'aviez rien fait. Comme il est sourd vous allez écrire le résultat sur le bout de papier. C'est la troisième étape: l'affichage des résultats du traitement.

Pour un ordinateur

Pour un ordinateur c'est un peu la même chose:

  1. Lire les données signifie transférer des informations affichées à l'écran vers la mémoire, ou plus précisémment vers une variable-donnée, c'est à dire une variable prévue pour stocker une donnée du traitement.
    2. Lire.jpg, 41kB
  2. Traiter les données signifie grosso-modo faire des calculs qui dépendent des données pour produire des résultats. En principe, mais ce n'est pas obligatoire, chaque résultat est stockée dans une variable-résultat. La programmation de cette étape sera vue plus loin dans le cours lorsque nous parlerons d'expression et d'affectation.
    3. Traitement.jpg, 34kB
  3. Si les résultats ont été sauvegardés dans des variables résultats, Afficher les résultats signifie afficher la valeur de chacune de ces variables à l'écran. Il est également possible d'afficher les résultats d'un traitement sans les avoir au préalable sauvegardés dans des variables. Mais il serait difficile pour l'instant d'expliquer comment. Nous verrons cela un peu plus loin.
    4. Afficher-Resultat.jpg, 47kB
Exemple du programme d'addition

Reprenons l'exemple de l'addition de deux nombres.

Lire les données signifierait dans ce cas lire les valeurs des deux nombres à additionner depuis (par exemple) deux zones de texte pour les stocker dans deux variables données X et Y.

LireX-Y.jpg, 43kB

Traiter les données signifierait additionner les valeurs des variables X et Y, puis mémoriser le résultat dans une variable Somme.

Traitement-Addition.jpg, 50kB

Enfin, afin afficher les résultats signifierait afficher la valeur de la variable somme dans la zone de texte prévue à cet effet.

Afficher-Somme.jpg, 55kB


Historique

Avant l'apparution des interfaces graphiques, tous les langages de programmation avaient des procédures (cette notion sera abordée dans le chapitre sous-programmes) pour lire et afficher.

En Pascal, par exemple elles s'appellent readln (pour la lecture) et writeln (pour l'écriture).

La procédure writeln

La procédure writeln, vous permettait d'afficher un texte à l'écran. Par exemple l'instruction: 

writeln ('Hello world !');

vous affichait le texte 'Hello Word' à l'écran, comme ceci (en supposant que l'écran était vide avant l'exécution de l'instruction):

Writeln-Hello-World.jpg, 20kB

Avec la procédure writeln, vous pouviez également afficher la valeur d'une variable à l'écran. Par exemple, en supposant que la variable Somme contienne la valeur 2013, l'instruction: 

writeln (Somme);

vous affichait 2013 à l'écran, comme ceci:

Writeln-2013.jpg, 19kB

Chaque writeln, affichait donc une nouvelle ligne à la suite des lignes déjà affichées à l'écran.

La procédure readln

La procédure readln permettait de lire la valeur d'une variable tapée au clavier (et donc affichée à l'écran).

Supposons par exemple qu'un programme exécute l'instruction suivante: 

readln (X);

où X représente un nombre entier.

Dès que l'instruction est exécutée, le programme est momentanément interrompu. Le système d'exploitation prend alors la main et range chaque caractère saisi par l'utilisateur dans un buffer associé au clavier. Dès que l'utilisateur appuie sur la touche Entrée le contenu du buffer est renvoyé au programme qui stocke alors la valeur correspondante dans la variable X et continu son exécution.

ETBib

ETBib est une unité Pascal que j'ai écrite afin d'introduire des procédures équivalentes à readln et writeln fonctionnant avec une interface graphique.

Ces procédures sont les suivantes:

Ces procédures ont été introduites pour des raisons pédagogiques (explications pour le lecteur averti). Donc gardez bien à l'esprit qu'elles ne font pas partie du langage Pascal.

Exemple d'utilisation des procédures de ETBib

Pour expliquer le fonctionnement des procédures de ETBib, nous allons prendre un exemple de programme qui permet de lire et d'afficher trois variables:

Voici l'interface graphique du programme :

Population.jpg, 19kB
Lecture des variables

La lecture des trois variables est déclenchée par le bouton Lire. Voici la procédure évènementielle associée: 

procedure TForm1.BT_LireClick(Sender: TObject);
begin
  Lire (Ville,ZT_Ville);
  LireEntier (CP, ZT_CodePostal);
  LireNombre (NH,ZT_Hab);
end;

La procédure de lecture à utiliser dépend du type de la variable: Lire pour lire une variable de type String, LireEntier pour lire une variable de type Integer et LireNombre pour lire une variable de type Double.

Entre parenthèses figurent:

Rappelez vous que chaque zone de texte est associé à un buffer qui se rempli avec les caractères frappés au clavier.

Lorsque la variable est de type chaine de caractères, la procédure de lecture ne fait que recopier ces caractères dans la variable.

S'il s'agit d'une variable de type Integer ou Double, il ne suffit pas de recopier le buffer dans la variable. Le contenu du buffer est tout d'abord codé en base 2, puis c'est le résultat de ce codage qui est stocké dans la variable.


Affichage des variables

L'affichage des trois variables se fait par le bouton Afficher dont voici la procédure évènementielle: 

procedure TForm1.BT_AfficherClick(Sender: TObject);
begin
  Afficher (Ville, ZT_Ville);
  AfficherEntier (CP, ZT_CodePostal);
  AfficherNombre (NH, ZT_Hab);
end;

Comme pour la lecture, il faut choisir la procédure d'affichage en fonction du type de la variable : Afficher pour afficher une variable de type String, AfficherEntier pour une variable de type integer et AfficherNombre pour une variable de type Double.

Dans les parenthèses, on précise le nom de la variable à afficher, puis le nom de la zone de texte dans laquelle on souhaite l'afficher.

La procédure Afficher recopie simplement le contenu de la variable dans le buffer qui est ensuite affiché dans la zone de texte par le système d'exploitation.

Dans le cas des procédure AfficherNombre et AfficherEntier, un décodage préalable est nécessaire avant de recopier la chaine de caractère représentant le nombre dans le buffer.


Effacement des zones de texte

L'effacement des zones de texte s'effectue avec le bouton Effacer dont voici la procédure évènementielle: 

procedure TForm1.BT_EffacerClick(Sender: TObject);
begin
  Effacer (ZT_Ville); Effacer (ZT_Hab);
  Effacer (ZT_CodePostal);
end;

Il suffit ici de préciser entre parenthèse le nom de la zone de texte à effacer.

Argumentation pédagogique

Cette section s'adresse au lecteur averti (professeur ou élève avancé) désirant comprendre la raison pour laquelle j'ai introduit les procédures de lecture et d'affichage.

Reprenons notre exemple. Voici comment lire les trois variables sans utiliser les procédures Lire, LireEntier et LireNombre: 

procedure TForm1.BT_LireClick(Sender: TObject);
begin
  Ville := ZT_Ville.Text;
  CP := StrToInt(ZT_CodePostal.Text);
  NH := StrToFloat (ZT_Hab.Text);
end;

Ce qui me gène ici est l'utilisation obligatoire de la programmation objet. On accède à l'attribut Text de la classe TEdit. C'est encore pire lorsqu'il s'agit d'afficher du texte dans une zone de liste puisqu'il faut alors appliquer la méthode Add à l'attribut items (objet de la classe TStringList) d'un objet de la classe TListBox.

Or, je pense que l'on peut difficilement commencer un cours de programmation avec des notions de programmation objet. A mon sens la programmation objet, ne peut être abordée qu'après avoir bien assimilé les types structurés (puisque les objets sont en quelque sorte des types structurés étendus) et les sous-programmes (puisque les méthodes sont des sous-programmes associés à des classes).

Mis à part la programmation objet, d'autres arguments peuvent être ajoutés en faveur de l'utilisation des procédures de lecture et d'affichage: