Guide Pascal et Delphi


précédentsommairesuivant

V. Préliminaires

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.

V-A. Données simples dans un programme Pascal

Révision éclair : la mémoire de l'ordinateur

Votre ordinateur possède, en plus du disque dur, une mémoire physique appelée aussi « mémoire vive », ou encore RAM (Random Access Memory, Mémoire à accès aléatoire). La taille de cette mémoire est généralement comprise entre 16 Mo (Mégaoctets) et 128 Mo. 1 Mégaoctet contient 1024 (2 exposant 10) Kilooctets et chaque kilooctet contient 1024 octets. Chaque octet contient 8 bits. Un bit est une unité de stockage élémentaire qui peut avoir seulement 2 valeurs : 0 ou 1. Ces 8 bits forment un nombre binaire qui, transformé en nombre décimal classique, est compris entre 0 et 255 (2x2x2x2x2x2x2x2-1).

Cette mémoire est occupée par tout ce qui fonctionne sur votre ordinateur, depuis son allumage et jusqu'à son extinction. Windows contrôle cette mémoire, s'en réserve une part et met le reste à votre disposition. Dans cette mémoire, les autres logiciels pourront être copiés depuis le disque dur, puis exécutés. Les logiciels pourront également y stocker leurs données.

Mais la taille de cette mémoire n'étant pas infinie, il faudra réfléchir lorsque vous aurez beaucoup de données à y stocker. Windows, lorsque la mémoire est pleine, sait en libérer, mais ceci a un prix : une extrême lenteur (ce n'est pas pour ça qu'il faudra rechigner à en utiliser, la mémoire est faite pour servir !)

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.

V-A-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.

V-A-1-a. 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.

Mot Pascal Octets occupés en mémoire Valeur minimale Valeur maximale Remarques
Integer 4 -2 147 483 648 2 147 483 647 C'est le type entier parfait pour la plupart des usages.
Cardinal 4 0 4 294 967 295 N'accepte pas les nombres négatifs, par contre, il va plus loin dans les nombres positifs
Shortint 1 -128 127  
Smallint 2 -32 768 32 768  
Longint 4 -2 147 483 648 2 147 483 647 Utilisez plutôt Integer
Int64
(Depuis Delphi 5 seulement)
8 -2 x 1063 2 x 1063 - 1 Permet de passer outre les limitations de Integer pour de très grands nombres.
Byte 1 0 255 Idéal pour de petites valeurs, encombrement très réduit en mémoire.
Word 2 0 65 535 Préférable à Smallint.

Les nombres entiers, en Pascal, s'écrivent tels quels, sans séparateur 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.

V-A-1-b. 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.

Mot Pascal Octets en mémoire Valeurs minimales etmaximales autorisées chiffres significatifs Remarques
Single 4 1.5 x 10-45
3.4 x 1038
7-8 Idéal pour des nombres avec peu de décimales
Double 8 5.0 x 10-324
1.7 x 10308
15-16 Intermédiaire : plus de précision mais plus de place en mémoire.
Extended 10 3.6 x 10-4951
1.1 x 104932
19-20 Précision maximale : idéal pour de grandes valeurs
Currency 8 -922337203685477.5808
922337203685477.5807
19-20 A utiliser pour les sommes d'argent : seulement 4 chiffres après la virgule, mais on peut atteindre des sommes assez énormes.

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

V-A-1-c. 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 :

 
Sélectionnez

1.1 + 2.86

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

 
Sélectionnez

2.43 - 1.2

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

 
Sélectionnez

3.23 / 2.19

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,

 
Sélectionnez

(2.43 - 1.2) * 2

et

 
Sélectionnez

2.43 - 1.2 * 2

ne valent pas la même chose (2.46 et 0.03).

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

Exercice 1 : (voir la solution)

  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.

Exercice 2 : (voir la solution)

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 me contacter pour me demander des explications plus détaillées ou vous adresser à la mailing-list.

V-A-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 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.

V-A-3. Booléens

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 :

 
Sélectionnez

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

Opérateur Signification Fonctionnement
= Est égal à Renvoie true si les deux expressions sont égales
< Est strictement inférieur à Renvoie true si « Expression 1 » est strictement inférieure à « Expression 2 »
> Est strictement supérieur à Renvoie true si « Expression 1 » est strictement supérieure à « Expression 2 »
<= Est inférieur ou égal à Renvoie true si « Expression 1 » est inférieure ou égale à « Expression 2 »
>= Est supérieur ou égal à Renvoie true si « Expression 1 » est supérieure ou égale à « Expression 2 »
<> Est différent de Renvoie true si « Expression 1 » est différente de « Expression 2 »

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.

V-A-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.

V-A-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 :

 
Sélectionnez

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.

V-B. 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 : IV-E-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'.

      Image non disponible

      Lorsque vous lancez l'application, le bouton est visible.

    2. Changez maintenant cette propriété en 'false' en utilisant la liste déroulante :

      Image non disponible
      Image non disponible

      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 :

    Image non disponible

    (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 elles 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)

V-C. Structure d'un programme Pascal

Nous entrons enfin dans le vif du sujet. Cette partie est consacrée à la compréhension pour vous de la structure (de l'organisation) et non du contenu (du sens) de tout programme écrit en langage Pascal. Tout au long de cette partie, des exercices vous seront proposés afin de manipuler un peu le langage. Vous aurez également des occasions de mettre en pratique vos connaissances toutes fraîches sur les types de données.

Vous savez déjà, ou alors il est grand temps de savoir, qu'un logiciel qu'on crée avec Delphi passe par l'état de projet. Ce projet est constitué du fichier projet (DPR), d'unités (PAS) et de fiches (DFM). Le fichier projet étant en fait une unité particulière, nous nous attacherons d'abord à la structure de ce fichier, qui diffère de celle des unités. Nous nous intéresserons ensuite à la structure d'une unité (toutes les unités ont la même structure générale (en fait, unité désigne plutôt un fichier contenant une unité, c'est un abus de langage que nous nous permettrons désormais). La structure des fichiers DFM (fiches) ne sera pas vue car ce n'est pas du texte compréhensible qui y est inscrit (mais nous y reviendrons).

Le mieux pour suivre les explications données est de lancer Delphi et d'ouvrir le projet PremierEssai déjà commencé. Les seuls éléments du projet sont alors une unité (« Principale ») et une fiche (Form1). Pour voir le fichier projet (PremierEssai), deux possibilités :

  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 :

    Image non disponible

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

V-C-1. Structure d'un fichier projet

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

 
Sélectionnez

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.

V-C-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 :

 
Sélectionnez

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 :

 
Sélectionnez

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 :

 
Sélectionnez

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 :

 
Sélectionnez

{$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 :

bloc uses de la partie parties dans lesquelles ce bloc agit
Interface Interface, Implémentation
Implémentation Implémentation


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.

V-D. Constantes et Variables

Ce paragraphe est consacré à l'étude des fameuses « données » dont on n'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.

Les paragraphes qui suivent décrivent l'usage de ces deux notions.

V-D-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.

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

 
Sélectionnez

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

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

 
Sélectionnez

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;

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 :

 
Sélectionnez

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 :

 
Sélectionnez

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 :

 
Sélectionnez

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.

V-D-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 :

 
Sélectionnez

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 :

 
Sélectionnez

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 :

 
Sélectionnez

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.

V-E. 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.


précédentsommairesuivant

  

Copyright © 2008 Frédéric Beaulieu. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.