Cours les bases du langage Pascal
Cours les bases du langage Pascal
...
3 Premiers éléments de Pascal
3.1 Le Langage Pascal
3.1.1 C'est un langage typé
- Toutes les variables doivent être déclarées
- Leur type doit être explicitement défini
3.1.2 C'est un langage structuré
- Le langage permet de définir des procédures et fonctions qui sont des sortes de sous-programmes (Cf. chapitre 8).
- Un problème peut ainsi être décomposé en sous-problèmes.
3.1.3 C'est un langage récursif
Les procédures et fonctions peuvent « s’appeler » elles-mêmes (Cf. chapitre 12).
3.2 Structure globale d’un programme Pascal
- En-tête
C’est la première ligne d'un programme PASCAL.
L'en-tête commence toujours par le mot-réservé program. Elle est suivie d'un identificateur choisi par le programmeur.
Syntaxe :
program identificateur;
Exemple :
program Second_Degre ;
- Déclarations
En Pascal, on peut déclarer des :
- des constantes
- des types
- des variables
L'ordre indiqué doit être impérativement respecté.
- Instructions
Une instruction est une phrase du langage représentant un ordre ou un ensemble d'ordres qui doivent être exécutés par l'ordinateur.
On distingue :
Les instructions simples :
Ordre unique, inconditionnel (Ex : affectation)
Les instructions structurées
- instructions composées
- instructions itératives
- instructions conditionnelles
Quelques caractéristiques des instructions :
- Pas de format fixe
- Possibilité de spécifier une instruction sur plusieurs lignes ou plusieurs instructions sur une seule ligne
- Début d'une instruction :
▪ un mot clé
▪ un identificateur
- Fin d'une instruction : par un point virgule ;
- Structure de bloc
En Pascal, le bloc d'instructions principal commence par « begin » et se termine par « end. »
- Exemple de programme
Nous présentons ci-dessous un programme qui donne la moyenne de n nombres entrés au clavier par l'utilisateur, qui précisera le nombre de données qu'il va taper. A ce stade du cours, il n'est pas nécessaire de comprendre le contenu de ce programme. Il suffit simplement de reconnaître l'architecture globale décrite précédemment (déclarations de variables, blocs, indentations, begin...end)
program moyenne ; {En-tête}
var {Déclarations}
donnee, somme, moyenne : real; i, n : integer ;
begin {début du bloc d'instructions}
writeln('entrer le nombre de données'); readln(n);
if n > 0 then begin
somme := 0;
for i := 1 to n do begin
read(donnee);
somme := somme + donnee; end;
moyenne := somme / n; writeln('moyenne =',moyenne);
end else
writeln('pas de donnees');
end. { fin du bloc d'instructions}
Remarques : Il est conseillé d’utiliser
- des indentations pour refléter la structure du programme.
- des commentaires pour souligner des points importants.
Un commentaire peut être ajouté en n’importe quel point du programme Un commentaire est un texte encadré par des accolades ou par les caractères (* et *).
Exemples :
{ ceci est un commentaire } (* en voici un autre*)
Les commentaires sont destinés à faciliter la lecture et la compréhension du programme par les programmeurs. Ils n’ont aucune incidence sur le fonctionnement du programme.
3.2.1 L'Alphabet
L'alphabet Pascal est constitué des éléments suivants :
- Les majuscules : A, B,..., Z(26 caractères)
- Les minuscules :a, b,..., z(26 caractères)
- Le caractère "blanc"
- Les chiffres : 0, 1,..., 9
- Les symboles spéciaux :
- Les opérateurs :
o arithmétiques : + - * /
o relationnels :< ; > ; = ; <= ; >= ; <>
- Les séparateurs : ( ) ; { } ; [ ] ;(* *)
- Le signe "pointeur" : ^ (utile pour les fichiers ,Cf. chapitre XI )
- Les signes de ponctuation : . , ; : ' ` ! ?
3.2.2 Les mots du langage
- Définition
Un mot est une suite de caractères encadrés par des espaces ou des caractères spéciaux.
Certains mots sont réservés. Ils ne peuvent être redéfinis par l'utilisateur, parce qu’ils participent à la construction syntaxique du langage.
Exemples de mots réservés :
const var type array record begin end procedure function if then else case while repeat for in until with do and or ...
- Les identificateurs
Un identificateur est un nom donné à un élément du programme (constante, variable, fonction, procédure, programme, ...) par le programmeur.
En Pascal :
- Un identificateur est une suite alphanumérique commençant nécessairement par une lettre de l'alphabet et ne comportant pas d'espaces.
- Il est possible de lier plusieurs mots à l'aide de " _ ".
Exemples d'identificateurs légaux :
x2 Z31 xBarre SOMME salaire_net
Exemples d'identificateurs non légaux :
3Mots U.T.C. mot-bis A!8 $PROG AUTRE MOT
- Les identificateurs standards
Les identificateurs standards sont des identificateurs prédéfinis ayant une signification standard.
A la différence des mots réservés, ils peuvent être redéfinis par le programmeur (mais c’est fortement déconseillé).
Exemples d'identificateurs standards :
Fonctions :
cos sin exp sqr sqrt succ pred Constantes :
maxint true false Types :
integer real boolean char Procédures :
read write reset rewrite
3.3 Déclarations
En Pascal, tout symbole (constante, type, variable, procédure, fonction) utilisé dans un programme doit être explicitement déclaré.
3.3.1 Constantes
L'utilisation de constantes en programmation est vivement conseillée. Les constantes permettent :
- de clarifier le programme
Exemple : PI à la place de 3,141592653
- de faciliter la modification : il suffit de modifier la valeur spécifiée dans la déclaration au lieu d'en rechercher les occurrences et de les modifier dans tout le programme.
Syntaxe :
Exemples :
const
DEUX = 2;
PI = 3.14;
VRAI = true; { } FAUX = false; CAR_A = 'A';
PHRASE = 'il fait beau';
Le point virgule est obligatoire à la fin de chaque déclaration.
3.3.2 Types
Un type définit l’ensemble des valeurs que peut prendre une donnée.
Il existe des types standard, mais on peut également déclarer de nouveaux types.
- Les types standards
Un type standard est un type qui est normalement connu de tout langage Pascal et qui n'a donc pas été déclaré par l'utilisateur.
Les types standards sont: integer, real, boolean, char et string.
- Le type integer :
Les valeurs correspondant à ce type sont des nombres entiers.
Ce sont des suites de chiffres, éventuellement précédées d'un signe + ou –, qui ne contiennent ni point décimal, ni exposant.
Exemples d'entiers corrects :
589 0 7 +7 -28 -9999
Exemples d'entiers incorrects :
- 644 895
On ne peut pas représenter en mémoire tous les entiers. Le nombre de bits utilisable pour coder un entier est fixe, mais varie en fonction des compilateurs.
▪ Sur n bits, il sera possible d'utiliser des entiers compris entre :
- 2n-1et (2n-1 - 1)
▪ Par exemple, sur 16 bits , les entiers seront compris entre :
-32768 et 32767 (216=32768)
La plupart des compilateurs définissent également le type longint qui permet de coder des
« entiers longs », en doublant le nombre de bits utilisables.
- Le type real
Les valeurs sont des réels.
Représentation décimale :
Signe + partie entière + point + partie décimale
Diagramme syntaxique d'un réel non signé :
Exemples de réels correctement écrits :
3.5 -7.80 0 -0.656 +95000.0
Exemples de réels incorrectement écrits : 8. 75,632 100.
Représentation en virgule flottante On ajoute un exposant.
Notation : lettre E suivie d'un entier signé ou non signé
Diagramme syntaxique général (valable aussi bien pour les entiers que les réels) :
Exemples d'écriture correcte : 7E-5 -1.2345e2 +60e+4
Exemples d'écriture incorrecte :
45 E3 6.3E2.4 IX 2/3
Il est possible de représenter en mémoire de très grandes valeurs, mais là encore il est impossible de représenter tous les nombres.
- Le type boolean
Les valeurs sont dites logiques.
Ce sont les deux constantes : true (vrai) et false (faux)
Les opérateurs booléens (ou logiques) tels que and ou or sont associés à ce type.
- Le type char
Les valeurs sont les caractères, en particulier :
▪ alphanumériques : 'a' . . 'z' 'A' . . 'Z' '0' . . '9'
▪ le caractère blanc : ' '
▪ les caractères accentués
▪ les caractères de ponctuation
Dans un programme, les valeurs de type char doivent être entre apostrophes (quotes). Ex : 'd'
- Le type string
Les valeurs sont des chaînes de caractères.
Elles sont également représentées entres apostrophes. Lorsqu’il y a une apostrophe dans la chaîne de caractères, elle doit être doublée :
Ex : 'il fait beau aujourd''hui'
Il ne faut pas confondre avec les commentaires, situés entre deux accolades, qui n'interviennent pas directement dans le programme.
Ces commentaires servent au programmeur, lorsqu’il doit reprendre le programme plus tard, pour le modifier.
- Les types scalaires et non standards
Un type est dit scalaire s’il est :
- soit un type scalaire standard (integer ou real),
- soit un type énuméré,
- soit un type intervalle.
Organisation des types scalaires :
- Le type énuméré
Un type énuméré est une séquence ordonnée d'identificateurs.
Syntaxe :
type
identificateur = (id1, id2,..., idn) ;
Exemples :
type
couleur = (jaune, vert, rouge, bleu, marron ); semaine=(lundi,mardi,mercredi,jeudi,vendredi,
samedi,dimanche); reponse = (oui, non, inconnu); sexe = (masculin, féminin); voyelle = (A, E, I, O, U);
N.B. : Le mot réservé type ne doit être écrit qu'une seule fois.
Remarques :
- Deux types énumérés différents ne peuvent contenir le même identificateur. Les ensembles énumérés sont donc disjoints.
- La séquence de valeurs étant ordonnée, le système connaît les successeurs et prédecesseurs d'un élément.
mardi : prédécesseur de mercredi. mercredi : successeur jeudi.
- Le type intervalle
Un type intervalle est nécessairement un sous-type d'un type scalaire (standard ou énuméré) déjà défini.
Syntaxe :
type
identificateur = [borne inf] .. [borne sup] ;
Toutes les valeurs de l'intervalle sont autorisées.
Exemples :
Intervalle d'entiers :
type
Decimal = 0 .. 9 ;
Octal = 0 .. 7 ;
Age = 0 .. 150 ;
Intervalle de caractères :
type
ABC = 'A' .. 'C' ;
Maj = 'A' .. 'Z' ;
Exemples avec un type non-standard
type
Ouvrable = lundi .. vendredi ; WeekEnd = samedi .. dimanche ; Lettres = 'A' .. 'Z' ;
Remarques :
- On ne peut pas définir un type intervalle à l’aide du type real (type non scalaire).
- L’ordre ascendant est requis : borne-inf doit être placé avant borne-sup dans le type énuméré source.
Exemples de déclarations incorrectes :
type
Octal= 7 .. 0 ;
Ouvrable = vendredi .. lundi ;
3.3.3 Variables
Déclarer une variable, c'est définir l'ensemble des valeurs qu'elle peut prendre. Toutes les variables utilisées dans un programme doivent être déclarées.
On peut déclarer une variable :
- à l'aide d'un type standard ou d'un type déclaré au préalable.
- par une déclaration explicite (et spécifique à cette variable) de l'ensemble des valeurs qu'elle peut prendre.
Syntaxe :
var
identificateur : type ;
Diagramme syntaxique :
Remarques :
- var ne peut apparaître qu'une seule fois
- il est possible de grouper plusieurs variables pour le même type (en les séparant par des virgules).
Exemples
var
jour: semaine ; a, b, c : real;
i, j, k : integer ; conge : week-end ; vivant : boolean ;
avec déclaration locale explicite :
var
lettre : 'A' . . 'Z' ;
feux : (vert, orange, rouge) ;
3.3.4 Exemples de déclarations de constantes, types et variables.
const
JOUR_MAX = 31 ; AN_MIN = 1901 ; AN_MAX = 2000 ;
type
Siecle = AN_MIN . . AN_MAX ;
Semaine = (lundi, mardi, mercredi, jeudi, vendredi, samedi, dimanche) ; Annee = (janvier, février, mars, avril, mai, juin, juillet,
aout, septembre, octobre, novembre, decembre);
var
mois: annee ; jour: semaine ;
nbJours : 1 .. JOUR_MAX ; an: siecle ;
ouvrable : lundi .. vendredi ; i, j : integer ;
numEtudiant : 1 .. maxint ;
3.4 Entrées / Sorties
Ce sont des échanges d'informations entre la mémoire (variables et constantes) et les périphériques (clavier, écran ...).
Les types autorisés sont : entier, réel, booléen, caractères et chaînes de caractères.
3.4.1 Lecture
read (v1, v2, v3, ..., vn);
Cette instruction permet de lire les valeurs entrées par l’utilisateur au clavier et de les stocker dans les variables v1,..., vn
read (v1, v2, v3, ..., vn); <=> read(v1); read(v2);... read(vn);
L’instruction :
readln (v1, v2, v3, ..., vn);
permet, de manière analogue, de lire n valeurs et passe ensuite à la ligne suivante en ignorant ce qui reste éventuellement sur la ligne.
readln; peut être employé sans paramètre
Exemple :
program Test; var
i, j : integer ; {déclaration des variables}
begin
read(i,j); {lecture de deux entiers} end.
3.4.2 Ecriture
write (v1, v2, ..., vn);
writeln(v1, v2, ..., vn); ---> écrit les valeurs des variables passées en paramètre puis va à la ligne
writeln; peut être employé sans paramètre
Exemple : program Test; var
i : integer; r : real;
begin
write('Entrez un entier et un réel :');
read(i,r); {lecture des valeurs}
writeln('L''entier vaut : ', i : 5); {affichage de i} writeln('et le réel est : ', r : 6:2); {affichage de r}
end.
Le programme lit les valeurs de i et r tapées par l'utilisateur et les affiche ensuite à l'écran, sur 5 caractères pour i, et sur 6 caractères pour r, dont 2 chiffres après la virgule.
Autre exemple :
program Exemple; var
a, b : integer; c1, c2 : char;
resultat : boolean; x, y : real;
begin
write('entrez 2 entiers : ');
readln(a,b); {lecture des 2 valeurs}
write('maintenant, entrez une lettre');
readln(c1); {lecture d'un caractère} write('entrez une autre lettre : ');
readln(c2);
write('entrez maintenant un réel : ');
readln(x); {lecture d'un réel}
writeln;
resultat := (a<=b); {resultat prend la valeur de l'expression a<=b} writeln('le 2ème entier est-il inf ou égal au 3ème ? =>', resultat);
y:=sqr(x); {calcul de x au carré} writeln('le carré du réel est : ', y:4:2);
writeln('ou encore : ',y:8:4); {affichage sur 8 caractères,
dont 4 chiffres après la virgule} writeln('le code ASCII de ',c1, ' est : ', ord(c1):4);
resultat := (c1>c2);
{resultat prend la valeur de l'expression c1>c2}
{il est vrai si c1>c2, et faux sinon} writeln('Le caractère 1 est-il avant le caractère 2 ? => ', resultat); write('Le code de ',c1,' est : ', ord(c1):4);
writeln(' et celui de ',c2, ' est : ', ord(c2):4); end.
3.5 Instruction d'affectation
L’instruction d’affectation à un double rôle :
- Evaluation de l'expression (calcul)
- Puis affectation (rangement) dans la variable (identificateur)
Remarques
- Les types doivent être compatibles (les mélanges de types sont interdits)
- Ne pas confondre ":=", l'opérateur d'affectation et "=", l'opérateur de test.
Exemple :
Soit X une variable de type integer
X := 10 signifie que l'on affecte la valeur 10 à la variable X, donc X vaut 10 après l’exécution de cette instruction.
On peut tester si X est égal à une certaine valeur avant d'effectuer un calcul : if X = 3 then X := X / 2 ;
Après exécution de cette instruction, la valeur de X est toujours 10, car le test X = 3 n'est pas vérifié (puisque la valeur 10 a été placée dans X)
3.6 Opérateurs et fonctions arithmétiques
3.6.1 Opérateurs disponibles
+ somme
- soustraction
* multiplication
/ division
DIV division entière (Ex : 5 div 3 = 1 ) MOD modulo (Ex : 5 mod 3 = 2 )
Exemples
var
A, B, C, D : real; I, J, K : integer;
begin
A := 7.4 ;
B := 8.3 ;
C := A + B ;
D := A / B + C ; I := 42 ;
J := 9 ;
K := I mod J ; { K vaut 6 }
end.
3.6.2 Expressions
Une expression est une combinaison d'opérandes (variables et constantes), d'opérateur et de fonctions.
Exemples :
"i+1", "2.08E3 * x" ou encore "(x>2) OR (x<8)"
3.6.3 Evaluation des expressions
Il suffit d'utiliser les règles de décomposition syntaxique et l'ordre des priorités mathématiques.
Exemples :
- a*b+c se décompose en :
Expression ‹ Expression simple ‹ Terme + Terme ‹ (Facteur * Facteur) + Facteur donc a*b+c est équivalent à : (a*b)+c
- a>3 and a<10 n'est pas correct
(pas de solution possible lors des décompositions) (a>3) and (a<10) est correct
3.6.4 Fonctions arithmétiques
ABS (X) valeur absolue de X ARCTAN (X) arctangente de X
CHR (X) caractère dont le numéro d'ordre est X COS (X) cosinus de X
EXP (X) exponentielle de X
LN (X) logarithme népérien de X
ORD (X) numéro d'ordre dans l'ensemble de X PRED (X) prédécesseur de X dans son ensemble ROUND (X) arrondi de X
SIN (X) sinus de X
SQR (X) carré de X
SQRT (X) racine carrée de X
SUCC (X) successeur de X dans son ensemble TRUNC (X) partie entière de X
3.6.5 Fonctions logiques
EOF (X) vrai si la fin de fichier X est atteinte EOLN (X) vrai si fin de ligne du fichier
ODD (X) vrai si X est impair, faux sinon
3.7 Programmation structurée
La programmation structurée consiste à :
- rechercher et à identifier les tâches nécessaires à la résolution d'un problème donné
- organiser l'ensemble de ces tâches
- faire apparaître cette structure dans le programme correspondant.
Pour cela, il faut respecter une certaine discipline de programmation en s'efforçant de satisfaire les exigences suivantes : la clarté, la modularité, l'efficacité.
3.7.1 La Clarté
- Faire des déclarations explicites de toutes les entités manipulées
- Utiliser des noms significatifs (prix pour le prix d'un objet et non pr5...)
- Ne pas employer de méthodes hermétiques
- Ne pas faire de "branchements"
- Utiliser des indentations, c'est-à-dire des "marges décalées"
3.7.2 La Modularité
- Décomposition du problème en plusieurs sous-problèmes
---> réduction de la complexité
---> synthèse de modules
- Réunion structurée des différents modules
3.7.3 L'Efficacité
- Conformité des résultats
---> Problème de la vérification d'un programme
- Vitesse d'exécution
- Utilisation optimale de la mémoire
3.7.4 Bénéfices attendus
- Programmation plus simple
- Lecture plus commode
- Modifications plus aisées
- Modules faciles d'accès
- Partage du travail
- Fiabilité supérieure
4 Instructions alternatives
4.1 Choix simple
Syntaxe :
Cette instruction évalue l’expression booléenne (condition). Si le résultat est true, c’est le premier bloc d’instructions (après then) qui est exécuté sinon c’est le second (après else).
Remarques :
- On peut imbriquer plusieurs "if"
- Attention à la présentation : il est souhaitable d’utiliser des indentations (marges décalées) pour augmenter la lisibilité du programme
Points importants :
- Surtout pas de point virgule immédiatement avant ELSE !
- L’instruction alternative est facultative
- La valeur de la condition doit être booléenne
- Les instructions peuvent être simples ou composées
Exemple 1 : Equation du premier degré
Ecrire un programme qui résoud une équation du premier degré Ax+b=0 qui lit les valeurs de A et B entrées par l'utilisateur.
program Premier_Degre; var
A, B : real; begin
write('entrez les coefficients A et B : '); readln(A,B);
if A=0 {évaluation de la condition} then
if B=0 then
writeln('Indéterminé !') else
writeln('Impossible !')
else
writeln('La solution est : ',-B/A:10:3);
end.
Exemple 2 : Maximum de deux nombres
Ecrire un programme qui calcule le maximum de deux nombres entrés au clavier.
program MAXIMUM_DEUX ; var
X,Y : real ; MAX : real ;
begin
writeln('Tapez les deux nombres:') read (X, Y) ;
if X > Y {évaluation de la condition} then
MAX := X
else
MAX := Y ;
writeln('Le plus grand nombre est ',MAX); end.
Exemple 3 : Exemple avec expressions relationnelles et booléennes
program GRAND_PETIT ; var
SEX : (M,F) ;
MAJEUR, PETIT, GRAND, FEMME, HOMME : boolean ; AGE : 1..120;
TAILLE : 50..250;
begin
read (SEX, AGE, TAILLE) ;
FEMME := SEX=F ; {femme est vrai si sex = F}
HOMME := not FEMME ; {homme vaut le contraire de femme} MAJEUR := AGE>18 ;
if FEMME then begin
PETIT := TAILLE<150 ;
{petit est vrai si TAILLE < 150} GRAND := TAILLE>170 ;
end else
begin
PETIT := TAILLE<160 ;
GRAND := TAILLE>180 ;
end ;
writeln (MAJEUR, FEMME, HOMME) ; writeln (AGE, PETIT, GRAND) ;
end.
4.2 Choix multiple
Cette méthode est utilisée pour tester une solution parmi N. Par exemple, lorsqu’un menu est proposé à l'utilisateur :
1) lire
2) écrire
3) calculer
4) sortir
il est nécessaire de savoir si l'utilisateur a tapé 1, 2, 3 ou 4.
Au lieu d'utiliser plusieurs if... then... else... imbriqués, il est préférable de choisir une sélection multiple (case en Pascal).
Ainsi au lieu d'écrire :
if reponse=1 then
{ instructions de lecture... }
else if reponse=2 then
{ instructions d'écriture... }
else if reponse=3 then
{ instructions de calcul... }
Il est préférable d'écrire :
case reponse of
1 : {instructions de lecture... }
2 : {instructions d'écriture...}
3 : {instructions de calcul...}
end;
Syntaxe
Seules les égalités sont possibles au niveau du test (Pas de comparaisons de type <, >, <=, >= ou <>) On peut néanmoins utiliser des intervalles
Remarque :
L’instruction case of est utile :
- pour remplacer des structures if... then... else... imbriquées
- pour tester l’égalité à des valeurs données d'une expression Elle améliore la lisibilité du programme !
Exemple 1 : Simuler une calculatric
program calculette ; var
A, B : real ; RESULTAT : real;
TOUCHE : char; begin
write('entrez une opération ');
write('(taper un nombre, un opérateur puis un nombre):'); readln(A,TOUCHE,B);
case TOUCHE of
'+' : RESULTAT:= A+B; '-' : RESULTAT:= A-B; '*' : RESULTAT:= A*B; '/' : RESULTAT:= A/B;
end;
writeln(A, TOUCHE, B,' = ', RESULTAT);
end.
Exemple 2 : Le loto
program bingo ; var
x : integer ; begin
write('entrez un entier : '); readln(x);
case x of
1..10 : writeln('bingo');
11..50 : writeln('pas de chance'); end;
if x > 50 then
writeln('valeur non autorisée');
end.
4.3 Instructions composées
Les instructions composées permettent de regrouper, dans un même bloc, un ensemble d'instructions qui seront exécutées au même niveau.
Syntaxe
Séquence de deux ou plusieurs instructions comprises entre begin et end et séparées par des points virgules
Remarque :
Il est possible d'imbriquer des instructions composées.
On utilise alors des indentations pour améliorer la lisibilité du programme.
5 Instructions itératives
Une boucle permet de parcourir une partie d'un programme un certain nombre de fois. Une itération est la répétition d'un même traitement plusieurs fois.
5.1 Boucles à bornes définies
5.1.1 Définition
Une boucle à bornes définies est une boucle pour laquelle le nombre d'itérations à effectuer, est connu grâce aux valeurs des bornes minimum et maximum.
Un indice de boucle varie alors de la valeur minimum (initiale) jusqu'à la valeur maximum (finale)
Syntaxe :
POUR variable VARIANT DE valeur initiale A valeur finale FAIRE <séquence d'instructions>
Exemples :
POUR mois VARIANT DE Janvier A Décembre FAIRE <budget> POUR Jour VARIANT DE Lundi A Vendredi FAIRE <Travail>
POUR i VARIANT DE 1 A nombre_etudiants FAIRE <corriger copies du ième étudiant>
5.1.2 Exemple d'itérations à bornes définies
On désire généraliser l'algorithme de calcul du salaire net, vu précédemment, à la paie de N personnes
- Données N, PR, PL
- Pour I variant de 1 à N,
exécuter les instructions suivantes :
2.1 Lire NH, SH
2.2 SB € SH x NH
2.3 R€ SB x PR
2.4 Si R > PL alors R € PL
2.5 SN € SB - R
2.6 Ecrire SN
- Fin de l'itération
5.1.3 La boucle à bornes définies en Pascal : for
Syntaxe :
for variable := exp.1 to exp.2 do Bloc d'instructions;
Remarques :
- la variable doit être de type scalaire (entier, énuméré, intervalle ou caractère). Elle ne peut pas être de type réel.
- si exp.1 > exp.2 le for est ignoré
Exemple :
program boucle_for; var
i:integer; begin
for i:=1 to 5 do
writeln('le carré de ', i, ' est :', i*i); writeln;
writeln('fin'); end.
Il est possible d'imbriquer plusieurs boucles FOR :
for X1 := C1 to C2 do begin
...
for X2 := D1 to D2 do begin
...
end;
...
end;
5.2 Boucles à bornes non définies
Syntaxe de la boucle TANT QUE :
5.2.1 Boucle TANT QUE
TANT QUE <condition> FAIRE <séquence d'instruction>
Exemples :
TANT QUE le nombre considéré est positif FAIRE recherche de la racine carrée
TANT QUE le feu est vert FAIRE action de passer
TANT QUE il reste une fiche de paie non traîtée FAIRE traitement de la fiche concernée
5.2.2 En Pascal : while ... do
Syntaxe :
while expression do <bloc d'instructions>;
Remarques :
- Le bloc d’instructions n’est pas exécuté si la valeur de expression est false. Il n’est donc pas exécuté du tout si la valeur de l’expression est false au départ
- L’incrémentation doit être gérée par le programmeur lui-même. Il n’y a pas contrairement à la boucle for
d'augmentation automatique d'une variable
Exemple :
program boucle_while; var
i:integer; begin
i:=1;
while i <= 5 do begin
writeln('le carré de ', i, ' est :', sqr(i)); i:=i+1; { incrémentation gérée par le programmeur }
end; writeln;
writeln('FIN.'); end.
5.2.3 Boucle REPETER ... JUSQU’A
REPETER <séquence d'instruction> JUSQU'A <condition>
Exemples :
REPETER recherche de la racine carrée JUSQU'A le nombre considéré est négatif
REPETER action de passer JUSQU'A le feu n'est pas vert
REPETER traitement d'une fiche de paie
JUSQU'A il ne reste plus de fiche de paie non traîtée
5.2.4 En Pascal : repeat ... until
repeat <bloc d'instructions> until <expression>;
Remarques :
- La boucle s'effectue tant que la valeur de expression est false. On s’arrête quand l'expression devient
true. C'est le contraire de la boucle while.
- Contrairement au while, il y a au moins un passage (1 boucle), même si l'expression est vraie au départ.
- De même que pour le while, c'est le programmeur qui gère l'incrémentation.
Exemple :
program boucle_repeat; var
i:integer; begin
repeat
writeln('le carré de ', i, ' est :', sqr(i)); i:=i+1; { incrémentation gérée par le programmeur }
until i>5; writeln; writeln('FIN.');
end.
Attention :
Il faut examiner en particulier :
- les conditions initiales,
- les conditions d'arrêt
- l'incrémentation.
Avant de lancer le programme, il est conseillé de le faire "tourner" à la main (c’est-à-dire simuler l'exécution du programme pas à pas), en faisant évoluer les variables.
Les instructions contenues dans la boucle doivent permettre l'évolution de la valeur retournée par l'expression, sinon le programme peut rester bloqué dans une boucle infinie.
5.2.5 Comparaison des deux boucles
Les deux boucles peuvent être choisies indifféremment. Cependant, l'une est le contraire de l'autre, au niveau de la condition d'arrêt :
- Tant que condition1 est vraie, faire bloc d'instructions...
- Répéter bloc d'instructions, jusqu'à ce que condition2 soit vraie Dans ce cas, condition1 est l'opposé de condition2
Exemple : les deux boucles suivantes sont équivalentes :
tant que (i <> 10) faire i € i+1 (on fait varier i jusqu'à 10) répéter i € i+1 jusqu'à (i=10)
Il est toujours équivalent d'utiliser une boucle TANT QUE ou une boucle REPETER. Cependant, il existe une différence entre les deux boucles :
Dans le cas d'une boucle REPETER... JUSQU'A, le bloc d'instructions est effectué au moins une fois, ce qui n'est pas forcément vrai pour une boucle TANT QUE.
En effet, pour ce dernier type de boucle, si la condition est fausse dès le départ, le bloc d'instructions ne sera pas du tout exécuté. En revanche, avec une boucle REPETER ... JUSQU'A, si la condition est fausse dès le départ, le bloc d'instructions sera quand même exécuté une fois.
Remarque : les boucles REPETER et TANT QUE peuvent être utilisées même si les bornes sont définies. Il est cependant préférable d'utiliser dans ce cas une boucle POUR (vue précédemment).
Exemple :
Reprenons l'exemple de la paie de N personnes
- Données N, PR, PL
- Initialiser I avec la valeur 1
- Tant que I est inférieur ou égal à N, faire:
3.1 Lire NH, SH
3.2 SB € SH x NH
3.3 R€ SB x PR
3.4 Si R > PL alors R € PL
3.5 SN € SB - R
3.6 Ecrire SN
3.7 Donner à I la valeur suivante.
- Fin de l'itération
Il en est de même avec Répéter...jusqu'à...
- Données N, PR, PL
- Initialiser I avec la valeur 1
- Répéter les instructions suivantes :
3.1 Lire NH, SH
3.2 SB € SH x NH
3.3 R€ SB x PR
3.4 Si R > PL alors R € PL
3.5 SN € SB - R
3.6 Ecrire SN
3.7 Donner à I la valeur suivante.
- Jusqu'à ce que I=N
5.2.6 Exemples
Exemple1 : Calculer la somme des N premiers entiers naturels
---> On utilise une boucle à bornes définies, puisqu'on connaît l'intervalle de variations (de 1 à N)
1) Lire N
2) Somme € 0
3) Pour i variant de 1 à N faire Somme € Somme + i
4) Ecrire les résultats : 'Résultat = ' Somme
Exemple comparatif :
Nous allons à présent traîter le même exemple, avec trois boucles différentes.
Il s'agit de reconstruire l'opération de multiplication, en effectuant des sommes successives.
Soit à effectuer le produit des entiers naturels M et K (distincts de 0) Données :
M multiplicande K multiplicateur
Résultat :
P produit Méthode :
ajouter K fois le multiplicande
Forme 1 : POUR
- Lire K, M
- P € 0
- Pour i variant de 1 à K faire P € P+M
- Afficher le résultat P
FORME 2 : avec TANT QUE
- Lire K, M
- P € 0
i € 1
- Tant que i € K faire
P € P+M
i € i+1
- Afficher le résultat P
FORME 3 : avec REPETER
- Lire K, M
- P € 0
i € 1
- Répéter
P € P+M
i € i+1 Jusqu'à i>K
- Afficher le résultat P
