Guide Pascal et Delphi

Au grand regret de ceux d'entre vous que les mathématiques rebutent profondément, les nombres en programmation (et en Pascal entre autres) sont partout. C'est le type de données le plus simple et le plus utilisé, et de nombreuses variantes existent qui autorisent différents intervalles et permettent ou pas les nombres décimaux.

V-A-1-a. Nombres entiers▲

V-A-1-b. Nombres à virgules▲

V-A-1-c. Opérations sur les nombres▲

1.1 + 2.86

2.43 - 1.2

3.23 / 2.19

(2.43 - 1.2) * 2

2.43 - 1.2 * 2

Pour utiliser des caractères tels que ceux que vous êtes en train de lire, il vous faudra utiliser d'autres types de données, à savoir les types caractères et chaînes de caractères.

Une précision avant de commencer : les caractères et chaînes de caractères font la différence, au contraire du reste d'un programme, entre majuscules et minuscules.

Le type caractère, associé au mot Pascal 'char' (on dira maintenant type char, ou type single, ou type integer pour désigner les types), permet de stocker un unique caractère, que ce soit une lettre, un chiffre, des caractères moins fréquents tels que : # ! ? , ; . : @. Etc.

C'est parfois très pratique, comme nous le verrons plus tard, mais se limiter à un seul caractère est tout de même gênant. C'est pour cela que le type 'string' (« chaîne » en français) existe. Il permet, dans les versions 2 et 3 de Delphi, de stocker 255 caractères, et n'a plus de limite à partir de la version 2 (bien que l'ancien type limité à 255 caractères soit alors accessible par le type 'shortstring').
Il est également possible de personnaliser la longueur (tout en respectant quand même la limite maximale de 255 dans ce cas) en utilisant le type 'string[n]' ou n prend une valeur comprise entre 1 et 255. Ce type permet d'utiliser des chaînes d'au plus n caractères.

Les chaînes et les caractères se notent entre simples quotes (' ') à ne pas confondre avec les guillemets (" ") :

'truc' est une chaîne, 'truc et 1000 autres trucs' en est une autre. Pour inclure une simple quote dans une chaîne, il suffit d'en mettre deux. Ainsi, 'l''oiseau' représente en fait « l'oiseau ». La chaîne vide se note ''.

Il est possible de concaténer deux ou plus de chaînes en une seule (c'est-à-dire de les coller bout à bout). Pour cela, on utilise l'opérateur +.

Exemples :

1. 'inte' + 'lligent' et 'intelligent' désignent la même chaîne de caractères.
2. 'i'+'ntelli'+'gent' et 'intellig'+'ent' également.
3. par contre, 'i'+' ntelli '+'gent' , qui comporte des espaces, est différente de 'intelligent'.
4. 'exemple'+ ' ' +'idiot' et 'exemple idiot' représentent la même chaîne.
5. 'l'+''''+'oiseau' et 'l''oiseau' également.
6. 'l'+''''+'Oiseau' et 'l''oiseau', par contre, sont différentes, car la première contient une majuscule et pas la deuxième.

Deux remarques pour terminer cette partie :

1. 'abc' + 1 n'a pas de sens (il faudrait écrire 'abc' + '1' pour obtenir 'abc1'), car on ne peut pas additionner une chaîne et un nombre. On dit alors que ces deux types sont incompatibles. Il existe des moyens pour passer outre ce genre d'incompatibilité, même si l'intérêt ne saute pas aux yeux, mais il est encore un peu tôt pour en parler.
2. Ensuite, une chaîne de caractère ne peut pas être coupée par un retour à la ligne. C'est-à-dire que lorsque vous taperez une chaîne dans Delphi, vous n'aurez pas le droit de l'écrire directement sur plusieurs lignes. Si vous souhaitez le faire, découpez-la en morceaux (écrits chacun sur une seule ligne) concaténés ensuite par des opérateurs +. Ceci sera illustré dans des exemples présents dans la suite du guide.

Révision éclair : les booléens
On appelle booléen, ou valeur booléenne, une valeur pouvant être 0 ou 1. On associe souvent ces deux valeurs aux deux expressions logiques « faux » (« false » en anglais) et « vrai » (« true » en anglais).

Les opérateurs booléens permettent de combiner logiquement plusieurs valeurs booléennes. Les opérateurs à connaître sont (avec leur table de vérité) :

• not (négation)
  (not A) est la négation logique de A, à savoir vrai si A est faux, et faux si A est vrai.

  A	not A
  0	1
  1	0

• or (ou inclusif)
  (A or B) est vrai si A est vrai, si B est vrai, ou si A et B sont vrais à la fois.

  A	B	A or B
  0	0	0
  0	1	1
  1	0	1
  1	1	1

• and (et)
  (A and B) est vrai seulement si A et B sont vrais à la fois.

  A	B	A and B
  0	0	0
  0	1	0
  1	0	0
  1	1	1

• xor (ou exclusif)
  (A xor B) est vrai si exactement l'une des deux valeurs de A et B est vrai et que l'autre est fausse (i.e. A faux et B vrai, ou bien A vrai et B faux).

  A	B	A xor B
  0	0	0
  0	1	1
  1	0	1
  1	1	0

Les tables de vérité de ces opérateurs sont également à connaître et sont données ici à titre indicatif.

Les valeurs booléennes (0 ou 1) ont une place privilégiée en informatique, et sont naturellement intégrées à Delphi. Le type 'boolean' permettra d'avoir une donnée de type booléen. Une telle donnée peut avoir seulement deux valeurs : false (faux, valeur : 0) ou true (vrai, valeur : 1).

Le mot Pascal not permet la négation d'une donnée booléenne. Ainsi, « not true » vaut « false » et « not false » vaut « true ».

Il est possible d'utiliser les opérateurs booléens classiques, qui sont des mots Pascal : or (ou inclusif logique), xor (ou exclusif logique) et and (et logique) avec les données de type 'boolean'. Ces opérateurs répondent aux priorités en vigueur en Logique, à savoir :

1. not est le plus prioritaire ;
2. and vient ensuite ;
3. or et xor viennent enfin au même niveau.

Exemples :

1. true and true vaut 'true'
2. false or true vaut 'true'
3. not false and true vaut 'true'
4. not false xor not true vaut 'true'
5. not not false vaut 'false'

Les expressions booléennes permettront souvent de décider si une partie de programme est exécutée ou non (la valeur true entraînera l'exécution d'un morceau de programme, la valeur false permettra de passer par dessus, par exemple, ou d'exécuter un autre morceau de programme).

Il est maintenant temps de voir quelques autres opérateurs liés aux booléens et qui vous servirons souvent. Les symboles que nous allons voir sont des opérateurs de comparaison (+ ou / par exemple sont des opérateurs simples). Comme leur nom l'indique clairement, ils permettent de comparer deux expressions (souvent des nombres ou des booléens). Ils s'utilisent de la façon suivante :

« Expression 1 » opérateur « Expression 2 »

(pensez à « 1 + 2 » pour vous convaincre que cette écriture n'est pas si terrible qu'elle en a l'air)

Par expression, on entend n'importe quoi qui soit une donnée du programme ou quelque chose de calculable.

Le résultat de ces opérateurs, contrairement aux opérateurs +, -, ... est un booléen, et vaut donc true ou false. Il est donc primordial de comprendre que ce résultat peut être utilisé comme n'importe quel donnée booléenne (cf. exemples)

Voici la liste des opérateurs et leur signification :

Exemples :

1. 0 = 1 vaut false
2. 1 < 1 vaut false
3. 1 >= 1 vaut true
4. 1 + 1 > 3 vaut false (les opérations sont prioritaires sur les opérateurs de comparaison)
5. (1 + 1 > 2) or (2 < 3) vaut true
6. not (10 - 22 > 0) et (10 - 22 <= 0) sont équivalents et valent true.
7. not (2 * 3 - 1 >= 5) = true vaut... false. (explication de ce dernier cas un peu tordu : 2 * 3 - 1 >= 5 est vrai, donc vaut true, la négation vaut donc false, et false = true est alors faux, donc vaut false).

Ces opérateurs permettront de faire des tests sur des données d'un programme, et de prendre des décisions en fonction du résultat des tests.

Les types énumérés sont énormément utilisés par Delphi et l'inspecteur d'objets, mais existaient bien avant Delphi. Ils sont utiles lorsqu'une donnée ne doit pouvoir prendre qu'un certain nombre de valeurs, chacune ayant une signification particulière. Ils permettent de définir directement les valeurs possibles pour une donnée (de ce type). Ces valeurs sont données sous forme de noms, qui seront considérés ensuite comme des mots du langage Pascal. Exemple concret : vous voulez définir l'alignement horizontal d'un texte. 3 alignements sont possibles : gauche, centré, droite. Vous pouvez alors utiliser le type de donnée dit type énuméré nommé « TAlignment ». Une donnée de ce type peut avoir trois valeurs, qui sont comme des mots du langage Pascal, à savoir : taLeftJustify, taCenter et taRightJustify.

Vous n'avez absolument pas à savoir ce que sont en réalité ces trois expressions (nommés plutôt identificateurs). Pour donner un alignement centré à un texte, il faudra utiliser taCenter (et nous verrons où et comment faire cela dans très peu de temps). Il vous faudra cependant savoir que chacun de ces identificateurs possède une valeur ordinale positive ou nulle (nous reparlerons de cela au chapitre 5).

Il sera également possible pour vous de créer des types énumérés en donnant le nom du type (comme 'TAlignment') et en donnant les valeurs possibles pour les données de ce nouveau type. Vous verrez que cela est bien utile dans certaines situations mais ce n'est pas encore pour tout de suite.

Cette partie consacrée aux types de données les plus simples (pas forcément encore pour vous, désolé si c'est le cas) est terminée. Vous l'avez certainement trouvé ennuyeuse, et vous avez raison : elle l'est. Lorsque vous parcourrez la suite de ce guide, il sera certainement intéressant pour vous de revenir à cette partie, qui vous semblera à ce moment bien moins abstraite. L'essentiel pour l'instant est qu'aucun des mots du langage Pascal qui suivent ne vous soit inconnu à partir de ce point :

Integer byte word
single currency
div mod
char string shortstring string[n]
boolean true false
and or xor not

De même, la liste des symboles ci-dessous doit être connue de vous :

+ - * /
= < > <= >= <>

Si ce n'est pas le cas, essayez de revenir en arrière pour voir ce qui vous a échappé, sinon, vous pouvez avancer en toute confiance. La suite du chapitre est consacrée à des manipulations servant de mise en pratique pour vos connaissances toutes fraiches. Vous verrez alors que les booléens, les données de types énumérées, les chaînes et les nombres sont partout.

Le fichier projet est un des domaines réservés à Delphi, mais dont vous devez connaître l'existence et la structure. L'ensemble du texte du fichier est généré par Delphi. Dans l'état actuel, le texte du fichier projet devrait être (avec peut-être d'autres styles de caractères, mais un texte identique) :

program PremierEssai;

uses
  Forms,
  Principale in 'Principale.pas' {Form1};

{$R *.RES}

begin
  Application.Initialize;
  Application.CreateForm(TForm1, Form1);
  Application.Run;
end.

Servez-vous de ce texte comme illustration de ce qui suit.

Avant tout, ce qui est écrit entre accolades (texte vert en italique) est un commentaire. Ce qui est à l'intérieur de ces accolades est normalement ignoré par Delphi, à certaines exceptions bien précises près.

Encore une fois, le contenu du fichier projet est géré entièrement par Delphi, et une intervention de votre part, bien que possible et autorisée, risque de provoquer des erreurs. Il est assez rare d'avoir à modifier directement ce fichier, et plus avantageux de laisser Delphi se débrouiller tout seul.

Un fichier projet est un fichier (donc un morceau de programme, donc par abus d'écriture un programme) écrit en langage Pascal. Un fichier projet est constitué de blocs de texte. Chaque bloc possède sa propre syntaxe. Les blocs sont terminés par un point-virgule (;) sauf le dernier qui est terminé par un point (.). Un fichier projet commence par le mot réservé program et se termine par le point final du dernier bloc.

Le premier bloc d'un fichier projet consiste en la déclaration de son nom. Ceci est fait par l'utilisation du mot Pascal program, suivi d'un espace (l'espace est un séparateur en Pascal, comme en français. C'est le séparateur minimum. On peut y ajouter au besoin d'autres espaces, des sauts de lignes, des tabulations, bien utiles pour bien présenter le texte) puis du nom du programme, et enfin d'un point-virgule séparant le bloc du suivant. Le nom doit être identique au nom du fichier .DPR, à l'exception de « .dpr » qui doit être omis.

Exemple : Dans notre cas, le fichier projet se nomme PremierEssai.dpr. La première ligne du fichier projet comporte donc comme nom de programme « PremierEssai ».

Le second bloc d'un fichier projet est un bloc spécial qu'on retrouvera dans les unités, sous une forme simplifiée. Ce bloc sert de connexion entre les différentes unités et le fichier-projet.

Le bloc commence par le mot Pascal uses (en français : « utilise ») et donne ensuite une liste d'éléments, séparés par des virgules. Le bloc se termine par un désormais classique point-virgule. Chaque élément de cette liste comporte au moins le nom d'une unité (l'alter-ego du nom de programme spécifié après program mais pour une unité), qui est le nom du fichier dans lequel elle est stockée, privé de « .pas ». Cette unité peut faire partie du projet ou pas. Si l'élément s'arrête à la mention du nom, c'est que l'unité ne fait pas partie du projet.

Exemple : l'unité 'Forms' est mentionnée dans le fichier projet, mais ne fait pas partie du projet. C'est une des nombreuses unités fournies par Delphi et utilisables à volonté.

Les éléments qui font référence aux unités du projet comportent en plus le mot Pascal in suivi d'une chaîne de caractères (entre simple quotes, vous vous en rappelez ?) contenant le nom d'un fichier (le fichier qui contient l'unité). Si l'élément se termine ici, c'est une unité sans fiche. Peut ensuite venir entre accolades (donc en commentaire, mais ceux-ci ne sont pas vraiment ignorés par Delphi du fait de leur présence dans le bloc uses du fichier-projet) un autre élément qui fait référence à la fiche et qui n'est évidemment présent que si celle-ci existe (dans le cas d'une unité non associée à une fiche, cet élément n'apparaît donc pas) : c'est le nom de la fiche (C'est la propriété 'name' de la fiche).

Exemple : l'unité stockée dans Principale.pas a pour nom « Principale », elle est associée à une fiche dont le nom est Form1 (affichez les propriétés de la fiche dans l'inspecteur d'objet et regardez la propriété 'name' pour vous en convaincre).

Vient ensuite une ligne indispensable comportant un commentaire spécial que nous n'expliquerons pas ici : « {$R *.RES} » (lisez l'approfondissement ci-dessous si vous voulez quand même en savoir plus). Ce n'est pas un bloc puisque les commentaires sont ignorés par Delphi. Ce commentaire est seulement un commentaire spécial que vous pouvez ignorer (vous devez commencer à vous demander si les commentaires sont vraiment des commentaires. C'est effectivement le cas dans 99% des cas, sauf entre autres pour ceux commencant par le symbole '$'. Rassurez-vous, lorsqu'on se contente d'écrire du texte simple, il n'y a aucun problème).

Approfondissement :

Dans le répertoire dans lequel vous avez enregistré le fichier projet (et normalement le projet entier), se trouve normalement un fichier nommé 'PremierEssai.res'. Ce fichier est un fichier de ressources. Anciennement, ces fichiers de ressources contenaient des ressources compilées telles des fiches, des images, des icônes, ...
Delphi utilise ce fichier pour stocker en général un unique élément : l'icône de l'application. Si vous souhaitez vous en assurer, vous pouvez lancer l'éditeur d'images de Delphi (menu Outils/ Editeur d'images) et ouvrez le fichier. Ce sera également une méthode pour changer cette icône.
La ligne {$R *.RES} est une directive de compilation, qui est destinée non pas à l'ordinateur ni à Delphi mais au compilateur (le programme qui compile le projet et le transforme en application). Cette commande est exécutée par le compilateur et ne sera pas incluse dans l'application. La commande demande d'inclure tous les fichiers .RES du répertoire du projet dans la compilation. C'est ainsi que l'icône de l'application est incluse dans le fichier .EXE final. C'est aussi comme cela que nous pourrons ajouter d'autres éléments extérieurs, mais cela est pour beaucoup plus tard.
Souvenez vous de ces explications lorsque, dans les unités, vous verrez la ligne {$R *.DFM}. Cette ligne a le même rôle, pour les fichiers .DFM, donc les fiches (en fait, les fichiers contenant les fiches). C'est ainsi que les fiches sont incluses dans la compilation.

Le reste du fichier, avant « end. », est la partie (le bloc) la plus importante du fichier projet : c'est celle qui permet l'exécution de l'application. Cette partie commence par le mot réservé (mot Pascal) begin (en français : « début ») et se termine par le mot réservé end. Ce bloc est constitué lui-même comme le fichier projet, à savoir de blocs. Chaque bloc est séparé des autres par un point-virgule (omis avant le premier et après le dernier bloc). Chacun de ces petits blocs est une instruction du programme.

Exemple : dans notre cas, il y a trois instructions qui sont :

1. Application.Initialize
2. Application.CreateForm(TForm1, Form1)
3. Application.Run

La signification de ces instructions est hors de notre propos. Concentrez-vous simplement sur ce terme : instruction. Il signifie que chacun des 3 morceaux de texte ci-dessus est un ordre en Pascal compréhensible par l'ordinateur (après compilation, mais c'est jouer sur les mots) et qui sera donc exécuté par ce dernier. En fait, ces instructions sont parmi les toutes premières qui seront exécutées par l'ordinateur au démarrage de l'application.

Voilà, désormais, vous connaissez la structure d'un fichier-projet. En gros, vous pouvez retenir qu'un fichier-projet est organisé comme suit :

• bloc de déclaration de nom :
  program nom_du_programme;
• bloc d'utilisation d'unités :
  uses liste_d_unites;
• bloc d'instructions :
  begin
  instructions
  end.

Etant donné que vous aurez peu à modifier le fichier projet, vous passerez le plus clair de votre temps à écrire du Pascal dans des unités. Pour voir la seule unité actuelle du projet PremierEssai, effectuez la même manipulation que pour le fichier-projet, mais en sélectionnant cette fois 'Principale'. Le texte écrit dans la fenêtre d'édition devrait être :

unit Principale;

interface

uses
  Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms,
  Dialogs, StdCtrls;

type
  TForm1 = class(TForm)
    Button1: TButton;
  private
    { Private declarations }
  public
    { Public declarations }
  end;

var
  Form1: TForm1;

implementation

{$R *.DFM}

end.

Le squelette de base de l'unité (et de toute unité, mis à part le nom qui évidemment, changera) est :

unit Principale;

interface

implementation

end.

La ligne « unit Principale; » est le premier bloc de l'unité. Il permet, comme dans un fichier-projet, de donner le nom de l'unité. Ce nom est, comme pour le fichier-projet, le nom du fichier privé de l'extension '.pas'.

Important : Ce nom ne doit pas être modifié par vous directement, utilisez plutôt la commande Fichier/Enregistrer sous... des menus pour changer le nom du fichier .PAS contenant une unité, ce qui aura pour conséquence de mettre à jour le nom d'unité.

Les mots réservés interface, implementation, et end délimitent deux parties : le premier est contenu entre interface et implementation et se nomme tout naturellement l'interface de l'unité. La deuxième partie est entre implementation et end et se nomme l'implémentation de l'unité. Un point final termine l'unité comme dans un fichier-projet.

Remarque : Bien que le fichier-projet soit considéré par Delphi comme une unité (mais ce n'en est pas une, pour vous dire enfin toute la vérité), il ne possède pas ces deux parties interface et implémentation qui sont réservées aux unités.

L'interface de l'unité 'Principale' est donc :

uses
  Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms,
  Dialogs, StdCtrls;

type
  TForm1 = class(TForm)
    Button1: TButton;
  private
    { Private declarations }
  public
    { Public declarations }
  end;

var
  Form1: TForm1;

Et l'implémentation est :

{$R *.DFM}

Ce qui est assez court mais qui aura une très nette tendance à s'allonger.

Vous vous souvenez du mot réservé uses ? Il permet, je le rappelle, d'accéder à une autre unité. En réalité, seule l'interface d'une unité est alors accessible, mais jamais l'implémentation (et il n'y a absolument aucun moyen d'accèder à l'implémentation d'une autre unité, et ça ne servirait d'ailleurs à rien, nous le verrons).

On pourrait faire ici l'analogie avec une unité centrale d'ordinateur : l'interface est alors l'extérieur du boîtier, et l'implémentation est l'intérieur de ce même boîtier. Lorsque vous utilisez une unité centrale, vous utilisez les quelques boutons et afficheurs (diodes) qui se trouvent en face avant. Vous utilisez également les prises qui sont à l'arrière du boîtier pour brancher divers câbles. Vous utilisez en quelque sorte une interface, sans vraiment vous soucier de l'intérieur du boîtier. Vous pouvez même ignorer totalement ce qu'il y a à l'intérieur et jamais cela ne vous posera de problème : vous êtes l'utilisateur de l'ordinateur et non son créateur.

C'est le même principe avec une unité : seule l'interface vous intéresse, vue de l'extérieur, l'implémentation n'a plus d'importance vu de l'extérieur de l'unité. Mais n'allez pas croire que l'implémentation n'est pas importante ! En effet, comment croyez-vous que votre ordinateur fonctionnerait si votre unité centrale était complètement vide ? La réponse est simple, il ne fonctionnerait pas. Vous auriez beau appuyez sur le bouton On/Off, il ne se passerait rien car rien n'aurait été prévu dans l'implémentation (l'intérieur du boitier) pour réagir à vos ordres (pas de fils branchés sur l'interrupteur et reliés à un quelconque circuit électrique).

L'implémentation regroupe tout ce qui n'a pas à être vu de l'extérieur. Vous y mettrez la majorité du texte Pascal, ne laissant dans l'interface que le strict nécessaire depuis l'extérieur.

Chacune de ces deux parties a un rôle particulier. On peut dire, sans encore rentrer dans les détails, que l'interface est la partie déclarative de l'unité tandis que l'implémentation est plutôt la partie exécutive. Pour s'exprimer un peu plus clairement, l'interface contiendra tout ce qui devra être connu de l'extérieur : on y déclarera ce qu'on veut mettre à la disposition de l'extérieur. L'implémentation, quand à elle, contiendra majoritairement des instructions (comme celles présentes à la fin du fichier-projet) organisées en groupes.

L'interface et l'implémentation possède chacune un bloc unique et optionnel désormais connu de vous : uses. Il a le même rôle que pour le fichier-projet, à savoir faire appel à d'autres unités. La syntaxe de ce bloc est très simple par rapport à celle employée dans le fichier-projet : le mot-clé uses est suivi par un espace, puis par une liste de noms d'unités, séparés par des virgules. Un point-virgule termine le bloc. On dira, lorsque le nom d'une unité est présent dans le bloc uses, que cette unité est utilisée.

Le bloc uses est valable au moins pour toute la partie dans laquelle il est inclus, c'est-à-dire que les unités listées dans le uses de l'interface (resp. de l'implémentation) sont accessibles partout dans l'interface et dans l'implémentation (resp. l'implémentation seulement). Le tableau ci-dessous résume cela :

Quelques règles sont à connaître dans l'utilisation des unités :

1. Une unité peut être utilisée par un nombre quelconque d'autres unités.
2. Une unité ne peut être utilisée qu'une fois dans une autre unité, c'est-à-dire qu'elle sera utilisée dans l'interface ou dans l'implémentation, mais pas dans les deux.
3. Les utilisations d'unités depuis l'interface des unités ne peuvent pas être circulaires.Pour expliquer ce concept assez tordu mais imparable, supposons que nous avons trois unités nommées unit1, unit2 et unit3 (ces noms sont destinés à simplifier les explications, ils ne sont pas à utiliser car non descriptifs du contenu de l'unité). Si l'unité unit1 utilise l'unité unit2 dans son interface, si l'unité unit2 utilise l'unité unit3 dans son interface, alors l'unité unit3 n'aura pas le droit d'utiliser l'unité unit1 (et pas l'unité unit2 non plus) dans son interface, car ceci formerait un cycle.
4. Il est toujours possible d'utiliser une unité dans l'implémentation d'une unité (en respectant toutefois la règle 2). Ceci permet de tempérer la règle précédente : dans le dernier exemple, les unités unit1 et unit2 pourront quand même être utilisées par l'unité unit3, non pas dans son interface mais quand même dans son implémentation.

Même si ces règles peuvent paraître compliquées, elle le seront moins à l'emploi. Le coté contraignant ne devrait pas dans l'absolu vous déranger puisque vos programmes devront être écrits en tenant compte de ces règles.

Les noms (techniquement : les chaînes de caractères utilisés pour les nommer) de constantes, de variables, d'unités, de programmes, de types sont ce qu'on appelle des identificateurs. Un identificateur répond aux exigences suivantes, imposées par le langage Pascal :

• C'est une suite de caractères, pris parmi les lettres majuscules ou minuscules, les chiffres, le blanc souligné ( _ ) (en dessous du 8 sur votre clavier). Par contre, les espaces, le tiret ( - ), les accents, et tout le reste sont interdits.
• Un nombre de caractères maximum raisonnable est 50 (le nombre maximal a augmenté avec les différentes versions de Delphi).
• Le premier caractère ne peut pas être un chiffre.
• Les majuscules et minuscules sont vues comme les mêmes lettres. Il est cependant recommandé d'utiliser les minuscules autant que possible et les majuscules seulement pour les premières lettres des mots. Ainsi par exemple 'PremierEssai' est un identificateur valable et descriptif.

Exercice 4 : (voir la solution)

Parmi les propositions ci-dessous, lesquelles sont des identificateurs valables, et pour ceux qui n'en sont pas, pourquoi ?

1. test1
2. 1_test
3. test 1
4. test-1
5. test_1
6. TEST_2

Pour les exemples qui vont suivre, vous pourrez utiliser Delphi et taper le texte indiqué juste avant le mot implementation dans l'unité 'Principale' :

...
  end;

var
  Form1: TForm1;

{ <-- Ici }
implementation

{$R *.DFM}
...

Vous ne pourrez pas avoir de résultat visible, mais vous pouvez vérifier que vous avez bien tapé les textes en compilant le projet (Menu Exécuter / Compiler, ou raccourci clavier : Ctrl + F9). Les erreurs éventuelles vous seront alors indiquées par un ou plusieurs messages d'erreur.

Les constantes sont une possibilité très intéressante de la programmation en Pascal. Elles permettent, sans aucune programmation, de faire correspondre un identificateur et une valeur. Cette valeur peut être de beaucoup de types (un seul à la fois, quand même) mais il faudra parfois indiquer ce type.

Les constantes se déclarent dans un bloc adéquat. Ce bloc peut être positionné, pour l'instant, dans l'interface ou dans l'implémentation d'une unité en dehors des autres blocs. La structure d'un tel bloc est des plus simple : on débute le bloc par le mot réservé const (le bloc n'a pas de marque de fin, c'est le début d'un autre bloc ou la fin de l'interface ou de l'implémentation qui terminent le bloc).

const

Vient ensuite une liste aussi longue qu'on le souhaite de déclarations de constantes. Une déclaration de constante a la forme :

Identificateur = Valeur;

Où Identificateur est un identificateur (non utilisé ailleurs) et Valeur est une valeur de type nombre, chaîne ou booléen (d'autres types seront utilisables par la suite au prix d'une syntaxe adaptée).

Exemple :

const
  LargeurParDefaut = 640;
  NomLogiciel = 'Premier Essai';
  MontreEcranDemarrage = True;
  Touche01 = 'z';

Les constantes de types plus complexes devront plutôt utiliser la syntaxe suivante :

Identificateur : Type = Valeur;

Où Type est le type de la constante, et Valeur une valeur acceptable pour ce type.

Exemple :

const
  AlignementParDefaut: TAlignment = taCenter;

Une constante peut également être déterminée à partir de tout ce dont on connaît la valeur à l'endroit où on déclare cette constante. En pratique, on peut utiliser les constantes déclarées plus haut dans l'unité, et les constantes des unités utilisées (listées dans le bloc uses).

Exemple :

const
  Valeur1 = 187; {187}
  Valeur2 = Valeur1 + 3; {190}
  Valeur3 = Valeur2 div 2; {95}
  Condition1 = (Valeur3 > 90); {True}
  ChBonj = 'Bonjour';
  ChBonjM = ChBonj + ' ' + 'Monsieur';

Rappel : les textes entre accolades sont des commentaires ignorés lors de la compilation.

Note : Plusieurs blocs de déclaration de constantes peuvent se suivre sans problème.

La zone d'effet de la constante (la zone où la constante est accessible) commence juste après la déclaration et se termine à la fin de l'unité. De plus, lorsqu'une constante est déclarée dans l'interface d'une unité, elle est également accessible à toute autre unité utilisant la première. Les constantes peuvent également être déclarées dans le fichier-projet entre le bloc uses et le bloc d'instructions.

Une variable est un identificateur associé à un type donné. La valeur de cette variable pourra changer au cours de l'exécution de l'application. Les valeurs autorisées pour cette variable, ainsi que les opérations possibles avec et sur cette variable dépendent exclusivement du type de la variable et de l'endroit où elle a été déclarée.

Car comme les constantes, une variable se déclare dans un bloc spécifique situable pour l'instant dans l'interface ou dans l'implémentation d'une unité, en dehors de tout autre bloc. Il est également autorisé de déclarer des variables dans le fichier-projet entre le bloc uses et le bloc d'instructions (retenez que les endroits possibles pour les déclaration de constantes et de variables sont les mêmes).

Un bloc de déclarations de variables est de la forme suivante :

var  Déclaration de variables; Déclaration de variables; ... Déclaration de variables;

Que la description ci-dessus ne vous leurre pas, il peut très bien n'y avoir qu'une déclaration de variables par bloc. Chacun de ces blocs « Déclaration de variables » sert à déclarer une ou plusieurs variables d'un même type, et est de la forme :

Identificateur_1, identificateur_2, ..., identificateur_n : type;

Chaque déclaration de variables peut ne déclarer qu'une variable, ou plusieurs, mais du même type. Identificateur_n désigne toujours un identificateur non utilisé ailleurs. Lorsqu'on veut déclarer des variables de types différents, on utilise plusieurs blocs de déclaration.

Les exemples ci-dessous donnent l'éventail des possibilités qui vous sont offertes :

var
  A: integer;

var
  N1, N2: single;

var
  Test: Boolean;
  Indx: Integer;
  S1, S2: string;

L'intérêt des variables est énorme : il nous sera possible de stocker un résultat de calcul dans une variable, de réagir suivant la valeur d'une autre, d'en additionner deux et de stocker le résultat dans une autre, ... les possibilités sont illimitées.

En dehors des variables et des constantes que vous déclarez, rappelez-vous bien que vous aurez accès aux constantes et variables des unités que vous utiliserez (bloc uses). Bon nombre de constantes et de variables sont ainsi proposées et il suffit d'utiliser l'unité les contenant pour y avoir accès. Nous illustrerons cela dans un prochain exemple.