L'écriture des littéraux obéit à un certain nombre de conventions qui dépendent du type et du langage de programmation.

Les littéraux numériques

Un littéral numérique représente la valeur d'un nombre.

Il existe de nombreuses manières d'écrire un nombre. On peut par exemple avoir:

• une simple suite de chiffres. Cette écriture ne convient que pour les nombres entiers positifs. Exemple: 2012
• pour pouvoir représenter des entiers relatifs, il faut autoriser la présence d'un signe + ou - devant cette suite de chiffres. Exemple -15, +320
• pour pouvoir représenter des nombres non entier on utilise le point. La partie entière du nombre est suivi d'un point puis d'une autre suite de chiffres. Exemples: 3.141559, -5.33333
• Pour pouvoir représenter des nombres très grands ou très petits, on autorise également la notation scientifique. Exemple: 1.7E+308

Un littéral de type chaine de caractères s'écrit entre quotes.

Par exemple 'Il fait beau', '4012', '(3 x + 1)', 'VisualC++', '@%^š€' sont des littéraux de type chaine de caractères.

On remarquera que tous les caractères sont autorisés entre les quotes sauf les quotes eux mêmes !. Pour mettre une quote dans une chaine de caractères, il faut le faire précéder par une autre quote. Par exemple:

    'L''horaire d''été'
 

Parmis les chaines de caractères, il y en a une qui joue un rôle particulier : la chaine vide.

Une constante est donc en quelque sorte le synonyme d'une valeur. On pourra par exemple introduire une constante PI représentant le nombre 3.14159. Avant la compilation du code (cette étape s'appelle en fait la précompilation) toutes les occurrences du mot PI seront remplacées par 3.14159.

Comme son nom l'indique, la valeur d'une constante ne peut pas varier durant l'exécution d'un programme.

En Pascal, une constante peut se déclarer de la manière suivante:

    Const nom de constante = littéral ;
 

Le nom d'une constante obéit aux même règles que le nom d'une variable.

    Const PI = 3.14159 ;
     CLEF_USB = 'F:' ;  DISQUE_DUR = 'C:';
 

Voici par exemple, quelques opérateurs fréquement rencontrés dans les langages de programmation: +   -  /  *  ^  =  ++  !   %

Dans ce cours, nous nous concentrerons pour l'instant sur les opérateurs suivants:

• L'opérateur d'addition, représentée par le caractère + .
• L'opérateur de soustraction,représenté par le caractère -
• L'opérateur de multiplication, représenté par le caractère * (et non pas × comme en mathématique !).
• L'opérateur de division, représenté par le caractère /
• l'opérateur de concaténation, représenté par le caractère +

Vous connaissez déjà les quatre premiers opérateurs, puisqu'il s'agit des opérateurs mathématiques classiques. Mais si vous n'avez jamais fait de programmation, vous ignorez probalement le sens de l'opérateur de concaténation.

Par exemple, si je concatène la chaine 'para' avec la chaine 'pluie', j'obtient la chaine 'parapluie'.

La manière de noter l'opérateur de concaténation dépend des langages.

En Pascal, il se note comme l'opérateur d'addition, c'est à dire avec un signe +.

L'opérateur de concaténation permet de construire des expressions de type chaine de caractères.

Par exemple, 'Je suis '+Prenom est une expression de type chaine de caractères constituée d'un littéral ('Je suis '), de l'opérateur de concaténation + et d'un nom de variable (Prenom).

On peut concaténer autant de chaines de caractères qu'on le souhaite. Par exemple, dans l'expression 'Je suis '+Prenom+' '+Nom il y a quatre chaines de caractères.

Voilà différentes valeurs de l'expression

 'Je suis ' + Prenom

pour différentes valeurs de la variable Prenom :

Voilà différentes valeurs de l'expression

 'Je suis ' + Prenom + ' ' + Nom

pour différentes valeurs des variables Prenom et Nom :

L'écriture d'une expression dans un certain langage de programmation doit nécessairement obéir aux règles propres à ce langage.

Nous donnons ici, un certain nombre de règles non exhaustives permettant d'écrire des expressions valides en Pascal.

Les règles suivantes permettent de construire des expressions de type chaine de caractères valides:

Exemples d'application de ces règles (Nom et Prenom sont des chaines de caractères et Age est un entier):

Les règles suivantes (non exhaustives) permettent de construire des expressions numériques valides:

Exemples d'application de ces règles (avec Nom de type String, Age de type Integer et Poids de type Double):

Les procédures d'affichage de l'unité ETBib permettent d'afficher la valeur d'une expression. Selon le type de l'expression on utilisera Afficher, AfficherEntier ou AfficherNombre.

Pour afficher une expression E de type chaine de caractères dans une zone de texte ou zone de liste Z, on utilisera l'instruction:

   Afficher ( E, Z);

Exemple: la variable Nom contient le nom d'une personne et la variable Adresse son adresse. L'instruction suivante permet d'afficher le nom et l'adresse de la personne sur une seule ligne dans la zone de liste ZL_Client:

   Afficher (Nom + '-' + Adresse, ZL_Client);

le nom et l'adresse sont séparés par un tiret.

Pour une expression numérique dont le résultat est toujours un nombre entier, on peut utiliser AfficherEntier ou AfficherNombre. Par contre, si le résultat n'est pas forcément entier, il faudra utiliser AfficherNombre.

Exemple1: Un hotel propose des chambres à 47 euros. La variable NJ contient le nombre de jours. L'instruction suivante permet d'afficher le prix du séjour dans la zone de texte ZT_PrixSejour :

   AfficherEntier ( NJ * 47 , ZT_PrixSejour);

dans cet exemple, on peut utiliser la procédure AfficherEntier car le prix à payer est forcément un nombre entier.

Exemple2: Supposons à présent que le prix d'une chambre soit variable et pas forcément entier. Ce prix est stocké dans une variable P de type double. Dans ce cas, on ne sait pas si le prix du séjour est un nombre entier. Il faut donc utiliser l'instruction:

   AfficherNombre ( NJ * P , ZT_PrixSejour);

Revenons sur le schéma lecture-traitement-affichage. A présent, nous pouvons expliquer comment afficher les résultats d'un traitement sans les sauvegarder dans des variables: il suffit d'écrire l'expression du traitement à l'intérieur de l'instruction d'affichage !

Voilà par exemple comment écrire le programme d'addition sans sauvegarder le résultat dans une variable:

 var
  Form1: TForm1;
  // Déclaration des variables globales
  x, y  : integer;

implementation

{ TForm1 }

procedure TForm1.BoutonAdditionnerClick(Sender: TObject);
begin
  // Lecture des données
  LireEntier (x,zoneTexteX);
  LireEntier (y,ZoneTexteY);
  // Traitement et Affichage du résultat
  AfficherEntier (x + y, ZoneTexteSomme);

end;     

Le calcul de l'addition se fait à l'intérieur de l'instruction d'affichage.

Dans des cas simples, cette manière de programmer peut être utilisée. Mais de manière générale, essayez autant que possible de séparer le traitements des données et l'affichage. Vous obtiendrez ainsi des programmes plus lisibles et plus faciles à modifier.