III. Pascal Objet, première partie
III.1. Préliminaires
III.2. Données simples dans un programme Pascal
III.2.1. Nombres
III.2.1.1. Nombres entiers
III.2.1.2. Nombres à virgules
III.2.1.3. Opérations sur les nombres
III.2.2. Caractères et chaînes de caractères
III.2.3. Booléens
III.2.4. Types énumérés
III.2.5. Récapitulatif
III.3. Utilisations des types simples dans l'inspecteur d'objets
III.4. Structure d'un programme Pascal
III.4.1. Structure d'un fichier projet
III.4.2. Structure d'une unité
III.5. Constantes et Variables
III.5.1. Préliminaire : les identificateurs
III.5.2. Constantes
III.5.3. Variables
III.6. Conclusion

Cette partie est consacrées à l'étude du langage Pascal Objet (ou Pascal). Cette première partie introduira le langage, sa syntaxe et ses structures. Dans un premier temps, le cours sera purement théorique. Dans un second temps, dés que vous aurez les connaissances requises, les manipulations et exercices arriveront.

III.2. Données simples dans un programme Pascal

Tout programme Pascal que vous créerez manipulera des données. Ces données sont stockées, comme le programme, dans la mémoire vive (RAM et non disque dur, mais ce n'est pas vraiment important) de l'ordinateur.

Un type de donnée, ou type, est un nom donné à une catégorie très précise de donnée. Ce type permet à Delphi de savoir de quelle manière vont être stockées les données dans la mémoire, quelle quantité de mémoire sera utilisée, quelles valeurs seront autorisées et quelles opérations seront possibles sur ou à partir de ces données. Chaque donnée dans un programme devra avoir un type déterminé. Il existe quelques règles pour échapper à cette restriction, mais elles servent dans la majorité des cas à dissimuler des faiblesses dans la construction d'un programme.

Les parties qui suivent décrivent les types de données courants déjà connus par Delphi, que vous pourrez utiliser dans vos programmes. Pour chaque type de donnée, un mot Pascal vous sera indiqué, c'est ce mot que vous utiliserez dans vos programmes (la manière de vous servir de ces mots vous sera expliquée plus tard). Ensuite viendront des types plus complexes et les types personnalisés.

Vous en êtes probablement à vous dire : « C'est bien joli tout ça, et les exemples ? ». Une réponse à votre interrogation : « Ce n'est pas encore possible ». Les exemples viendront en effet lorsque vous serez à même d'écrire vous-même vos premiers programmes écrits en Pascal (ce qui ne devrait pas trop tarder). Tout ce bavardage sur les types de données, bien que fastidieux pour vous, est indispensable.

III.2.1. Nombres

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.

III.2.1.1. Nombres entiers

Les types de nombres entiers utilisables sous Delphi sont indiqués dans le tableau suivant. Les deux premier sont à utiliser le plus souvent possible car ils offrent les meilleures performances en terme de temps processeur (en gros, la meilleure vitesse, en plus fin, le processeur va plus vite à les traiter car elles prennent 4 octets, taille de prédilection pour les processeurs actuels). Les plus souvent utilisés sont mis en évidence. N'essayez surtout pas de mémoriser tout le tableau, ce serait inutile et fastidieux : Il est juste présenté ici à titre d'information et de référence pour plus tard. Seuls les trois mots Integer, Byte et Word sont à retenir pour l'instant.

Les nombres entier, en Pascal, s'écrivent tels quels, sans séparateurs de milliers. Un nombre négatif doit être précédé d'un signe -. Les nombres positifs peuvent être précédés d'un signe +, non obligatoire et encombrant.

Ainsi, '+12' et '12' sont valides et valent le même nombre. '-12' et '- 12' sont valides et valent le même nombre.

Une petite remarque enfin pour les amateurs de nombres hexadécimaux (un nombre en base 16, contrairement à la classique base 10) : pour utiliser un nombre hexadécimal, il suffit de le précéder par le symbole $. Ainsi, $10F sera considéré comme 271.

III.2.1.2. Nombres à virgules

Notez bien ici qu'on ne parle pas de nombres réels : si vous êtes un peu versé dans les mathématiques (comme votre dévoué serviteur), sachez que Delphi, et l'ordinateur en général, permet d'employer une bien maigre part des nombres réels.

Vous aurez parfois à utiliser des nombres à virgule dans vos programmes, ne serait-ce que pour exprimer des tailles en mètres, des prix en francs ou en euros. Pour cela, Delphi met à votre disposition quelques types de nombres à virgules, avec plus ou moins de décimales (c'est-à-dire que le nombre de chiffres après la virgule est limité). On parle de nombre de chiffres significatifs, c'est-à-dire que les nombres de chiffres avant et après la virgule, ajoutés, est limité.

Le tableau suivant, comme dans le cas des nombres entiers, résume tout cela.

Les nombres à virgule s'écrivent comme les nombres entiers, à ceci près que le séparateur décimal à utiliser n'est pas la virgule mais le point (oui, ce n'est pas très malin, mais l'informatique suit les règles américaines, et ces chers américains préfèrent le point à la virgule).

Ainsi, '- 1.1' est correct, '-1,1' ne l'est pas, '1,1' est incorrect, '1.1' est correct (chaque exemple pris évidemment sans les quotes : ' ').

III.2.1.3. Opérations sur les nombres

Les nombres, qu'ils soient entiers ou à virgule peuvent être utilisés dans des opérations. Les opérations usuelles : l'addition, la soustraction, la multiplication et la division, sont effectuées par les signes respectifs :
+ - * (étoile) / (barre oblique)

Les opérations, dans le langage Pascal, s'écrivent comme à la main. Les espaces entre les nombres et les signes d'opérations sont sans importance.

Ainsi, pour additionner 1,1 et 2,86, il faut tout simplement écrire :

Pour soustraire 1,2 à 2,43, il faut écrire :

Pour diviser 3,23 par 2,19, il faut écrire :

L'utilisation des parenthèses est possible et répond aux mêmes règles qu'en mathématiques. Les priorités sont les mêmes. Ainsi,

Il est à noter ici que la division par 0 est évidemment, comme toujours, interdite et provoquera une erreur d'exécution du programme.

Il est important de comprendre que le résultat d'une opération est du type du nombre le plus complexe dans l'opération. Ainsi, si on additionne un nombre entier à un nombre à virgule, le résultat est un nombre à virgule, ou plus précisément est une donnée de type nombre à virgule, même si sa partie décimale vaut 0.

Le type de donnée du résultat est le type le plus large utilisé dans l'opération (celui qui autorise le plus de choses). Ainsi, la multiplication d'un nombre de type 'single' par un nombre de type 'extended' donne un résultat de type 'extended'. Par contre, lorsqu'une opération est faite entre deux nombres de mêmes types, le type du résultat est ce type.

La division est une exception à cette dernière règle : le résultat est toujours à virgule, quels que soient les nombres mis en œuvre (pensez à 9 / 2 qui vaut 4.5 et qui ne peut donc pas être stocké sous la forme d'un nombre entier).

Il est également possible d'utiliser les deux autres opérations mod et div à la place de /. L'opération div effectue une division entière, à savoir qu'elle renvoie le quotient entier de la division (dans l'exemple de 9 / 2, l'opération 9 div 2 renvoie 4). L'opération mod est le complément de div et renvoie le reste de la division entière (Ainsi : 9 mod 2 vaut 1).

1. Ecrire l'opération qui ajoute 2 à 4,1 et divise ce nombre par la soustraction de 4 à -2
2. De quel type de données le résultat sera-t-il ?

Autre piège classique de l'informatique : si nous avons deux valeurs de type 'byte', disons 200 et 100, que croyez-vous que vaut 200+100 dans ce cas ? La réponse qui saute aux lèvres est 300, et c'est une réponse fausse, puisque le type du résultat est 'byte', qui ne supporte que les nombres entre 0 et 255 !
Que vaudra alors 200+100 ? La réponse exacte est 44 (vive l'informatique !), car l'ordinateur a enlevé autant de fois 256 (c'est un modulo l'amplitude du type (le nombre de valeurs possibles), ici 255 - 0 + 1) qu'il fallait pour retomber dans un intervalle correct. Il faut se méfier de ce genre de comportement car alors si on a deux 'integer' de valeurs 2000000000 et 1000000000, leur somme vaut non pas 3000000000 mais -1294967296 ! Etonnant pour une somme de deux nombres positifs, non ?
Attention : ce qui est expliqué ici est un piège dont il faut se méfier, et non pas un moyen d'effectuer des calculs, parce qu'on ne peut se fier aux résultats de calculs menés hors des sentiers battus.

On a deux valeurs de type 'word' : 65535 et 2, combien vaut dans ce cas précis 65535 + 2 ?

Remarque : Si vous n'avez pas tout (ou rien) compris, ce n'est pas bien grave. Adressez-vous au professeur de maths le plus proche et il vous expliquera tout ça, ou alors vous pouvez m'écrire pour me demander des explications plus détaillées.

III.2.2. Caractères et chaînes de caractères

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 4 (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 +.

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.

III.2.3. Booléens

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.

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 :

(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 :

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.

III.2.4. Types énumérés

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.

III.2.5. Récapitulatif

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.

III.3. Utilisations des types simples dans l'inspecteur d'objets

Place maintenant à quelques manipulations : retournez sous Delphi, ouvrez si besoin le projet PremierEssai et faites apparaître les propriétés de la seule fiche du projet dans l'inspecteur d'objets (si vous ne savez pas comment faire, relisez le paragraphe : II.5.4. L'inspecteur d'objets où la manipulation est décrite en détail).

Comme nous l'avons déjà expliqué, les propriétés de la fiche sont des paramètres modifiable de celle-ci. Chacune de ces propriété est d'un type bien déterminé. Vous connaissez maintenant certains de ces types. Voici une liste de propriétés de la fiche qui sont de types connus par vous.

• La propriété 'width' (largeur de la fiche) déjà utilisée auparavant. Cette propriété est un nombre entier et son type est 'integer' (pourtant, vous constaterez que les valeurs négatives sont interdites. C'est dû à des mécanismes que vous n'avez pas à connaître pour l'instant, qui seront vus beaucoup plus tard dans le guide).
• La propriété 'caption' (texte de la barre de titre) est de type 'string'. Vous pouvez y taper n'importe quel texte, il y a prise en compte des majuscules et minuscules.
• La propriété 'visible' (visibilité) est de type booléen et détermine si un composant est visible ou non pendant l'exécution de l'application. Cette propriété est plus souvent employée avec autre chose que les fiches. Effectuez la manipulation suivante :
  
  1. Affichez les propriétés du bouton ('Action !').
     Sa propriété 'visible' devrait normalement être à 'true'.

     

     
     Lorsque vous lancez l'application, le bouton est visible.
  2. Changez maintenant cette propriété en 'false' en utilisant la liste déroulante :

     
     
     

     et lancez l'application : le bouton n'est pas visible.
  3. Redonnez la valeur 'true' à la propriété 'visible' du bouton.
• La propriété 'BorderStyle' permet de définir le style de bordure de la fenêtre pendant l'exécution de l'application. Elle est de type énuméré et ses différentes valeurs sont accessibles dans l'inspecteur d'objets par une liste déroulante :

  

  (Il est possible que vous n'ayez pas tout à fait la même liste d'expressions, mais certaines doivent y être, comme 'bsSizeable', 'bsDialog', 'bsNone' et 'bsSingle')
  Le type de bordure de la fenêtre dépend de l'élément que vous sélectionnez ici (qui sera la valeur de la propriété 'BorderStyle').
  Si vous souhaitez expérimenter les différents styles de bordures, rien de plus simple : sélectionnez le style désiré, et lancez l'application pour voir le résultat (notez qu'avec certains choix, la fiche ne peut plus être redimensionnée).

Ceci termine les manipulations dirigées. L'exercice ci-dessous vous donnera l'occasion de découvrir d'autres propriétés de la fiche et du bouton.

Exercice 3 : (voir la solution) Les propriétés suivantes sont communes à la fiche et au bouton (chacun de ces deux composants en a un exemplaire). Essayez de trouver de quel type elle sont en utilisant l'inspecteur d'objets comme dans les manipulations ci-dessus (rappelez-vous que bien que les changements apportés à certaines propriétés sont directement visibles, d'autres requièrent de lancer l'application) :

1. 'Cursor' (pointeur utilisé pour la souris quand elle passe sur le composant)
2. 'Height' (hauteur de la fiche)
3. 'Hint' (texte de la bulle d'aide associée au composant)
4. 'ShowHint' (décide si la bulle d'aide est montrée ou pas)

III.4. Structure d'un programme Pascal

1. Si elle est disponible, Utilisez la commande 'Source du projet' du menu 'Voir'.
2. Sinon, une autre méthode qui marche toujours et également avec les unités est de cliquer sur le menu 'Voir', puis 'Unités...' (La fenêtre qui s'affiche alors liste les unités du projet ainsi que le fichier-projet (Vous pourrez l'utiliser pour voir la ou les autres unités). Dans la liste qui s'affiche :

   

   Double-cliquez sur PremierEssai. L'éditeur de code affiche alors du texte commençant par « program ... » (Note : vous voyez, en passant, que Delphi considère le fichier projet comme une unité puisqu'il est listé parmi les unités).

III.4.1. Structure d'un fichier projet

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).

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 :

III.4.2. Structure d'une unité

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.

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.

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.

III.5. Constantes et Variables

Ce paragraphe est consacré à l'étude des fameuses « données » dont on a cessé de parler presque énigmatiquement dans les parties précédentes. En Pascal, ces données peuvent être des constantes ou des variables.

Une constante est un nom que vous associez une fois pour toute à une valeur. Cette valeur ne pourra pas être modifiée pendant l'exécution de l'application. Ce nom devient alors un mot Pascal reconnu par Delphi.

Une variable est un nom que vous donnez à une donnée d'un type bien défini. Ainsi vous pouvez définir des variables de chaque type déjà vu dans ce guide, par exemple 'byte', 'single', 'char', 'string[10]', etc. La valeur d'une variable peut, comme son nom l'indique clairement, changer au cours de l'exécution de l'application.

III.5.1. Préliminaire : les identificateurs

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.

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 utilisez 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.

III.5.2. Constantes

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ées 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.

III.5.3. Variables

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;

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.

III.6. Conclusion

Cette première et longue partie sur le langage Pascal est terminée. Vous y avez appris les rudiments du langage : à savoir la structure des unités et du fichier-projet, les liaisons possibles entres ces éléments. Vous avez également appris ce que seront concrètement les données utilisées dans vos programmes.

Le prochain chapitre est consacré à l'étude de deux notions importantes du langage Pascal : les procédures et les fonctions. Ces deux notions seront ensuite utilisées activement dans le guide car les procédudes et les fonctions seront partout dans les programmes écrits en Pascal.

Retour en haut de la page