Suivez-nous sur X
|
|
|
0,
A,
B,
C,
D,
E,
F,
G,
H,
I,
J,
K,
L,
M,
N,
O,
P,
Q,
R,
S,
T,
U,
V,
W,
X,
Y,
Z,
ALL
|
|
0,
A,
B,
C,
D,
E,
F,
G,
H,
I,
J,
K,
L,
M,
N,
O,
P,
Q,
R,
S,
T,
U,
V,
W,
X,
Y,
Z
|
|
0,
A,
B,
C,
D,
E,
F,
G,
H,
I,
J,
K,
L,
M,
N,
O,
P,
Q,
R,
S,
T,
U,
V,
W,
X,
Y,
Z
|
|
A propos d'Obligement
|
|
David Brunet
|
|
|
|
Programmation : Pascal - Les types de base et instructions conditionnelles
(Article écrit par Olivier Garrigues et extrait d'Amiga News Tech - avril 1992)
|
|
Suite de notre exploration des types primaires que le langage Pascal met à notre disposition. Nous en finirons
ici avec les chaînes de caractères, puis attaquerons les instructions conditionnelles.
Pourquoi ai-je parlé si rapidement des chaînes de caractères, alors qu'il y tant de choses à dire ? Il faut savoir
que les chaînes sont un outil très souvent utilisé. Bien les connaître permet (de toute façon) de mieux appréhender le
langage Pascal. Mais reprenons notre étude. Mister Quaid a eu la très bonne idée de permettre les caractères d'échappement
dans les chaînes. Ce sont pour la plupart des codes ASCII difficilement accessibles au clavier. Pour les obtenir, on
utilise un caractère particulier d'introduction, le "\" (barre oblique inversée, ou "backslash"). Il doit être suivi
par un autre caractère, significatif de l'effet désiré. Ces séquences d'échappement sont en grande partie inspirées de
celles que l'on trouve en langage C :
- '\n' : passage à la ligne (Line Feed).
- '\t' : tabulation horizontale.
- '\0' : marque de fin de chaîne.
- '\b' : effacement à gauche (backspace).
- '\e' : échappement (Escape, pour les imprimantes).
- '\c' : CSI (pour les codes ANSI du console.device).
- '\a' : alerte (le DisplayBeep).
- '\f' : saut de page (Fora Feed).
- '\r' : retour en colonne (Carriage Return).
- '\v' : tabulation verticale.
- '\\' : le caractère "\" lui-même.
Deux remarques : les minuscules sont de rigueur. Si vous utilisez des majuscules, la barre oblique inversée
est ignorée. Bien que deux caractères soient utilisés pour la représentation, un seul est effectivement inséré
dans la chaîne. Attention donc si vous faîtes des calculs sur la longueur de la chaîne.
Ceux qui connaissent un peu l'informatique mais pas trop l'Amiga peuvent se demander ce qu'est le CSI (Control
Sequence Introducer). Le CSI est un code d'introduction standard pour les périphériques fichiers tel que le
périphérique logique PRT: (imprimante) ou les fenêtres CON: et RAW:. Les caractères qui le suivent ne sont pas
écrits mais interprétés par le console.device pour obtenir divers effets :
Nous avons vu qu'il existe deux sortes de chaînes, qui dépendent de la méthode de stockage en mémoire utilisée. La
première est le tableau de caractères. Pour pouvoir l'utiliser, il faut d'abord le déclarer puis l'initialiser par une affectation :
VAR MonTab : ARRAY [1..] OF CHAR ;
|
...qui signifie que la variable "MonTab" est un tableau d'indice 1 à <taille> de caractères ("of char"
veut dire "de caractères"). Ce type est limité car peu implémenté. On peut seulement affecter une chaîne constante entre
apostrophes de même longueur strictement, tester l'égalité entre deux tableaux de même longueur, lire le tableau à
partir d'un fichier ou du clavier et l'écrire. L'accès à l'un de ses caractères se fait, en reprenant l'exemple, par
Montab[<n° du caractère>]. Un exemple :
Le seul avantage est qu'il n'y a pas de dépassement de capacité : sachant que le nombre de cases d'un tableau est
égal à la différence des indices des extrêmes plus 1, pendant une saisie, le nombre de caractères recopiés dans
le tableau sera au plus égal au nombre de cases de celui-ci. Si par hasard, le nombre de caractères recopiés est
inférieur au nombre de cases et la procédure employée est "READ", le dernier caractère du tableau sera "EOL"
(ou LF pour les intimes).
La deuxième méthode est l'utilisation du type STRING. D'une approche plus complexe, ce type nécessite l'inclusion
de fonctions et de procédures non définies, ce que l'on fait par la directive de compilation (ne cherchez pas à
comprendre, ce n'est qu'une technique, donc appliquez) {$I "INC:StringLib.i" }
La seule obligation est de ne pas mettre d'espaces entre l'accolade ouvrante "{" et la directive "$1".
Pour ceux qui veulent comprendre cette phrase magique, une directive de compilation est un ordre qui n'appartient pas
au Pascal, mais est directement destiné au compilateur. Elle doit donc être mise comme un commentaire, d'où
les accolades. "$1" signifie inclure le texte contenu dans le fichier "INC:StringLib.i".
Comme cela a déjà été précisé, nous avons affaire à des pointeurs sur des caractères ; nous devons, pour les utiliser,
initialiser un espace de travail pour chaque variable de type STRING. Si nous ne le faisons pas, nous allons écrire
ou lire dans une zone inconnue de la mémoire (pour lire cela ne pose pas trop de problème, mais pour écrire, gare au
Guru !). Le compilateur ne se chargeant pas d'allouer une telle zone lui-même, il faut appeler la fonction AllocString(),
dont la fiche suit (elle se trouve dans StringLib.i) :
Function AllocString (taille : integer ) : string ;
|
Elle alloue un espace mémoire de la taille <taille> (pour une chaîne de <taille-1> caractères) et retourne
une variable de type STRING (c'est-à-dire un pointeur sur le début de la zone en question).
Il faut noter que l'on peut affecter deux variables de type STRING ensemble, mais ce n'est pas totalement l'effet
désiré car toute modification à travers l'une se répercutera sur l'autre : c'est un effet de bord par indirection
très connu. Il faut mieux utiliser la procédure StrCpy (destination, source), qui copie le contenu de la chaîne
désignée par <source> dans celle désignée par <destination>.
Quels sont les avantages de cette implémentation ? Il existe plusieurs petites fonctions ou procédures rattachées
à ce type. Pour une comparaison ou d'autres primitives, il n'est pas nécessaire que les arguments aient la même
taille (dans le sens du contenant). On peut aussi accéder à un caractère particulier de la chaîne par la méthode
d'indice. VAR s:STRING;.
On accède au n-ième caractère de "s" en écrivant "s[<-1>]" (-1 car l'indice commence à zéro).
Note : une constante caractère est un signe (caractères d'échappement compris) entre apostrophes. Par exemple,
'C' (la lettre C majuscule), '10' pour le caractère NULL, etc. Le petit exemple final sur le type STRING
(je ne dis pas que j'ai fini avec ce type, mais vous devez en voir de toutes les longueurs !).
Les conditions
Bon, assez parlé des chaînes, continuons notre découverte du Pascal. Pour cette partie, nous allons étudier
les instructions de contrôle du flux d'exécution. On entend par là, toute instruction qui modifie le cours
des ordres, comme une exécution conditionnelle ou une boucle.
Il existe deux sortes de contrôles d'exécution conditionnelle : le "IF" et le "CASE".
L'instruction "IF" s'écrit :
IF <condition> THEN <instruction1> [ELSE <instruction2>];
|
- <condition> est du type booléen (Boolena).
- <instruction1> est exécutée si la condition est vraie (TRUE).
- <instruction2> est exécutée si la condition est fausse (FALSE).
Cette instruction est optionelle. Puis le programme passe à l'instruction suivante. La faute qu'il ne faut pas faire :
IF <condition> THEN <instruction1>, ELSE <instruction2>;
|
Le "ELSE" est séparé de son "IF" par le premier ";", une erreur de compilation est générée. Les opérateurs de
comparaison de base pour les numériques, pour les booléens, pour le type char et les types énumérations sont :
- = : égal à (on l'a déjà utilisé).
- > : supérieur à.
- < : inférieur à.
- >= : supérieur ou égal à.
- <= : inférieur ou égal à.
- <> : différent de.
Ce sont des opérateurs binaires (c'est-à-dire à deux arguments). Ils renvoient tous un booléen. En rappel,
un opérateur a comme syntaxe : <opérande1> <opérateur> <opérande2>. Par exemple : x<y, x=y, x>=y.
Les opérateurs "=>" et "=<" ne sont pas implémentés, seuls sont utilisés ">=" et "<="
(c'est facile à retenir car ils s'écrivent comme nous les prononçons). Je ne vous fais pas l'affront de vous
dire qu'il faut que les deux arguments soient du même type (avec l'exception des entiers vu le mois dernier).
Pour les booléens, il existe aussi les "et", "ou", "not" pour l'algèbre de Boole. Ils sont aussi implémentés pour
les types cardinaux (entiers, CHAR, énumération).
- op1 AND op2 est vrai si et seulement si op1 et op2 sont vrais.
- op1 OR op2 est vrai si op1 ou bien op2 ou les deux sont vrais.
- NOT op passe l'opérateur de vrai à faux et inversement.
Par ailleurs, l'instruction d'un IF peut être un autre IF (on parle de IF imbriqués), il n'y pas de restrictions à la
quantité de IF imbriqués.
Pour éviter de nombreux "If then else if then else if...", la notion de cas a été implémentée. Elle recherche
dans les tous cas spécifiés, en les testant l'un après l'autre, le premier qui donne la réponse TRUE, puis execute
l'instruction qui lui est associée. Sa forme syntaxique est :
<Variable> est une variable de type scalaire autre que REAL (ce que l'on nomme généralement les cardinaux).
<comparaisons> sont les valeurs auxquelles la variable sera comparée. <instructions> sont les instructions qui
seront exécutées si la comparaison s'avère vraie.
Il existe plusieurs méthodes permises pour le cas. La première est la comparaison avec une constante (aucune variable
n'est autorisée). La seconde est la comparaison sur un intervalle : si la valeur est dans cet intervalle, le cas
sera exécuté, la troisième est le mélange des deux.
Allez pour finir, un exemple récapitulatif. La spécification du programme est : calcul arithmétique sur
deux entiers, saisis à partir du clavier.
Quelques remarques et conseils :
- Si vous avez un intervalle dans lequel quelques valeurs sont particulières, faite un CASE avec
les valeurs particulières avant le traitement de l'intervalle en question ; ne cherchez pas à le diviser
en sous-intervalles, ainsi vous pourrez toujours ajouter de nouvelles valeurs particulières.
- Utilisez plutôt un CASE que des IF imbriqués quand vous le pouvez, le code devrait normalement être plus optimisé.
- Attention à ne pas confondre l'intervalle (deuxième forme) avec le regroupement de cas (troisième forme),
par exemple la lettre 'c' est dans l'intervalle 'a'..'d' mais n'est pas dans les cas 'a','d'.
Le mois prochain, nous continuerons avec les boucles. Nous commencerons les constructeurs de types
(encore du travail en perspective). Bye et au mois prochain.
|
