|
|
Marco Cantù
Traduit de l'anglais par Iannis Papageorgiadis [email protected] |
Chapitre 2
|
Avant d'aborder le sujet de l'écriture des instructions du langage Pascal, il importe de mettre en évidence quelques éléments du style d'encodage Pascal. La question que nous souhaitons traiter est la suivante : indépendamment des règles de syntaxe, comment devrait-on écrire du code ? Il n'y a pas qu'une seule réponse à cette question, puisque le goût personnel peut dicter à chacun différents styles. Cependant, il y a quelques principes que l'on doit connaître concernant les commentaires, les majuscules, les espaces, et tout ce qu'on appelle la belle impression. En général, chaque style d'écriture de code a pour but la clarté. Le style et les décisions de formatage que vous prenez sont une sorte de raccourci indiquant le but d'un morceau de code donné. Un outil essentiel pour arriver à la clarté est la cohérence; quel que soit le style que vous choisissez, assurez vous de le conserver à travers tout le projet.
{ceci est un commentaire}
(* ceci est un autre commentaire *)
// ceci est un commentaire jusqu'en fin de ligne
La première forme est plus courte et plus souvent utilisée.
La seconde forme a souvent été préférée
en Europe parce que sur plusieurs claviers européens manque le symbole
de l'accolade. La troisième forme de commentaires a été
empruntée au C++ et est disponible uniquement dans les versions
32 bits de Delphi. Les commentaires jusqu'en fin de ligne sont très
utiles pour les commentaires courts et pour désactiver une ligne
de code en la mettant en commentaire.
Dans les listings de ce livre, nous essaierons d'indiquer les commentaires en italiques (et les mots réservés en gras), pour rester cohérent avec la mise en évidence de la syntaxe par défaut de Delphi.
Disposer de trois formes différentes de commentaires peut être
utile pour effectuer des commentaires imbriqués. Si vous souhaitez
désactiver plusieurs lignes de code en les plaçant en commentaire
et si ces lignes contiennent quelques véritables commentaires, vous
ne pouvez pas utiliser le même identificateur de commentaire
{... code
{commentaire, créant des problèmes}
... code}
Avec un second identificateur de commentaire, vous pouvez écrire
le code suivant, qui est correct :
{ ... code
//ce commentaire est correct
... code}
Notez que si l'accolade ouverte ou la parenthèse-étoile est
suivie du signe dollar ($), elle devient une directive de compilation,
comme p. ex. dans {$X+}.
En fait, les directives de compilation sont aussi des commentaires. Par exemple, {$X+ Ceci est un commentaire} est permis. Cela constitue une directive valide et un commentaire, bien que quelques programmeurs auront probablement tendance à séparer directives et commentaires.
Remarque : Il y a une seule exception à la règle de l'insensibilité à la casse de Pascal : la procédure Register d'un paquet de composants doit commencer par un R majuscule, pour une question de compatibilité avec C++ Builder.
Il existe cependant deux légers inconvénients. Premièrement, vous devez être conscient que ces identificateurs sont réellement les mêmes; de la sorte, vous éviterez de les utiliser comme étant des éléments différents. Deuxièmement, vous devrez essayer d'être cohérent dans l'utilisation des majuscules, pour améliorer la lisibilité du code.
Une utilisation cohérente des majuscules n'est pas imposée par le compilateur, mais c'est une bonne habitude à prendre. Une approche fréquente consiste à mettre une majuscule à la première lettre de chaque identificateur. Lorsqu'un identificateur est composé de plusieurs mots consécutifs (vous ne pouvez pas insérer un espace dans un identificateur), la première lettre de chaque mot devrait être une majuscule:
MonLongIdentificateur MonTresLongEtPresqueIdiotIdentificateurD'autres éléments complètement ignorés par le compilateur sont les espaces, les nouvelles lignes et les tabulations que vous ajoutez dans le code source. Tous ces éléments sont connus sous le nom collectif de espace. Ils sont utilisés uniquement pour améliorer la lisibilité du code; ils n'affectent pas la compilation.
Le Pascal, au contraire du BASIC, permet l'écriture d'une instruction sur plusieurs lignes de code, en coupant une longue instruction en deux ou plusieurs lignes. L'inconvénient (du moins pour certains programmeurs BASIC) d'allouer plus d'une ligne aux instructions est qu'il faut se rappeler d'ajouter un point-virgule pour indiquer la fin d'une instruction, ou plus exactement pour séparer une instruction de la suivante. Notez que la seule restriction à la disposition des instructions de programmation sur plusieurs lignes est qu'une chaîne littérale ne peut occuper plusieurs lignes.
Encore une fois, il n'existe pas de règles établies pour
l'utilisation des espaces et des instructions sur plusieurs lignes; il
n'existe que quelques règles empiriques
if ... then instruction; if ... then begin instruction1; instruction2; end; if ... then begin if ... then instruction1; instruction2; end;
La mise en forme ci-dessus est basée sur la "belle impression",
mais les programmeurs interprètent différemment cette règle
générale. Quelques uns indentent begin et end
au niveau du code interne; quelques autres indentent begin et end
et indentent une fois de plus le code interne; d'autres encore placent
le begin dans la même ligne que le if de la condition.
C'est là une question de goût personnel.
On utilise souvent une indentation similaire pour les listes de variables
ou les listes des types de données, ou encore pour continuer une
instruction se trouvant sur la ligne précédente :
type
Letters = set of Char;
var
Name: string;
begin
{ long commentaire et longue instruction se poursuivant sur la ligne
suivante et indentée de deux espaces}
MessageDlg ('Ceci est un message',
mtInformation, [mbOk], 0);
Bien sûr, de telles conventions ne constituent qu'une suggestion
afin de rendre le code plus lisible à d'autres programmeurs, et
sont complètement ignorées par le compilateur. Nous avons
essayé d'utiliser ces règles dans tous les exemples et dans
tous les fragments de code de cet ouvrage. Le code source des manuels de
Delphi et les exemples de l'aide utilisent un style de formatage semblable
à celui-ci.
Les mots réservés, les commentaires et les chaînes sont probablement les trois éléments auxquels cette caractéristique est la plus profitable. Vous pouvez repérer en un coup d' oeil un mot mal écrit, une chaîne qui n'est pas terminée correctement, et la longueur d'un commentaire sur plusieurs lignes.
Vous pouvez facilement personnaliser l'organisation de la mise en évidence en vous servant de la page Couleurs de la boîte de dialogue Options d'environnement du menu Outils (fig. 2.1). Si vous travaillez seul, choisissez les couleurs qui vous plaisent. Si vous travaillez en collaboration avec d'autres programmeurs, vous devriez vous accorder sur un standard de couleurs. A notre avis, travailler sur un ordinateur avec un coloriage de la syntaxe différent de celui auquel on est habitué est vraiment difficile.
FIGURE 2.1 : La boîte de dialogue utilisée pour définir la mise en évidence de la syntaxe
array [0..] of ;Puisque les Modèles de Code prédéfinis contiennent habituellement plusieurs versions du même assemblage, le raccourci se termine généralement par une lettre indiquant la version qui vous intéresse. Toutefois vous pouvez aussi ne taper que la partie initiale du raccourci. Par exemple, si vous tapez ar et que vous pressez Ctrl+J, l'éditeur affichera un menu local avec une liste des choix disponibles accompagnée d'une courte description, comme vous pouvez le voir à la figure 2.2.
Figure 2.2: Choix des modèles de code
Vous pouvez personnaliser les Modèles de Code en modifiant ceux qui existent ou en ajoutant vos morceaux de code habituels. Si vous le faites, pensez que le texte du Modèle de Code comprend généralement le caractère "|" pour indiquer la position où se trouvera le curseur après l'opération, c'est-à-dire l'endroit où vous pouvez commencer à taper pour compléter le Modèle de Code avec le code personnalisé.
La table 2.1 reprend la liste complète des identificateurs jouant un rôle spécifique dans Pascal Objet (en Delphi 4).
Table 2.1 : Les mots réservés du Pascal Objet
| Mot réservé | Rôle |
|---|---|
| absolue | directive (variables) |
| abstrait | directive (méthode) |
| and | opérateur (booléen) |
| array | type |
| as | opérateur (RTE) |
| as | instruction |
| assembler | compatibilité ascendante |
| ta | instruction (exceptions) |
| automate | spécificateur d'accès (classe) |
| begin | marqueur de bloc |
| case | instruction |
| cdecl | fonction de convention d'appel |
| class | type |
| const | déclaration ou directive (paramètres) |
| constructor | méthode spéciale |
| contains | opérateur (ensemble) |
| default | directive (propriété) |
| destructor | méthode spéciale |
| dispid | spécificateur d'interface de répartition |
| dispinterface | type |
| div | opérateur |
| do | instruction |
| downto | instruction (for) |
| dynamic | directive (méthode) |
| else | instruction (if ou case) |
| end | marqueur de bloc |
| except | instruction (exceptions) |
| export | compatibilité ascendante (classe) |
| exports | déclaration |
| external | directive (fonctions) |
| far | compatibilité ascendante (classe) |
| file | type |
| finalization | structure d'unité |
| finally | instruction (exceptions) |
| for | instruction |
| forward | directive de fonction |
| function | déclaration |
| goto | instruction |
| if | instruction |
| implementation | structure d'unité |
| implements | directive (propriété) |
| in | opérateur (ensemble) - structure de projet |
| index | directive (interface de répartition) |
| inherited | instruction |
| initialization | structure d'unité |
| inline | compatibilité ascendante (voir as) |
| interface | type |
| is | opérateur (RTE) |
| label | déclaration |
| library | structure de programme |
| message | directive (méthode) |
| mod | opérateur (math) |
| name | directive (fonction) |
| near | compatibilité ascendante (class) |
| nil | valeur |
| nodefault | directive (propriété) |
| not | opérateur (booléen) |
| object | compatibilité dascendante (class) |
| of | instruction (case) |
| on | instruction (exceptions) |
| or | opérateur (booléen) |
| out | directive (paramètres) |
| overload | directive de fonction |
| override | directive de fonction |
| package | structure de programme (paquets) |
| packed | directive (enregistrement) |
| pascal | convention d'appel de fonction |
| private | spécificateur d'accès (classe) |
| procedure | déclaration |
| program | structure de programme |
| property | déclaration |
| protected | spécificateur d'accès (class) |
| public | spécificateur d'accès (class) |
| published | spécificateur d'accès (class) |
| raise | instruction exceptions |
| read | spécificateur de propriété |
| readonly | spécificateur d'interface |
| record | type |
| register | convention d'appel de fonction |
| reintroduce | directive de fonction |
| repeat | instruction |
| requires | structure de programme (paquets) |
| resident | directive (fonctions) |
| resourcestring | type |
| safecall | convention d'appel de fonction |
| set | type |
| shl | opérateur (math) |
| shr | opérateur (math) |
| stdcall | convention d'appel de fonction |
| stored | directive (propriété) |
| string | type |
| then | instruction (if) |
| threadvar | déclaration |
| to | instruction (for) |
| try | instruction (exceptions) |
| type | déclaration |
| unit | structure d'unité |
| until | instruction |
| uses | structure d'unité |
| var | déclaration |
| virtual | directive (méthode) |
| while | instruction |
| with | instruction |
| write | spécificateur de propriété |
| writeonly | spécificateur d'interface de répartition |
| xor | opérateur (booléen) |
Les expressions sont communes à plusieurs langages de programmation. Une expression est toute combinaison valide de constantes, de variables, de valeurs littérales, d'opérateurs, et de résultats de fonctions. Les expressions peuvent aussi être passées aux paramètres valeur des procédures et fonctions, mais pas aux paramètres variables (qui exigent qu'une valeur puisse leur être assignée).
Contrairement à beaucoup d'autres langages,
la priorité des opérateurs and et or est comparable
à celle des opérateurs relationnels. Ainsi, si vous écrivez
a < b and c < d, le compilateur essaiera d'effectuer en premier
lieu l'opération and; une erreur de compilation sera alors
produite. C'est pour cette raison que vous devriez placer ces expressions
dans des parenthèses
Remarquez que quelques-uns des opérateurs courants ont des significations différentes en fonction des types de données. Par exemple, l'opérateur + peut être utilisé pour additionner deux nombres, concaténer deux chaînes, effectuer l'union de deux ensembles, et même additionner un déplacement (offset) à un pointeur PChar. Cependant, vous ne pouvez pas additionner deux caractères, comme cela est permis en C.
Div est un autre opérateur étrange. En Pascal, vous pouvez diviser deux nombres (réels ou entiers) à l'aide de l'opérateur / et dans les deux cas vous obtiendrez comme résultat un réel. Si vous devez diviser deux entiers et que vous souhaitez un résultat entier, utilisez par contre l'opérateur div.
Table 2.2 : Les opérateurs Pascal groupés par ordre de
priorité
| Opérateurs unaires (la plus haute priorité) | |
|---|---|
| @ | Adresse de la variable ou de la fonction (retourne un pointeur) |
| not | Booléen ou négation binaire |
| Opérateurs multiplicatifs et binaires | |
| * | Multiplication arithmétique ou intersection de deux ensembles |
| / | Division avec virgule flottante |
| div | Division entière |
| mod | Modulo (reste de la division entière) |
| as | Transtypage contrôlé (RTE) |
| and | Booléen ou Et binaire |
| shl | Décalage à gauche binaire |
| shr | Décalage à droite binaire |
| Opérateurs d'addition | |
| + | Addition arithmétique, union de deux ensembles, concaténation de chaînes, addition de décalage et de pointeur |
| - | Soustraction arithmétique, différence de deux ensembles, soustraction déplacement pointeur |
| or | Booléen ou Ou binaire |
| xor | Booléen ou Ou exclusif binaire |
| Opérateurs Relationnels et de comparaison (la plus basse priorité) | |
| = | égal |
| <> | différent |
| < | inférieur |
| > | supérieur |
| <= | inférieur ou égal, ou sous-ensemble de |
| >= | supérieur ou égal, ou sur ensemble de |
| in | membre de |
| is | Vérification de type dynamique (un autre opérateur RTE) |
Style := Style + [fsBold]; Style := Style + [fsBold, fsItalic] - [fsUnderline];Vous pouvez également utiliser les procédures standard Include et Exclude, qui sont nettement plus efficaces (mais qui ne peuvent pas être utilisées avec les propriétés des composants du type ensemble, parce qu'elles exigent un paramètre valeur compatible avec le type de base de l'ensemble) :
Include (Style, fsBold);
| © Copyright Marco Cantù, Wintech Italia Srl 1995-99 |