Variables et constantes en Pascal

Un article de Mangue.org, l'encyclopéde libre.

Nous allons voir dans ce cours comment utiliser des variables et des constantes dans nos programmes.

Sommaire

1 Les constantes 2 Les variables 3 Exemple 4 Déclaration de variables initialisées

Les constantes

Nous souhaitons écrire un programme (qui a peu d'intérêt en soi) nous indiquant combien de cours nous avons déjà lu !
La seule méthode que vous connaissez pour le moment est d'écrire ceci à l'intérieur d'une chaîne de caractères. Pour faciliter les modifications ultérieures, nous séparerons du reste du programme une instruction chargée d'indiquer précisément le nombre de cours que nous avons lu comme ceci :

program Affiche_Constante;

(* uses WinCrt; *)

begin
  write ('Vous avez deja lu ');
  write ( 3); (* on peut afficher des nombres *)
  write (' cours complets !');
end.

Si nous lisons un cours de plus il faudra reprendre tout le programme pour que celui ci affiche le bon nombre de cours. Pour ça il faudra donc vous replonger dans le code source en entier (ok pour l'instant c'est pas très dur mais ça va le devenir)
La solution consiste à définir une constante au début de votre programme... Vous pouvez faire ça avec l'instruction const comme ceci :

program Affiche_Constante;

(* uses WinCrt; *)

const Nombre_de_cours_anterieurs = 3;

begin
  write ('Vous avez deja lu ');
  write ( Nombre_de_cours_anterieurs);
  writeln (' complets.'); (* retour a la ligne *)
  write ( 'Vous lisez maintenant le ');
  write ( Nombre_de_cours_anterieurs + 1, '° cours :o))');
end.

Les modifications ultérieures ne se feront que sur une seule ligne mais auront une influence sur l'ensemble du programme. La syntaxe pour déclarer une constante est donc la suivante : const identificateur = valeur
De plus vous pouvez déclarer des constantes de n'importe quel type connu, ce qui est fort pratique.

Remarque

Dans cet exemple vous voyez aussi apparaître deux nouveautés, la premier est l'instruction writeln qui se comporte comme write à ceci prêt qu'elle provoque un retour à la ligne après l'affichage de ses arguments éventuels (elle peut ne pas en avoir) La seconde est la possibilité d'envoyer plusieurs arguments aux fonctions write et writeln, ceux-cis sont affichés les uns après les autres et séparés par des , dans le code source.

Les variables

Nous allons écrire un programme semblable au précédent de part ce qu'il produit mais différent dans son code source. Au lieu d'utiliser une constante, nous allons utiliser une variable.
Le contenu d'une variable peut varier au cours d'un programme. En revanche il n'est pas possible de les initialiser au moment où on les déclare (pas pour tous les compilateurs en tous cas!)

Les variables sont déclarées avec une instruction comme celle-ci : var identificateur : type
Ensuite il est possible d'affecter une valeur à cette variable grace à l'opérateur := mais regardez plutôt cet exemple, ça vaut mieux qu'on long discours ;

program Premiere_Variable;

(* uses WinCrt; *)

var Rang : integer;

begin
  Rang := 3; (* 3 cours lus *)
  writeln ('Vous avez lu ', Rang, ' cours.');
  Rang := Rang + 1;
(* la nouvelle valeur de Rang est 4 *)
  write ( 'Celui ci est le ', Rang, 'eme.');
end.

Nous avons déclaré une variable de type entier (integer) puisque celà suffisait pour ce que nous désirions, pour connaître les différents types disponibles, lisez le [./cours5.htm cours suivant].
Au cours du programme nous avons affecté la valeur 3 à la variable rang puisque nous avons lu trois cours puis plus tard nous avons incrémenté cette valeur.

Il est évident que ce programme n'a aucun intérêt, son équivalent avec des constantes est plus facile à lire et à modifier !!!
La syntaxe correcte pour une affectation de valeur dans un programme est la suivante : nom_de_la_variable := valeur sachant que la valeur peut être définie par une constante nommée ou bien une autre variable ou encore la combinaison de tout ça !!

Astuce

Il est possible de déclarer plusieurs variables du même type au sein de la même instruction. Pour ça il faut séparer les différents noms de variables par des virgules. Regardez donc l'exemple suivant :

program DeclarationDeVariablesEntieres;

(* ueses WinCrt; *)

var Entier1, Entier2, Entier3 : integer;

begin
(* suite d'instructions *)
end.

Exemple

Nous allons écrire un programme robuste permettant de nous situer parmis l'ensemble des cours. Celui-ci n'aura pas d'autre action que de nous dire combien nous avons déjà lu de cours et quel est le rang de celui que nous lisons actuellement.
Vous l'avez compris nous avons intérêt à déclarer des constantes au début du programme, ainsi les modifications ultérieures du code source n'en seront que simplifiées, voici le code :

program Ou_en_sommes_nous;

(* uses WinCrt; *)

const Precedent = 3; (* cours precedent *)
      Actuel    = Precedent + 1;

begin
  write   ( 'Vous avez déjà lu ');
  writeln ( Precedent, ' cours.');
  writeln ( 'Celui-ci est le ', Actuel, 'eme.');
end.

La constante Precedent contient le nombre de cours qui précèdent celui-ci, c'est dans tous les cas la seule ligne du programme que nous auront à modifier.
Vient ensuite la constante Actuel, certains pourraient douter de son intérêt puisqu'elle ne représente que la valeur qui succède Precedent et que pour cette raison, nous pouvons l'obtenir quand nous le désirons. Il est vrai que cette déclaration n'est pas indispensable dans un programme aussi simple, mais pensez que vos codes sources vont rapidement augmenter en complexité.
A force de voir Precedent + 1 dans votre code vous finirez par vous demander ce que c'est! De plus si vous insérez un cours entre celui-ci et le précédent alors cette constante deviendra Precedent + 2. L'intérêt de cette déclaration est donc double, il simplifie la maintenance du code en prévision d'éventuelles modifications mais surtout, il en augmente la lisibilité !!!

Danger

Lors de la déclaration d'une constante il est possible d'utiliser toutes les valeurs déjà connues, même s'il s'agit de constantes déclarées précédemment comme nous l'avons fait ici. En revanche const Actuel = Precedent + 1; Precedent = 3 est impossible puisque le compilateur ne pourra pas affecter à actuel la valeur Precedent + 1 qu'il ne connaît pas encore (Precedent n'est pas encore d'éclarée)

Déclaration de variables initialisées

Elle est possible en Turbo Pascal (ou son équivalent sous Windows) de cette façon :

const x : real    = 5.4;
      y : real    = -1.2;
      n : integer = 10;

Avec le compilateur en licence libre GPC (Pascal GNU), la syntaxe est la suivante :

var x : real    = 5.4;
    y : real    = -1.2;
    n : integer = 10;

En revanche ce type de déclaration est impossible à ma connaissance en FreePascal.

Danger

Comme ceci n'est pas possible avec tous les compilateurs (vous remarquerez au passage que la syntaxe du compilateur GNU est la plus logique), nous n'utiliserons jamais cette fonctionalité dans les exemples des cours qui suivent.