Entrées et sorties

01 - Introduction 04 - Entrée
02 - Sortie 05 - Références
03 - Formatage de la sortie

01

Introduction

On appelle les entrées et sorties d'un programme les différentes possibilités par lesquelles un programme peut interagir avec son environnement. Dans un système d'exploitation par exemple, les entrées sont les données envoyées par un périphérique (clavier, souris, disque, réseau ...) et les sorties sont les données à destination d'un périphérique (écran, carte son, réseau, disque ...).

Delphi dispose de plusieurs entrées et sorties, comme par exemple les fichiers texte. Il existe cependant une entrée et sortie standard, qui permettent au programme d'interagir avec l'utilisateur: le clavier et l'écran.

flux_standard.png

02

Sortie

Delphi met à disposition deux instructions (qui sont en effet des procédures), qui permettent d'afficher une information à l'écran :

Les paramètres de ces deux instructions doivent être des expressions évaluables (et donc syntaxiquement correctes) qui peuvent contenir des valeurs littérales (valeurs fixes), des variables ou même des opérations et appels de fonctions.

Exemples d'expressions
writeln(3);               { affichage de la valeur littérale 3 }
writeln(5.64);            { affichage de la valeur littérale 5.64 en notation scientifique }
writeln('bonjour');       { affichage de la valeur littérale « bonjour » }
writeln(vitesseMaximale); { affichage de la valeur de la variable « vitesseMaximale » }
writeln(4 + 5);           { affichage du résultat de l'addition de 4 et de 5 }
writeln(sqr(3));          { affichage du carré de 3 }
writeln(-b / (2*a));      { affichage de la racine double dans le cas où le discriminant est nul }

Attention: En Delphi, on utilise l'apostrophe « ' » pour entourer du texte. Si un texte contient une apostrophe, il faut en mettre deux de suites, sinon Delphi pense que cette apostrophe termine le texte. Ce problème se pose aussi lors de l'affectation d'une variable de type string.

Exemples d'affichage de texte avec apostrophes
writeln('Je m''appelle Luc.');
writeln('Bonjour Monsieur ''''Gaston''''');

Les deux instructions ont encore une autre propriété: elles permettent un nombre variable de paramètres. Il est donc possible d'afficher une ou plusieurs expressions dans une seule instruction en les séparant par des virgules.

Exemples d'appels avec plusieurs paramètres
writeln('Bonjour Monsieur ', nomDeLaPersonne);
writeln('La somme de a et de b vaut : ', a+b);
writeln('Racine carrée de 64 : ', sqrt(64));

Dans le cas où writeln a plusieurs paramètres, un seul retour à la ligne est rajouté après l'affichage de toutes les informations.

03

Formatage de la sortie

L'affichage à l'écran peut être personnalisé facilement par le programmeur. Bien que cette personnalisation peut avoir un grand effet sur l'affichage des informations à l'écran (par exemple un arrondissement vers le haut), ces modifications sont purement esthétiques et ne modifient pas la valeur d'une variable.

Formatage d'un nombre entier

Il est possible de définir le nombre de positions que l'affichage doit avoir au minimum en utilisant la syntaxe suivante :

writeln(<expression> : <positions>);

où <expression> est une valeur littérale ou le nom d'une variable et <positions> le nombre de positions au minimum.

Si le nombre de chiffres est inférieur au nombre de positions souhaitées, le nombre sera précédé par suffisamment d'espaces.

Exemples de formatages d'un nombre entier
{
 Soit X une variable de type « integer » ayant une valeur de 42.
}

writeln(7);   { va afficher '7' }
writeln(7:4); { va afficher '   7', càd le chiffre 7 précédé de trois espaces }
writeln(X:3); { va afficher ' 42', càd le nombre 42 précédé d'un espace }
writeln(X:1); { va afficher '42' }

Formatage d'un nombre réel

Delphi affiche les nombres réels par défaut en notation scientifique (notation avec exposant de puissance à base 10). Souvent, une notation décimale est préférable et peut être réalisé grâce aux formatages.

Il est possible de définir le nombre de positions que l'affichage doit avoir au minimum ainsi que le nombre de positions décimales en utilisant la syntaxe suivante :

writeln(<expression> : <positions> : <décimales>);

où <expression> est une valeur littérale ou le nom d'une variable, <positions> le nombre de positions au minimum (y compris la virgule et les positions éventuelles rajoutées par l'affichage de la partie décimale) et <décimales> le nombre de positions derrière la virgule.

Si le nombre de positions derrières la virgule est inférieur au nombre de chiffres de la partie décimale, Delphi va arrondir le résultat en utilisant la méthode Round half to even.

Exemples de formatages d'un nombre réel
{
 Soit X une variable de type « real » ayant une valeur de 23.7
}

writeln(74.8:6:2);  { va afficher ' 74.80' }
writeln(55.35:8:1); { va afficher '    55.4' }
writeln(12.25:2:1); { va afficher '12.2' }
writeln(X:2:0);     { va afficher '24' }

Si vous êtes seulement intéressés par le nombre de positions de la partie décimale, je vous conseille d'utiliser toujours zéro pour le nombre de positions au minimum.

Formatage d'une chaîne de caractères

Il est possible de définir le nombre de positions que l'affichage doit avoir au minimum en utilisant la syntaxe suivante :

writeln(<expression> : <positions>);

où <expression> est une valeur littérale ou le nom d'une variable et <positions> le nombre de positions au minimum.

Si le nombre de caractères est inférieur au nombre de positions souhaitées, la chaîne sera précédée par suffisamment d'espaces.

Exemples de formatages d'une chaîne de caractères
{
 Soit X une variable de type « string » ayant la valeur 'bonjour'.
}

writeln('abc':8); { va afficher '     abc' }
writeln(X:8);     { va afficher ' bonjour' }
writeln(X:3);     { va afficher 'bonjour' }

04

Entrée

Attention: ce chapitre nécessite que le lecteur se soit familiarisé avec le concept de variables.

Delphi met à disposition l'instruction readln, qui permet de lire une valeur du clavier et de la stocker dans une variable, qui est passée en argument. L'utilisateur doit toujours terminer l'entrée avec la toucher « Enter ». Il existe aussi une instruction read, cependant celle-ci est utilisée plus souvent dans la manipulation de fichiers texte.

Exemple de la lecture d'une valeur
{
 Soit X une variable de type « integer »
}

readln(X); { va attendre jusqu'à ce que l'utilisateur ait entré un nombre entier }

Lors de la lecture d'une valeur avec Readln(), Delphi analyse automatiquement cette valeur et essaie de la convertir dans le bon format selon le type de variable. Si cette conversion n'est pas possible, le programme s'arrête avec un message d'erreur.

Exemple d'une saisie invalide
{
 Soit X une variable de type « integer »
}

readln(X);

{
 L'instruction readln(X) va attendre jusqu'à ce que l'utilisateur ait entré un nombre entier.
 S'il entre une valeur invalide, comme par exemple du texte, le programme se termine avec le
 message d'erreur « Invalid numeric input »
}

Tout comme write et writeln, readln permet aussi un nombre variable de paramètres. Il est donc possible de lire plusieurs valeurs en une seule instruction et de les stocker dans les variables respectives. Dans ce cas, l'utilisateur peut séparer les valeurs par un blanc ou par un retour à la ligne.

Exemple de la lecture de plusieurs valeurs
{
 Soient X, Y et Z trois variables de type « integer »
}

readln(X, Y, Z); { va attendre jusqu'à ce que l'utilisateur ait entré trois nombres entier }

Il est important de remarquer qu'il faut introduire une valeur et non pas une expression à évaluer.

Si le programme attend un nombre et que l'utilisateur introduit par exemple -2+5, alors le système va interrompre l'exécution avec un message d'erreur!

Si le programme attend une chaîne de caractères, alors ce type d'erreur ne peut pas arriver car '-2+5' est une chaîne valable. Il n'est évidemment pas garanti que le programme va en faire un usage intelligent. Il ne va en aucun cas évaluer l'expression!

05

Références

Les explications et les exemples sont inspirés par le livre Les générations PASCAL de Serge Linckels.

Sign In