Pascal-6 (c) Dr M.Ziade'. FACULTE DE GENIE, Liban. Faculty of Engineering, Lebanon. Dr M.Ziadé. Faculté de Génie, ingénieur. Universite Libanaise

www.facultedegenie.net SITE INDEPENDANT (non-officiel) FACULTE DE GENIE (LIBAN) Faculty of Engineering (Lebanon)	(net sponsor)
Zone PROF - Zone INGENIEUR - Zone ETUDIANT - Zone VISITEUR	Next Page N.116

* Guest-Book *
* News-Group *
Suggest update

f
a
c
u
l
t
e
d
e
g
e
n
i
e
.
n
e
t

w
w
w
.
f
a
c
u
l
t
e
d
e
g
e
n
i
e
.
n
e
t

g
r
o
u
p
.
f
a
c
u
l
t
e
d
e
g
e
n
i
e
.
n
e
t

Informatique : PASCAL (Chapitre VI)

AFFECTATIONS, TESTS, BOUCLES
(c) Dr Mustapha ZIADE'

This text copyright = www.ziade.net
Ce texte vient de © www.ziade.net

(VI.1) Commentaires (dans un programme)

- Les commentaires (ou remarques) sont des phrases (ou des suites de caractères) qui ne sont pas compilées, donc elles ne sont pas exécutés. Les commentaires sont utiles aux programmeurs, par exemple pour faire évoluer un programme qui a été écrit (parfois par soi-même) il y a quelques mois.

En Pascal les commentaires sont placés entre accolades (sans de ; après), par exemple:
{ voici un commentaire }

Les commentaires peuvent être placés entre (* et *), comme par exemple:
(* ceci est aussi un commentaire *)

(VI.2) Affectations

- L'affectation permet de stocker une valeur dans une variable. La syntaxe est la suivante:
'' identificateur := expression ; ''.

L'identificateur est le nom de la variable, et l'expression est: un nombre, ou une constante, ou une variable, ou le résultat d'une fonction, ou le résultat d'un calcul. Voici les exemples respectifs:

X := 2.5 ; { le nombre 2.5 est affecté à X }
N := N_MAX ; { la valeur de la constante N_MAX est affectée à N }
Y := X ; { la valeur contenue dans la variable X est affectée à Y }
Z := sqrt (2) ; { la racine carrée de 2 est affectée à Z }
A := 2*X - N + 7 ; { la valeur de 2X-N+7 est affectée à A }

Il est évident que les ''affectations'' suivantes sont impossibles:
2.5 := X ;
sqrt (2) := Z ;
2*X - N + 7 := A ;

Attention: un résultat de type réel ne peut pas être affecté à une variable de type entier.

En particulier: si N entier, et X réel alors N := X est impossible (quelle que soit la valeur de X).

Autres exemples impossibles:
N := 7.0 ; { 7.0 est un réel }
N := (A or B) ; { OR donne un booléen }
N := 4 / 2 ; { la division / donne un réel }
N := sin(0) ; { la fonction sin donne un réel }

Revoir le Chapitre III, §1 à §3, pour plus de détails.

(VI.3) Séquence ou bloc (d'instructions)

Un bloc ou une séquence est une suite d'instructions commençant par le mot réservé BEGIN et se terminant par le mot réservé END; (il y a un ; après le END mais pas après le BEGIN). Exemple:

BEGIN
X := N ;
{ un réel peut recevoir un résultat de type entier }
END ;

(Remarque: la séquence ''vide'' c.-à-d. '' BEGIN END; '' sans aucune instruction est autorisée)

(VI.4) Test conditionnel (if … then … else …)

Voici un exemple simple d'un test conditionnel (si… alors… sinon…) :

IF A<=B THEN
BEGIN
MINE := A ;
{ la valeur de A est affectée à MINE si A£ B }
END
ELSE { c'est-à-dire ici A>B }
BEGIN
MINE := B ;
{ la valeur de B est affectée à MINE si A>B }
END ;
WRITELN ( ' Le minimum de A et de B est ' , MINE ) ;

Remarque: le dernier WRITELN ne fait pas partie du ''IF…THEN…ELSE…''.

Attention: il n'y a pas de ; (point virgule) avant le ELSE.

Remarque: la séquence ELSE est facultative (non obligatoire), par exemple:

IF A <> 0 THEN
BEGIN
WRITELN ( ' ici A est non nul ' ) ;
END ; { fin du IF…}
WRITELN ( ' ici A peut être nul ou non nul ' ) ;

(VI.5) Choix multiples (case … of …)

Voici un exemple simple de choix multiple (N étant de type entier) :

CASE N OF
1 : BEGIN writeln ( ' ici N=1 ' ) ; X := abs(X) ; {exemple}
END;
2 .. 5 : BEGIN writeln ( ' ici 2£ N£ 5 ' ) ;
END;
0 , 6 , 7 : BEGIN writeln ( ' ici N=0 ou 6 ou 7 ' ) ; X := 0 ;
END ;
ELSE BEGIN writeln ( ' ici N<0 ou N>7 ' ) ; { tous les autres cas }
END ;
END ; { fin du CASE… }

Attention: le dernier END est nécessaire car il fait partie de l'instruction ''CASE…OF…''.

Le compilateur n'exécute que les instructions situées entre le BEGIN et le END du seul cas qui correspond à la valeur de la variable écrite entre le CASE et le OF.

Dans l'exemple ci-dessus, l'instruction X:=0 sera exécutée seulement si N=0 ou 6 ou 7.

DONC les différents cas (ou choix situés entre le CASE et son END) doivent être mutuellement exclusifs (c.-à-d. indépendants).

La variable (parfois appelée index) en fonction de laquelle agit le CASE doit être de type entier (integer, byte, word, shortint, longint). Elle peut aussi être de type caractère, comme par exemple:

CASE LTR OF
'a' , 'A' : BEGIN writeln ( ' ici le caractère LTR est la lettre A (ou a) ' ) ;
END;
ELSE BEGIN writeln ( ' ici le caractère LTR n'est pas la lettre A (ni a) ' ) ;
END ;
END ; { fin du CASE… }

Attention: il est impossible que la variable écrite entre le CASE et le OF soit de type réel (real, single, double, comp, extended).

Remarque: en TurboPascal, la variable du CASE…OF peut être de type booléen ou de type énuméré.

(VI.6) Boucles itératives (for … to … do)

Voici un exemple simple d'une boucle, pour N entier de 2 à 7, il affiche la valeur de N et son carré:

FOR N := 2 TO 7 DO
BEGIN
WRITE ( ' N = ' , N , ' et ' ) ;
WRITELN ( ' N² = ' , N*N ) ;
END;

Par définition, la variable qui suit le FOR s'appelle indice de la boucle.

Le compilateur exécute les étapes suivantes:

- étape 1: initialiser l'indice (exécute l'affectation écrite entre FOR et TO),

- étape 2: comparer l'indice à la limite (valeur écrite entre TO et DO),

- si l'indice est supérieur à la limite alors aller à l'étape 5 (sinon aller à l'étape 3),

- étape 3: exécuter la séquence d'instructions (BEGIN…END; correspondants à la boucle),

- étape 4: augmenter l'indice d'une unité puis aller à l'étape 2,

- étape 5: exécuter l'instruction qui suit la boucle (après le END de la boucle).

Attention: en Pascal, l'indice d'une boucle itérative est obligatoirement de type entier. Et seul un pas (saut) de +1 ou -1 est valable.

Voici une boucle décroissante (de pas -1)
for i:=9 downto 3 do …

Conseil: un bon programmeur ne modifie pas la valeur de l'indice dans une boucle itérative.

(VI.7) Boucles ''répéter … jusqu'à ce que …'' (repeat … until …)

Voici un exemple simple d'une boucle ''répéter … jusqu'à ce que …'' :

REPEAT
WRITE ( ' Donnez un nombre entier N (ou 1 pour finir) ' ) ;
READLN (N) ;
WRITELN ( ' N² = ' , N*N ) ;
UNTIL N=1;

Le compilateur répète l'exécution de la suite d'instructions écrites entre REPEAT et UNTIL jusqu'à ce que la condition qui suit le UNTIL soit vraie.

Le programmeur peut utiliser un ''indice'' quelconque avec les boucles REPEAT…UNTIL… ,
s'il le fait il doit alors initialiser cet indice avant l'exécution de la boucle, et modifier lui-même l'indice. Voici un exemple:

X := 2 ;
REPEAT
WRITELN ( ' X= ' , X , ' et X² = ' , X*X ) ;
X := X + 0.5 ; { modification de X par saut de 0.5 }
UNTIL X>7;

Comparer cet exemple avec l'exemple du paragraphe VI.4 (ci-dessus).

La boucle REPEAT…UNTIL… est toujours exécutée au moins une fois car la condition est à la fin.
La condition est dite postopératoire car elle est testée après avoir opéré le traitement du REPEAT.

(VI.8) Boucles ''tant que … faire …'' (while … do …)

Voici un exemple (à comparer à l'exemple précédent):

X := 2 ;
WHILE X<7.5 DO
BEGIN
WRITELN ( ' X= ' , X , ' et X²= ' , X*X ) ;
X := X + 0.5 ;
END ;

Le compilateur teste la condition écrite entre le WHILE et le DO, si cette condition est vraie alors il exécute la séquence d'instruction qui suit (le DO), sinon cette séquence n'est pas exécutée.
La condition est dite préopératoire car elle est testée avant d'opérer le traitement du WHILE.

(VI.9) Conseil important

Le programmeur doit toujours vérifier que le programme est écrit de façon à ce que toutes les boucles finissent par se terminer.

En particulier
- il vaut mieux remplacer les conditions d'égalité (ex: N=7) par des conditions d'inégalité (ex: N<=7 ou N>=7).
- il faut faire attention aux erreurs dues aux calculs numériques (revoir le Chapitre II*****).

(I) Introduction Générale

(II) Erreurs ou Limites des Calculs Numériques et informatiques *****

(III) Types, Opérateurs, Fonctions et Procédures prédéfinis

(IV) Partie Déclarative d'un programme

(V) Structure d'un programme

(VI) Affectations, Tests, Boucles

(VII) Fonctions, Procédures, Récursivité

(VIII) Fichiers Textes, Fichiers Binaires

(IX) Pointeurs

(i) Faculté de Génie, Liban