1ere Annee LMD

Semestre 2
Dr A. Rahmoun
SOMMAIRE
ALGORITHMIQUE
 1) Définitions. ..................................................................................................... 2
 2) Organisation d’un programme. ...................................................................... 2
 2.1) Déclaration des constantes ......................................................................... 2
 2.2) Déclaration des variables ............................................................................ 3
 2.3) Définition du programme principal................................................................ 3
 2.4) Définition des fonctions et procédures.......................................................... 3
 3) Affectation...................................................................................................... 4
 4) Opérateurs - Conditions. ................................................................................ 4
 4.1) Opérateurs................................................................................................. 4
 4.2) Conditions .................................................................................................. 4
 5) Les Structures algorithmiques. ...................................................................... 5
 5.1) Séquencement linéaire ............................................................................... 5
 5.2) Structures de choix (ou conditionnelles) ....................................................... 5
 5.2.1) Structure SI ... ALORS .......................................................................... 5
 5.2.2) Structure SI ... ALORS ...SINON ... ........................................................ 6
 5.2.3) Structure de choix multiple..................................................................... 6
 5.3) Structures itératives (ou répétitives) ............................................................. 7
 5.3.1) Structure REPETER ... JUSQUA ........................................................... 7
 5.3.2) Structure TANT QUE ... FAIRE .............................................................. 8
 5.3.3) Structure POUR Indice ALLANT DE ... A .... FAIRE ................................ 8
 1) DEFINITIONS.
 Algorithme : Description en langage naturel de la suite des
actions effectuées par un programme.

 Algorigramme : Traduction graphique de l’algorithme. Parfois

appelé Ordinogramme ou Organigramme.
 Syntaxe : Règles d’écriture d’un langage donné.
 Type de données : Un programme peut être amené à manipuler
différents types de données :
 - booléen : valeur pouvant être soit Vraie, soit Fausse.
 - entiers : valeur numériques entières pouvant être signées ou
non signées (codées sur un ou plusieurs octets; entiers + ou - )
 - réels : valeurs numériques codées avec une mantisse et un
exposant. (3.14, 456.765 , ….)
 - caractère : octet correspondant à un code ASCII. (A, B, a, b, &..)
 - chaîne de caractères : ensemble de caractères. (mot)
 - tableau de données : ensemble de données de même type
(exemple : tableau d’entiers, tableau de réels).
 Toutes ces données sont codées sous forme d'octets en mémoire.
 Constante : donnée manipulée par un programme et
ne pouvant être modifiée.
 Exemple : Constante Pi = 3.141559
 Variable : donnée manipulée par un programme et
pouvant être modifiée.
 Ce peut être :
 - une donnée d’entrée ;
 - le résultat final d’un calcul ;
 - un résultat intermédiaire de calcul.
 Identificateur : nom explicite d’une constante, d’une
variable ou d’une fonction.
 Exemples : Conversion_BCD, Resultat, Lettre…
 Procédures et fonctions : Une procédure ou une fonction
effectue une suite d’actions élémentaires constituant un
tout.
 Une fonction se différencie d’une procédure par le fait
qu’elle fournit un résultat.
 2) ORGANISATION D’UN PROGRAMME.
 L’algorithme d’un programme est organisé en plusieurs
parties :
 · déclaration des constantes
 · déclaration des variables
 · définition du programme principal
 · définition des fonctions et procédures
 2.1) Déclaration des constantes
 Syntaxe : Constante NomConstante : [Type] = Valeur
 Exemples : Constante Pi = 3.141559
 Constante NombreLettres = 10
 2.2) Déclaration des variables
 Syntaxe : Variable NomVariable : [Type]
 Exemples : Variable Rayon : Reel
 Variable Compteur : Entier
 Variable Lettre : Caractere
 2.3) Définition du programme principal
 Le programme principal consiste en une suite d’opérations
élémentaires faisant souvent appel
 à des fonctions ou procédures. Ces différentes opérations
sont mentionnées en utilisant les
 structures algorithmiques décrites au paragraphe 5.
 Le programme principal est délimité par les mots clefs
Début et Fin
 2.4) Définition des fonctions et procédures
 Les procédures et fonctions peuvent nécessiter éventuellement
un ou plusieurs paramètres d’entrée ou de sortie.
 Un paramètre d’entrée est la référence à une variable manipulée
par la procédure ou la fonction.
 Un paramètre de sortie est une valeur renvoyée par une fonction.
 Une fonction ou une procédure peut elle-même appeler une ou
plusieurs fonctions et procédures.
 Syntaxe de la déclaration d’une procédure :
 Procédure NomProcédure (NomEntrée1 : [Type], NomEntrée2 :
[Type],…)
 Constante ~ déclaration des constantes locales ~
 Variable ~ déclaration des variables locales ~
 Début
 ~ description des actions effectuées par la procédure ~
 Fin
 Syntaxe de l’appel d’une procédure :
 NomProcédure (NomEntrée1, NomEntrée2…)
 Syntaxe de la déclaration d’une fonction :
 Fonction NomFonction (NomEntrée1 : [Type], NomEntrée2 :
[Type],…) : [TypeDuRésultat]
 Constante ~ déclaration des constantes locales ~
 Variable ~ déclaration des variables locales ~
 Début
 ~ description des actions effectuées par la fonction ~
 Fin

 Syntaxe de l’appel d’une fonction :

 Variable = NomFonction (NomEntrée1, NomEntrée2…)
 Exemples d’appels de fonctions et procédures :
 Procédure sans paramètre : Effacer_Ecran
 Procédure avec un paramètre d’entrée : Ex : Afficher (‘Bonjour’)
 Fonction avec paramètres d’entrée et de sortie :
 Ex : Resultat = Racine (69)
 Exemple de déclaration de fonction :
 Fonction Moyenne (Note1 : Reel, Note2 : Reel) : Reel
 Variable Intermediaire : Reel
 Début
 Intermediaire = (Note1 + Note2)/2
 Moyenne = Intermediaire
 Fin
 Exemples d’utilisation de la fonction :
 Afficher (Moyenne(10.5,15))
Ou NouvelleNote = Moyenne (10,5.5)
 3) AFFECTATION.
 Une affectation consiste à attribuer une valeur à une
variable.
 La syntaxe générale est la suivante : NomVariable =
Expression
 « Expression » peut être :
 · une constante..Ex : surface = 40
 · une autre variable. Ex : Donnee = ValeurMemorisee
 · le résultat d’une fonction Ex : resultat = racine (nombre)
 · un calcul portant sur ces différents éléments
 Ex : surface = (PI * Carre (Diametre)) / 4
 4.1) Opérateurs
 1. Opérateurs mathématiques
 Addition (et union) + Soustraction (et complément) - Division / Multiplication (et
intersection) * , Egalité =
 MOD: renvoie le reste de la division x MOD y
 DIV: renvoie le quotient de la division x DIV y
 Opérateurs prioritaires : *, /, DIV et MOD.
 Opérateurs secondaires : + et -. Vous pouvez utiliser des parenthèses.
 2. Opérateurs relationnels
 Inférieur strict < Inférieur ou égale (et inclu) <=
 Supérieur strict >
 Supérieur ou égale (et contenant) >=
 Différent <>
 3. Opérateurs logiques :
 AND: le "et" logique des maths
 OR: le "ou"
 XOR: le "ou" exclusif
 NOT: le "non"
 Priorité des opérateurs
 Niveau 1 : NOT.
 Niveau 2 : *, /, MOD, DIV, AND.
 Niveau 3 : +, -, OR, XOR.
 Niveau 4 : =, <, >, <=, >=, <>.
 5) LES STRUCTURES ALGORITHMIQUES.
 Les structures algorithmiques sont réparties en 3 catégories :
 - succession linéaire d'opérations;
 - structures conditionnelles ou de choix : en fonction d'une
condition, le programme exécute des opérations différentes;
 - structures itératives ou répétitives: sous contrôle d'une condition,
une séquence d'opérations est exécutée répétitivement.
 5.1) Séquencement linéaire
 Les actions successives sont mentionnées les unes après les autres.
 Syntaxe Algorigramme
 Action1
 Action2
 ...
 ActionN
 Exemple : Calcul d’un produit de 2 nombres
 Algorithme produit;
 Variable
 a,b : réel ~ opérandes ~
 p : réel ~ résultat du produit ~
 Début
 Afficher (‘Saisir le nombre a ‘)
 Saisir (a)
 Afficher (‘Saisir le nombre b ‘)
 Saisir (b)
 p=a*b
 afficher (p)
 Fin
 5.2) Structures de choix (ou conditionnelles)
 5.2.1) Structure SI ... ALORS ...
 Une condition est testée pour déterminer si l’action ou
le groupe d’actions suivant doit
 être exécuté.
 Syntaxe Algorigramme
 Si Condition
 Alors Actions
 FinSi
 Exemple : Calcul d’une racine carrée
 Algorithme racine;
 Variable
 x: réel ~ opérande ~
 r: réel ~ résultat de la racine carrée ~
 Début
 Afficher (‘Saisir le nombre x‘)
 Saisir (x)
program testif1;
 Si x > 0
var x,r: real;
 Alors begin
 r = racine (x) writeln('entrez x:'); readln(x);
 afficher (r) if x>0 then r:=sqrt(x) ;
 FinSi writeln('r=',r);
 Fin end.
 5.2.2) Structure SI ... ALORS ...SINON ...
 Une condition est testée pour déterminer quelle action ou
quel groupe d’actions doit être exécuté.
 Syntaxe
 Si Condition
 Alors Actions1
 Sinon Actions2
 program testif1;
 var x,r: real;
 begin
 writeln('entrez x:'); readln(x);
 if x>0 then
 begin r:=sqrt(x) ;
 writeln('r=',r); end
 else writeln('pas de solution');
 end.
 Exemple : Calcul d’une racine carrée
 Algorithme racine2
 Variables :
 x: réel ~ opérande ~
 r: réel ~ résultat de la racine carrée ~
 Début
 Afficher (‘Saisir le nombre x‘)
 Saisir (x)
 Si x < 0
 Alors afficher (‘x est négatif’)
 Sinon
 r = racine (x)
 afficher (r)
 FinSi
 Fin
 5.2.3) Structure de choix multiple
 Une donnée est comparée successivement à des valeurs
constantes :
 Syntaxe
 Cas Ou Donnée Vaut
 Valeur1 : Actions1
 Valeur2 : Actions2
 ...
 ValeurN : ActionsN
 Autre : ActionsDéfaut
 FinCas

 Remarques : la partie « ActionsDéfaut » peut ne pas exister.

 Plusieurs valeurs différentes peuvent être regroupées sur
une même ligne si les actions correspondantes sont
identiques.
 Exemple : Affichage de la nature d’un caractère
 Algoritme affichechar; Program caseofEX2;
 Variable Var car: char;
 c: caractère Begin
 Début writeln('entrez un character');
readln(car);
 Afficher (‘Taper un caractère‘) Case car of
 Saisir (c) 'a'..'z' : writeln ('minuscule');
 Cas Ou c Vaut 'A'..'Z' : writeln('Majuscule');
 ‘A’..’Z’ : afficher (‘Lettre majuscule’) '0'..'9' : writeln('Nombre');
 ‘a’..’z’ : afficher (‘Lettre minuscule’) end;
end.
 ‘0’..’9’ : afficher (‘Chiffre’)
 autre : afficher (‘Ni Lettre Ni Chiffre’)
 FinCas
 Fin
3 .1 Ecrire un algorithme qui résolut une 3 .2 Ecrire un algorithme qui donne le carré
équation à un degré d’un réel
Program carré d’un réel ;
Program équation à un degré ; Var x, carre : real ;
Var a,b : integer ; x: real ; Begin
Begin Write (‘ Introduisez x :’) ;
Write (‘ Introduisez a :’) ; Read (a) ; Read (x) ;
Write (‘ Introduisez b :’) ; Read (b) ; carre:= x*x ;
x := -b/a ; Write(‘ le carré de x est : ’, carre) ;
WriteLn(‘ la solution est : ’, x) ; End.
End.

3.3. Ecrire les algorithmes qui calculent et

affichent le volume d’un cylindre de rayon et 3.4. Ecrire les algorithmes qui calculent et
de hauteur donnés. affichent la surface d'un rectangle de longueur et
Program volume d’un cylindre ; de largeurs données.
Const : PI:=3.14 ; Program surface d'un rectangle ;
Var Vol, rayon, hauteur : real ; Var surface, longueur, largeur : real ;
Begin Begin
Write(‘ Introduisez le rayon : ‘) ; Write(‘ Introduisez la Longueur : ‘) ;
Read(rayon) ; Read (longueur) ;
Write (‘ Introduisez la hauteur : ‘) ; Write (‘ Introduisez la Largeur:’) ;
Read (hauteur) ; Read (largeur) ;
Vol:= PI*rayon*rayon*hauteur ; Surface:= longueur * largeur ;
Write(‘ Le volume du cylindre est : ’, Vol) ; Write(‘ La surface du rectangle est : ’, Surface) ;
End. End.
 4.3. Fonctions mathématiques de base en Pascal
Syntaxe Fonction
 Sin(a) sinus
 Cos(a) cosinus
 ArcTan(a) arctangeante
 Abs(a) valeur absolue
 Sqr(a) carré
 Sqrt(a) racine carré
 Exp(a) exponentielle
 Ln(a) logarithme népérien
 L'argument des fonctions trigonométriques doit être exprimé en radian (Real),
 4.4. Opérations sur les variables

 Syntaxe Utilisation Type des variables Description

 Inc(a); Procédure intervalle ou énuméré Le
nombre a est incrémenté de 1
 Inc(a,n); Procédure intervalle ou énuméré Le nombre
a est incrémenté de n
 Dec(a); Procédure intervalle ou énuméré Le nombre
a est décrémenté de 1
 Dec(a,n); Procédure intervalle ou énuméré Le nombre
a est décrémenté de n
 Trunc(a) Fonction tout scalaire Prise de la partie entière
du nombre a sans arrondis
 Int(a) Fonction a:Real Int(a):Longint
Prise de la partie entière du nombre a sans arrondis
 Frac(a) Fonction Real Prise de la partie
fractionnaire du nombre a
5. Les types de variables
 Désignation Description Bornes Place en mémoire

 REAL nombres réels 2.9E-039 et 1.7E+038 6 octets

 SINGLE(*) réel 1.5E-045 et 3.4E+038 4 octets
 DOUBLE(*) réel 5.0E-324 et 1.7E+308 8 octets
 EXTENDED(*) réel 1.9E-4951 et 1.1E+4932 10 octets
 COMP(*) réel -2E+063 +1 et 2E+063 +1 8 octets
 INTEGER nombres entier -32768 et 32767 2 octets
 LONGINT entier -2147483648 et 2147483647 4 octets
 SHORTINT entier -128 et 127 1 octet
 WORD entier 0 et 65535 2 octets
 BYTE entier 0 et 255 1 octet
 LONG entier (-2)^31 et (2^31)-1 4 octets
 BOOLEAN variable booléenne TRUE ou FALSE 1 octet
 ARRAY [1..10] OF xxx tableau de 10 colones fait d'éléments de l'ensemble défini xxx (CHAR,
INTEGER...)
 ARRAY [1..10, 1..50, 1..13] OF xxx tableau en 3 dimensions fait d'éléments de l'ensemble
défini xxx (CHAR, INTEGER...)
 STRING chaîne de caractères 256 octets
 STRING [y] chaîne de caractère ne devant pas excéder y caractères y+1 octets
 TEXT fichier texte
 FILE fichier
 FILE OF xxx fichier contenant des données de type xxx (REAL, BYTE...)
 CHAR nombre correspondant à un caractère ASCII codé 0 et 255 1 octet

 POINTEUR adresse mémoire 4 octet

 DATETIME format de date
 PATHSTR chaîne de caractère (nom complet de fichier)
 DIRSTR chaîne de caractère (chemin de fichier)
 NAMESTR chaîne de caractère (nom de fichier)
5.1. Type simple
 On déclare les nouveaux types simples de variable dans la partie déclarative du
programme et avant la déclaration des variables utilisant ce nouveau type.
 Syntaxe :
 Type nom_du_type = nouveau_type ;
 Exemples :
 Type nom = string[20] ;
 Type entier = integer ;
 Type tableau = array [1..100] of byte ;

 Program exemple5.1 ;
 Type chaine = string[20] ;
 Var nom : chaine ;
 age : byte ;
 BEGIN
 Write('Entrez votre nom : ') ;
 ReadLn(nom) ;
 Write('Entrez votre âge : ') ;
 ReadLn(age) ;
 WriteLn('Votre nom est : ',nom,'et votre âge : ',age) ;
 END.
 Ce programme utilise un nouveau type appelé chaîne qui sert à déclarer la
variable nom.
 Program exemple3.1a ;
 Const Max=100 ;Type intervalle=1..Max ;Var x : intervalle ;
 BEGIN
 x:=1 ;
 {...} If Not(Succ(x)=Max) Then Inc(x) ;{...}
 END.
 Cet utilise quelques fonctions spécifiques aux types intervalles.
L'exemple suivant montre qu'on aurait pu se passer de déclarer
un nouveau type en le spécifiant directement dans la syntaxe Var.
 Program exemple3.1b ;
 Const Max=100 ;Var x : 1..Max ;
 BEGIN
 x:=1 ;
 {...}
 If Not(Succ(x)=Max) Then Inc(x) ;{...}
 END.
5.4. Type énuméré
 Un type énuméré est un type dont les variables associées n'auront qu'un
nombre très limité de valeur (au maximum 256 différentes possibles). Un type
énuméré sert de définition à un ensemble mathématique par l'intermédiaire de
la syntaxe Set Of dont ce n'est pas le sujet ici, voir chapitre Ensemble. La
définition d'un type énuméré consiste à déclarer une liste de valeurs possibles
(256 au maximum) associées à un type, c'est-à-dire qu'une variable de type
énuméré aura l'une et une seule de ces valeurs et pas une autre.
 Program exemple5.4a ;
 Type jours=(dim, lun, mar, mer, jeu, ven, sam) ;
 Var today : jours ;
 BEGIN today := mar ;
 today:=Succ(today) ;
 Inc(today,2) ;
Case today Of
dim : WriteLn('Dimanche') ;
lun : WriteLn('Lundi') ;
mar : WriteLn('Mardi') ;
mer : WriteLn('Mercredi') ;
jeu : WriteLn('Jeudi') ;
ven : WriteLn('Vendredi') ;
sam : WriteLn('Samedi') ;
Else WriteLn('autre, ', Ord(today)) ;
 End;
 END.
 Remarque : La fonction Chr() réciproque de Ord()
dans le cas de la table ASCII ne s'applique pas aux
types intervalles et énumérés.
 La partie déclarative de cet exemple :
 Type jours=(dim, lun, mar, mer, jeu, ven, sam) ;
 Var today : jours ;
 aurait très bien pu être racourcie en :
 Var today : (dim, lun, mar, mer, jeu, ven, sam) ;

 Note : Il est impossible d'utiliser les procédures

Write(Ln) et Read(Ln) avec les variables de type
énuméré.
 Program exemple5.4b ;
 Var color:(red, yellow, green, black, blue) ;
 BEGIN
 For color:=red To blue Do
 WriteLn('*') ;
 END.
 Cet exemple montre que l'instruction de boucle For marche aussi bien
pour les types intervalles qu'énumérés.
 Program exemple5.4c;
 Var color:(red, yellow, green, black, blue) ;
 BEGIN
 color:=green ;
 Case color Of
red : WriteLn('Rouge') ;
yellow : WriteLn('Jaune') ;
green : WriteLn('Vert') ;
black : WriteLn('Noir') ;
blue : WriteLn('Bleu') ;
 End ;
 END.
 Cet exemple montre que l'instruction de contrôle conditionnel Case
Of fonctionne aussi avec le type énuméré
 Program exemple5.4d;
 Var color:(red, yellow, green, black, blue) ;
 BEGIN
 color:=red ;
 Repeat Inc(color) ;
 Until color>green ;
 If color=black Then WriteLn('Noir') ;
 END.
5.3. Type intervalle
 Les types intervalles très utilisés ici ont
rigoureusement les mêmes propriétés que ceux dont
ils sont tirés. Ils peuvent être de type nombre entier
(Byte, Integer, ShortInt, LongInt, Long, Word) ou
caractères (Char). Un type intervalle est forcément de
type entier ou est compatible avec un type entier.
Certaines fonctions sont réservées aux types intervalle,
comme par exemple renvoyer le successeur dans
l'intervalle considéré. Sachant qu'un intervalle est
forcément ordonné et continu.
 Syntaxe :
 Type mon_type = borneinf..bornesup ;
 On doit obligatoirement avoir :
 borneinf et bornesup de type entier ou caractère
 borneinf <= bornesup
 Exemples :
 Type bit = 0..1 ;
 Type alpha = 'A'..'Z' ;
 Type cent = 1..100 ;
 Toutes ces instructions : Inc() (incrémentation de la
variable passée en paramètre), Dec() (décrémentation
de la variable passée en paramètre), Succ() (renvoie le
successeur de la variable passée en paramètre), Pred()
(renvoie le prédécesseur de la variable passée en
paramètre), Ord() (renvoie l'index de la variable dans
l'intervalle auquel elle appartient) s'appliquent aux
seuls types intervalles qu'ils soient de type nombre
entier ou caractère et énumérés. Par exemple, la boucle
Foret la condition Case Ofn'acceptent que des
variables de type intervalles (dont ont peut tiré un
successeur pour l'itération...).
 5.2. Type structuré (encore appelé enregistrement)
 Syntaxe :
 Type nom_du_type = Record sous_type1 : nouveau_type1
;sous_type2 : nouveau_type2 ;sous_type3 : nouveau_type3 ;End ;
 Note : les champs sont placés dans un bloc Record ... End ;
 et un sous-type peut lui-même être de type Record.
 Syntaxe :
 Type nom_du_type = Record
 sous_type1 : nouveau_type1 ;sous_type2 = Record ;
 sous_type2_1 : nouveau_type2 ;sous_type2_2 : nouveau_type3 ;
 sous_type2_3 : nouveau_type4 ;End ;
 Note :
 - une constante ne peut pas être de type complexe (Array,
Record...) mais seulement de type simple.
 - les champs d'une variable de type structuré peuvent être de tout
type (même tableau) sauf de type fichier (Text, File, File OF x).
 Program exemple5.2a;
 Type formulaire = Record
 nom : string[20] ;age : byte ;sexe : char ;
 nb_enfants : 0..15 ; End ;
 Var personne : formulaire ;
 BEGIN
 With personne Do
 Begin
 nom := ‘Ahmed' ;age := 18 ;
 sexe := 'M' ; nb_enfants := 3 ;
 End ;
 END.
 Program exemple5.2b;
 Type formulaire = Record
 nom : string[20] ; age :byte ; sexe : char; nb_enfants :
0..15 ; End ;
 Var personne : formulaire ;
 BEGIN
 personne.nom := 'Ahmed' ;personne.age := 18 ;
 personne.sexe := 'M' ;personne.nb_enfants := 3 ;
 END.
 Ces programmes exemple5.2 (a et b) sont absolument
identiques. Ils utilisent tout deux une variable personne
de type formulaire qui comprend trois champs : nom,
age et sexe. L'utilisation de ces champs se fait ainsi :
variable[point]champ (exemple5.2b).
.
 Program exemple5.2c;
 Type date = Record
 jour : 1..31 ;mois : 1..12 ;an : 1900..2000 ;End ;
 Type formulaire = Record
 nom : string[20] ;date_naissance : date ;End ;
 Var personne : formulaire ;
 BEGIN With personne Do
 Begin
 nom := 'Ahmed' ;
 With date_naissance Do
 Begin
 jour := 21 ;mois := 10 ;an := 1980 ;
 End ; End ; END.
 Program exemple5.2d;
Type formulaire = Record
nom : string[20] ;
date_naissance : Record
 jour : 1..31 ;mois : 1..12 ;an : 1900..2000 ;End ;
 End ;
 Var personne : formulaire ;
 BEGIN
 With personne Do
 Begin
 nom := 'Ahmed' ;
 With date_naissance Do
 Begin
 jour := 21 ;mois := 10 ;an := 1980 ;
 End ; End ; END.
6. Les structures alternatives
 6.1. If ... Then ... Else
 Cette commande est similaire au basic, elle se traduit par :
SI … ALORS … SINON …
 Program exemple6.1a ;
 Var chiffre:integer ;
 BEGIN
 Write('Entrez un entier pas trop grand : ') ;
 Readln(chiffre) ;
 If chiffre < 100 then
 writeln(chiffre, 'est inférieur à cent.')
 else writeln(chiffre, 'est supérieur ou égale à cent.') ;
 END.
 Ce programme exemple6.1a compare un chiffre entré par
l'utilisateur au scalaire 100. Si le chiffre est inférieur à 100,
alors il affiche cette information à l'écran, sinon il affiche
que le chiffre entré est supérieur ou égale à 100.
 Program exemple6.1b ;
 Var chiffre:integer ;
 BEGIN
 Write('Entrez un entier pas trop grand : ') ;
 Readln(chiffre) ;
 If chiffre < 100 then
Begin
writeln(chiffre, 'est inférieur à cent.');
end
else
begin
writeln(chiffre,'est supérieur ou égale à cent.');
end ;
 END.
 Ce programme exemple6.1b fait strictement la même chose
que le précédent mais sa structure permet d'insérer
plusieurs autres commandes dans les sous-blocs THEN et
ELSE.
 Program exemple6.1c ;
 Var i : integer ;
 BEGIN Randomize ;
 i := random(100) ;
 If i < 50 then writeln ( i, ' est inférieur à 50.')
 else
 if i < 73 then writeln ( i, ' est inférieur à 73.')
 else writeln ( i, ' est supérieur ou égale à 73.')
 END.
 6.2. Case ... Of ... End
 Cette instruction compare la valeur d'une variable de type
entier ou caractère (et de manière générale de type
intervalle) à tout un tas d'autres valeurs constantes.
 Note : attention car Case..Of ne permet de comparer
une variable qu'avec des constantes.
 Program exemple6.2 ;
 Var age:integer ;
 BEGIN
 Write('Entrez votre âge : ') ;
 Readln(age) ;
 Case age of
18 : writeln('La majorité!') ;
0..17 : writeln(‘petits enfants…') ;
60..99 : writeln(‘vieux’)
Else writeln('Vous êtes d''un autre âge...') ;
 End ; END.
 7. Les structures répétitives
 7.1. For ... : = ... To ... Do ...
 Syntaxe :
 For variable := borne inférieur To borne supérieur Do
instruction ;
 Autre Syntaxe :
 For variable := borne inférieur To borne supérieur Do
 Begin
 ...
 commandes ...
 End ;
 Program exemple7.1;
 Var i : integer ;
 BEGIN
 For i := 10 To 100 Do
 writeln ('Valeur de i : ', i ) ;
 END.
 7.2. For ... : = ... DownTo ... Do ...
 Cette instruction permet de décrémenter une variable à
partir d'une valeur supérieur jusqu'à une valeur inférieur et
d'exécuter une ou des instructions entre chaque
décrémentation. S'appliquent ici les mêmes remarques que
précédemment.
 Syntaxe :
 For variable := borne supérieur DownTo borne inférieur Do
instruction;
 Autre Syntaxe : (si plus d’une instruction)
 For variable := borne supérieur DownTo borne inférieur Do
 Begin
 commandes
 ...
 End ;
 Program exemple7.2;
 Var i : integer ;
 BEGIN
 For i := 100 DownTo 0 Do
 Begin
 WriteLn ('Valeur de i : ', i ) ;
 End ;
 END.
 7.3. Repeat ... Until ...
 Cette boucle effectue les instructions placées entre
deux bornes (repeat et until) et évalue à chaque
répétition une condition de type booléen avant de
continuer la boucle. Il y a donc au moins une fois
exécution des instructions
 Syntaxe :
 Repeat
 ...commandes...
 Until variable condition valeur ;
 Program exemple7.3 ;
 Var i : integer ;
 BEGIN Repeat Inc ( i , 1 ) ;
 Writeln ('Boucle itérée ', i, 'fois.') ;
 Until i > 20 ;
 END.
 program repreat1;
 var i: integer;
 begin
 i:=1 ;
 repeat
 writeln(i);
 i:=i+1;
 until i>10;
 readln;
 end.
 Note : la commande Inc permet d'incrémenter
une variable d'une certaine valeur. La commande
Dec permet au contraire de décrémenter une
variable d'une certaine valeur.
 Ces commandes permettent d'éviter la syntaxe :
 variable := variable +1 et variable := variable - 1.
 Syntaxe :
 Inc ( variable , nombre ) ;
 Dec ( variable , nombre ) ;
 7.4. While ... Do ...
 Ce type de boucle, contrairement à la précédente,
évalue une condition avant d'exécuter des instructions
(et nom pas l'inverse), c'est-à-dire qu'on peut ne pas
entrer dans la structure de répétition si les conditions
ne sont pas favorables. De plus, au moins une variable
de l'expression d'évaluation doit être sujette à
modification au sein de la structure de répétition pour
qu'on puisse en sortir.
 Syntaxe :
 While variable condition valeur Do instruction ;
 Autre Syntaxe :
 While variable condition valeur Do
 Begin
 Commandes ...
 End ;
 Program exemple7.4;
 Var code : boolean ;
 essai : string ;
 Const levraicode = 'password' ;
 BEGIN
 code:=false ; { facultatif, la valeur false est donnée par
défaut }
 While code = false Do
 Begin
 Write ('Entrez le code secret : ') ;
 Readln (essai) ;
 If essai = levraicode then code:=true ;
 End ;
 END.
 Program wh1;
 var i: integer;
 Begin
 i:=0;
 while i<=5 do begin
 writeln('i=',i);
 i:=i+1;
 end;
 readln;
 end.
 7.5. Arrêts de boucle.
 Il est possible de terminer une boucle For, While ou Repeat en
cours grâce à la commande Break . Pour reprendre une boucle
stoppée par Break, il faut utiliser la commande Continue.
 program forexit;
 var i: integer;
 var x,S: real;
 begin
 S:=0;
 for i:=1 to 10 do
 begin writeln('entrez un prix:'); readln(x);
 S:=S+x;
 if S>1000 then break
 else continue;
 end;
 writeln('somme finale =',S);
 End.
 program forexit2;
 var i: integer;
 var x,S: real;
 begin
 S:=0;
 for i:=1 to 10 do
 begin writeln('entrez un prix:'); readln(x);
 S:=S+x;
 if S>1000 then begin
 writeln('somme finale =',S); readln; exit;
end
 else continue;
 end;
 end.
 Program exemple7.5b;
 Var i, x : Integer ;
 BEGIN
 x := 0 ;
 For i := 1 to 10 Do
Begin Break ; x := 50 ; Continue ; End ;
WriteLn(x) ; END.
 Ce programme exemple7.5b fait la même chose que le
programme précédent mais dans une boucle For.
 Program exemple7.5c ;
 Var i, x : Integer ;
 BEGIN
 x := 0 ;
 While i<10 Do Begin Break ; x := 50 ; Continue ; End ;
WriteLn(x) ;
 END.

 Ce programme exemple7.5c fait la même chose que les
programmes précédents mais dans une boucle While. Et
pour quitter un bloc sous-programme (structure Begin ...
End ;) ou même le programme principal (structure Begin ...
End.), utilisez la commande Exit.
 Program exemple7.5d ;
 Var X: Integer ;
 BEGIN While X <> 13 Do
 Begin
 Write ('Entrez un nombre : ') ;
 Readln (X) ;
 Writeln (X) ;
 If X = 0 Then Exit ;
 End ;
 Writeln ('Boucle terminée.') ;
 END.
 13. Les tableaux
 Il est courant d'utiliser des tableaux afin d'y stocker
temporairement des données. Ainsi, une donnée peut être
en relation avec 1, 2 ou 3 (ou plus) entrées. L'intérêt du
tableau est de pouvoir stocker en mémoire des données que
l'on pourra retrouver grâce à d'autres valeurs à l'aide de
boucles, de formules, d'algorithmes. On peut utiliser un
tableau afin de représenter l'état d'un échiquier, le résultat
d'une fonction mathématique... Il est possible d'introduire
des variables de presque tous les types au sein d'un tableau :
Char, Integer, Real, String, Byte, Record, etc.
 Un tableau, tout comme une variable quelconque doit être
déclaré dans la partie déclarative du programme. On doit
toujours spécifier le type des variables qui seront
introduites dans le tableau.
 Syntaxe :
 Var nom_du_tableau : Array[MinDim..MaxDim] Of
type ;
 Note : les valeurs MinDim et MaxDim doivent être
des Integer ou des Char (c'est-à-dire
 de type énuméré). Avec MinDim inférieur à MaxDim.
L'un ou les deux peuvent êtres négatifs. Le type des
variables qui seront mises dans le tableau devra être
celui là : type.
 Remarque : il ne peut y avoir qu'un seul type de
variable au sein d'un tableau.
 Exemples :
 Var tab1 : Array[0..10] Of Byte ;
 Var tab2 : Array[1..100] Of Integer ;
 Var tab3 : Array[-10..10] Of Real ;
 Var tab4 : Array[50..60] Of String ;
 Var tab5 : Array['A'..'S'] Of Char ;
 Var tab6 : Array['a'..'z'] Of Extended ;
 Remarque : que les bornes d'un tableau soient
déclarées par des valeurs de type caractère (Char)
n'interdit pas pour autant de remplir le tableau de
nombres à virgules (voir le tab6 ci-dessus). Car en
effet, le type des bornes d'un tableau n'influe
aucunement sur le type des variables contenues
dans le tableau. Et réciproquement, le type des
variables d'un tableau de renseigne en rien sur le
type des bornes ayant servi à sa déclaration.
 Un tableau peut avoir plusieurs dimensions. Si
toutefois, vous imposez trop de dimensions ou des
index trop importants, une erreur lors de la
compilation vous dira : Error 22: Structure too large.
 Syntaxes :
 Var nom_du_tableau : Array[MinDim1..MaxDim1,
MinDim2..MaxDim2] Of type ;
 Var nom_du_tableau : Array[MinDim1..MaxDim1,
MinDim2..MaxDim2, MinDim3..MaxDim3] Of type ;
 Exemples :
 Var tab1 : Array[0..10, 0..10] Of Byte ;
 Var tab2 : Array[0..10, 0..100] Of Integer ;
 Var tab3 : Array[-10..10, -10..10] Of Real ;
 Var tab4 : Array[5..7, 20..22] Of String ;
 Var tab5 : Array[1..10, 1..10, 1..10, 0..2] Of Char ;
 La technique pour introduire des valeurs dans un tableau
est relativement simple. Il suffit de procéder comme pour
une variable normale, sauf qu'il ne faut pas oublier de
spécifier la position indexqui indique la place de la valeur
dans la dimension du tableau.
 Syntaxes :
 nom_du_tableau[index] := valeur;nom_du_tableau[index1,
index2] := valeur ;
 Note : la variable index doit nécessairement être du
même type énuméré que celui utilisé pour la
déclaration du tableau.
 On peut introduire dans un tableau les valeurs d'un autre
tableau. Mais pour cela, il faut que les deux tableaux en
question soient du même type (ou de types compatibles),
qu'ils aient le même nombre de dimension(s) et le même
nombre d'éléments.
 Syntaxe :
 nom_du_premier_tableau:= nom_du_deuxième_tableau ;
 Program exemple12a ;
 Var tab : Array[1..10] Of Integer ;
 i :Integer;
 BEGIN
 For i:=1 To 10 Do
 Begin
 tab[i]:=i ;WriteLn(sqrt(tab[i])*5+3) ;
 End;
 END.
Ce programme utilise un tableau à une seule dimension
dont les valeurs seront des variables de type integer.
Les "cases" du tableau vont de 1 à 10. Ici, le programme
donne à chaque case la valeur de l'index à l'aide d'une
boucle. Et ensuite, il affiche les valeurs contenues dans
le tableau.
 Syntaxe :
 Type nom_du_nouveau_type_tableau =
Array[DimMin..DimMax] Of Type;
 Var nom_du_tableau : nom_du_nouveau_type_tableau ;
 Procedure nom_de_la_procedure(Var nom_du_tableau :
nom_du_nouveau_type_tableau) ;
 Program Arr1;
 Var tab: array [1..10 ] of integer;
 i: integer;
 begin
 for i:=1 to 10 do
 begin
 tab [i]:=i;
 writeln(i,' ',sqrt(tab [i]));
 end;
 end.
Tableau de dimension 2
 Program Arr2;
 Var tab: array [1..3,1..3] of integer;
 i,j: integer;
 begin
 for i:=1 to 3 do
 for j:=1 to 3 do
 begin tab[i,j]:=i+j;
 writeln('tab[i,j]=',tab[i,j]); end;
 readln;
 end.
 8.1. Procédure simple
 Une procédure peut voir ses variables définies par le
programme principal, c'est-à-dire que ces variables sont
valables pour tout le programme et accessible partout dans
le programme principal mais aussi dans les procédures et
fonctions qui auront été déclarées après. La déclaration des
variables se fait alors avant la déclaration de la procédure
pour qu'elle puisse les utiliser. Car une procédure déclarée
avant les variables ne peut pas connaître leur existence et
ne peut donc pas les utiliser.
 Syntaxe :
 Program nom de programme ;
 Var variable : type ;
 Procedure nom de procédure ;
 Begin commandes ...
 End ;
 BEGIN
 nom de procédure ;
 End.
 Program exemple8.1a ;
 Uses crt ;
 program proc11;
 var a,c: real;
 procedure maths;
 Begin c:=sqr(cos(a)); end;
 begin
 writeln('entrez un nombre;'); readln(a);
 maths;
 writeln(c); readln;
 end.
 Program ProcArr2;
 Type tableau=Array [1..10] of integer;
 procedure saisir(var tab: tableau);
 var i: integer;
 begin
 for i:= 1 to 10 do begin
 writeln('entrez element de la case: ', i); readln(tab [i]); end;
 end;
 Procedure affiche(var tab: tableau);
 var i: integer;
 begin
 for i:=1 to 10 do writeln('tab [',i,']=',tab [i]); writeln; end;

 var tab1: tableau; i: integer;

 begin
 saisir(tab1);
 affiche(tab1);
 readln;
 end.
 Program exemple12b ;
 Type tableau = Array[1..10] Of Integer ;
 Procedure saisie(Var tab:Tableau) ;
 Var i:Integer ;Begin
 For i:=1 to 10 Do
 Begin Write('Entrez la valeur de la case n°',i,'/10 : ') ;
 ReadLn(tab[i]) ;
 End ;
 End ;
 Procedure tri(Var tab:Tableau) ;Var i,j,x:Integer ;
 Begin
 For i:=1 To 10 Do Begin For j:=i To 10 Do
 Begin if tab[i]>tab[j] Then
 Begin x:=tab[i] ;tab[i]:=tab[j] ;tab[j]:=x ;
 End; End ; End ;
 End ;
 8.2. Variables locales et sous-procédures
 Une procédure peut avoir ses propres variables locales
qui seront réinitialisées à chaque appel. Ces variables
n'existent alors que dans la procédure. Ainsi, une
procédure peut utiliser les variables globales du
programme (déclarées en tout début) mais aussi ses
propres variables locales qui lui sont réservées. Une
procédure ne peut pas appeler une variable locale
appartenant à une autre procédure. Les variables
locales doivent porter des noms différents de celles
globales si ces dernières ont été déclarée avant la
procédure. Enfin, on peut utiliser dans une procédure,
un nom pour une variable locale déjà utilisé pour une
autre variable locale dans une autre procédure.
 Une procédure, étant un sous-programme complet,
peut contenir ses propres procédures et fonctions qui
n'existent alors que lorsque la procédure principale est
en cours. Une sous-procédure ne peut appeler d'autres
procédures ou fonctions que si ces dernières font parti
du programme principal ou de la procédure qui
contient la sous-procédure.
 Syntaxe :
 Procedure nom de procédure ;
 Var variable : type ;
 Procedure nom de sous-procédure ;
 Var variable : type ;
 Begin
 ...
 End;
 Begin
 ... commandes ...
 End;
 8.3. Procédure paramétrée
 On peut aussi créer des procédures paramétrées (dont les
variables n'existent que dans la procédure). Ces procédures là
ont l'intérêt de pouvoir, contrairement aux procédures
simples, être déclarée avant les variables globales du
programme principal ; elles n'utiliseront que les variables
passées en paramètres ! Le programme principal (ou une
autre procédure qui aurait été déclarée après) affecte alors
des valeurs de variables à la procédure en passant des
variables en paramètres. Et ces valeurs s'incorporent dans les
variables propres à la procédure (dont les identificateurs
peuvent ou non êtres identiques, ça n'a aucune espèce
d'importance).

 La déclaration des variables se fait alors en même
temps que la déclaration de la procédure, ces variables
sont des paramètres formels car existant uniquement
dans la procédure. Lorsque que le programme appelle
la procédure et lui envoie des valeurs de type simple
(car celles de type complexe ne sont pas acceptées),
celles-ci sont appelées paramètres réels car les
variables sont définies dans le programme principal et
ne sont pas valables dans la procédure.
 A noter qu'on peut passer en paramètre directement
des valeurs (nombre, chaînes de caractères...) aussi
bien que des variables.
 Syntaxe :
 Program nom de programme ;
 Procedure nom de procédure( noms de variables : types ) ;
 Begin
 ... commandes ...
 End ;
 BEGIN
 nom de procédure ( noms d'autres variables ou leurs valeurs
);
 END.
 Note : on peut passer en paramètre à une procédure
des types simples et structurés. Attention néanmoins
à déclarer des types spécifiques de tableau à l'aide de
la syntaxe Type (voir Chapitre 20 sur les "Types simples
et structurés") car le passage d'un tableau en tant que
type Array à une procédure est impossible.
 Program exemple8.3a ;
 Uses Crt ;
 Procedure maths ( param : Real ) ;
 Begin
 WriteLn('Procédure de calcul. Veuillez patienter.') ;
 param := Sin(Sqrt(param+10)) ;
 WriteLn(param) ;
 End ;
 Var nombre : Real ;
 BEGIN
 ClrScr ;
 Write('Entrez un nombre :') ;
 ReadLn(nombre) ; maths (nombre) ;
 ReadLn ;
 END.
 procédure paramétrée appelée maths qui effectue les mêmes
calculs que le programme exemple8.1a. Mais ici, la variable est
déclarée après la procédure paramétrée. Donc, la procédure ne
connaît pas l'existence de la variable nombre, ainsi, pour qu'elle
puisse l'utiliser, il faut le lui passer en paramètre !
 8.4. Syntaxe var (procédures et fonctions)
 Il est quelquefois nécessaire d'appeler une procédure
paramétrée sans pour autant avoir de valeur à lui
affecter mais on souhaiterait que ce soit elle qui nous
renvoie des valeurs (exemple typique d'une procédure
de saisie de valeurs par l'utilisateur) ou alors on désire
que la procédure puisse modifier la valeur de la
variable passée en paramètre. Les syntaxes
précédentes ne conviennent pas à ce cas spécial. Lors
de la déclaration de variable au sein de la procédure
paramétrée, la syntaxe Var(placée devant
l'identificateur de la variable ) permet de déclarer des
paramètres formels dont la valeur à l'intérieur de la
procédure ira remplacer la valeur, dans le programme
principal, de la variable passée en paramètre. Et
lorsque Var n'est pas là, les paramètres formels doivent
impérativement avoir une valeur lors de l'appel de la
procédure.
 Pour expliquer autrement, si Var n'est pas là, la
variable qu'on envoie en paramètre à la procédure doit
absolument déjà avoir une valeur (valeur nulle
acceptée). De plus, sans Var, la variable (à l'intérieur de
la procédure) qui contient la valeur de la variable
passée en paramètre, même si elle change de valeur
n'aura aucun effet sur la valeur de la variable (du
programme principal) passée en paramètre. C'est à
dire que la variable de la procédure n'existe qu'à
l'intérieur de cette dernière et ne peut absolument pas
affecter en quoi que ce soit la valeur initiale qui fut
envoyée à la procédure : cette valeur initiale reste la
même avant et après l'appel de la procédure.
 Car en effet, la variable de la procédure est dynamique
: elle est créée lorsque la procédure est appelée et elle
est détruite lorsque la procédure est finie, et ce, sans
retour d'information vers le programme principal. La
procédure paramétrée sans Var évolue sans aucune
interaction avec le programme principal (même si elle
est capable d'appeler elle-même d'autres procédures et
fonctions).
 Par contre, si Var est là, la valeur de la variable globale
passée en paramètre à la procédure va pouvoir changer
(elle pourra donc ne rien contenir à l'origine). Si au
cours de la procédure la valeur est changée (lors d'un
calcul, d'une saisie de l'utilisateur...), alors la nouvelle
valeur de la variable dans la procédure, une fois la
procédure terminée, ira se placer dans la variable
globale (du programme principal) qui avait été passée
en paramètre à la procédure. Donc, si on veut passer
une variable en paramètre dont la valeur dans le
programme principal ne doit pas être modifiée (même
si elle change dans la procédure), on n'utilise pas le
Var. Et dans le cas contraire, si on veut de la valeur de
la variable globale placée en paramètre change grâce à
la procédure (saisie, calcul...), on colle un Var.
 Program Exemple8.4a ;
 Uses Crt ;
 Procedure Saisie ( var nom : String ) ;
 Begin Write('Entrez votre nom : ') ;
 ReadLn(nom) ;
 End ;
 Procedure Affichage ( info : String ) ;
 Begin WriteLn('Voici votre nom : ', info) ;
 End ;
 Var chaine : String ;
 BEGIN ClrScr ;
 Saisie(chaine) ;
 Affichage(chaine) ;
 END.
 Ce programme exemple8.4a illustre l'utilisation de la
syntaxe Var. En effet, le programme principal appelle
pour commencer une procédure paramétrée Saisie et
lui affecte la valeur de la variable chaine (c'est-à-dire
rien du tout puisque qu'avant on n'a rien mis dedans,
même pas une chaîne vide). Au sein de la procédure
paramétrée, cette variable porte un autre nom : nom, et
comme au début du programme cette variable n'a
aucune valeur, on offre à la procédure la possibilité de
modifier le contenu de la variable qu'on lui envoie,
c'est-à-dire ici d'y mettre le nom de l'utilisateur.
 Pour cela, on utilise la syntaxe Var. Lorsque cette
procédure Saisie est terminée, la variable chaine du
programme principal prend la valeur de la variable nom
de la procédure. Ensuite, on envoie à la procédure
Affichage la valeur de la variable chaine (c'est-à-dire ce
que contenait la variable nom, variable qui fut détruite
lorsque la procédure Saisie se termina). Comme cette
dernière procédure n'a pas pour objet de modifier la
valeur de cette variable, on n'utilise pas le mot clé Var,
ainsi, la valeur de la variable chaine ne pourra pas être
modifiée par la procédure. Par contre, même sans Var,
la valeur de la variable info pourrait varier au sein de la
procédure si on le voulait mais cela n'aurait aucune
influence sur la variable globale chaine. Comme cette
variable info n'est définie que dans la procédure, elle
n'existera plus quand la procédure sera terminée.
 Syntaxes :
 Procedure identifiant(Var var1, var2 : type1 ; var3 : type1) ;
 Begin
 ...
 End ;
 Procedure identifiant(Var var1 : type1 ; Var var2 : type2) ;
 Begin ...
 End ;
9. Les fonctions
 Quant aux fonctions, elles sont appelées à partir
du programme principal, d'une procédure ou d'une
autre fonction. Le programme affecte des valeurs à
leurs variables (comme pour les procédures
paramétrées, il faudra faire attention à l'ordre
d'affectation des variables). Ces fonctions, après
lancement, sont affectées elles-mêmes d'une valeur
intrinsèque issue de leur fonctionnement interne.
Il faut déclarer une fonction en lui donnant tout
d'abord un identifiant (c'est-à-dire un nom
d'appel), en déclarant les variables locales dont elle
aura besoin et enfin, il faudra préciser le type
correspondant à la valeur que prendra en elle-
même la fonction (string, real, etc
 Attention, on ne peut pas affecter un type complexe (array,
record) à une fonction : seuls les types simples sont
acceptés (voir chapitre 20 sur les types simples et
complexes). De plus, comme le montre les syntaxes
suivantes, on peut fabriquer une fonction sans paramètre
(ex: random). Il ne faut surtout pas oublier, en fin (ou
cours) de fonction, de donner une valeur à la fonction c'est-
à-dire d'affecter le contenu d'une variable ou le résultat
d'une opération (ou autre...) à l'identifiant de la fonction
(son nom) comme le montrent les syntaxes suivantes.
 Syntaxes :
 Function nom de fonction (variable : type ) : type ;
 Var déclaration de variables locales ;
 Begin ...
 Commandes
 ...
 nom de fonction := une valeur ;
 End ;
 Function nom de fonction : type ;
 Var déclaration de variables locales ;
 Begin ...
 Commandes
 ...
 nom de fonction := une valeur ;
 End ;
 Program exemple9 ;
 Uses crt ;
 Function exposant ( i , j : integer ) : integer ; { (i puissance j)}
 Var i2 , a : integer ;
 Begin
 i2 := 1 ;
 For a := 1 To j Do i2 := i2 * i ;
 exposant := i2 ;
 End ;

 Var resultat, x, n : integer ;

 BEGIN
 Write ('Entrez un nombre : ') ; Readln (x) ;
 Write('Entrez un exposant : ') ; Readln (n) ;
 resultat := exposant ( x , n ) ;
 Writeln ( resultat ) ;
 END.
 Program fun1;
 function exposant(i,j: integer): integer;
 var p, a: integer;
 begin p:=1;
 for a:=1 to j do p:=p*I exposant:=p; end;
 function factoriel(m: integer): longint;
 var k : integer; s: longint;
 begin s:=1;
 for k:=1 to m do s:=s*k;
 factoriel:=s; end;

 var i,expo,x,n: integer; fac: longint;

 var S,Ex: real;
 begin
 writeln('entrez un nombre:'); readln(x);
 writeln('entrez un exposant:'); readln(n);
 expo:=exposant(x,n); writeln(x,' exposant ', n,' =',expo);
 fac:=factoriel(n); writeln('factoriel(n)=',fac);
 S:=1; i:=1;
 repeat Ex:= exposant(x,i)/factoriel(i);
 S:=S+Ex; i:=i+1;
 until abs(Ex) <0.001;
 writeln('Exp(x)=',S);
 end.
 10. Les fichiers
 10.1. Déclaration
 Pour utiliser un ou des fichiers tout au long d'un programme,
il faudra l'identifier par une variable dont le type est fonction
de l'utilisation que l'on veut faire du fichier. Il existe trois
types de fichiers :
 Les fichiers textes (Text), qui sont écrits au format texte
(chaînes de caractères, nombres) dans lesquels ont peut
écrire et lire ligne par ligne ou à la file avec les
procédures Write(Ln) et Read(Ln). Chaque fin de ligne
du fichier se termine par les caractères 10 et 13 de la
table ASCII qui signifient respectivement retour chariot
et passage à la ligne. Ces deux derniers caractères sont
transparents au programmeur. On pourra donc y écrire
ou y lire indifféremment des chaînes ou des nombres,
cela dépend du type que l'on affecte à la variable passée
en paramètre aux procédures d'entrée/sorties (voir plus
 Note : S'il y a lieu de faire une conversion
nombre/chaîne, le compilateur le fait tout seul,
par contre si le type de la variable ne correspond
pas avec la donnée lue dans le fichier et qu'aucune
conversion n'est possible (exemple : WriteLn(f,
x:Real); alors que le fichier ne contient que des
lettres), alors cela produit une erreur.
 Syntaxe :
 Var f : Text ;
 Les fichiers typés (File Of), qui sont des fichiers
écrits sur disque telles que les données se
présentent en mémoire. C'est-à-dire que la taille
du fichier résultera directement et exactement de
la taille en mémoire qu'occupe telle ou telle
variable. Cela accrue la vitesse d'accès aux
données du fichier. Mais le plus grand avantage
c'est que l'on obtient ainsi des fichiers
parfaitement formatés, c'est-à-dire qu'on peut y
lire et écrire directement des variables de type
structuré qui contiennent plusieurs champs de
données ( voir chap Type) sans avoir à se soucier
des divers champs qu'elles contiennent. Il va sans
dire que ce type de fichier est préférable à tous les
 • Les fichiers tout courts (File), qui sont des
fichiers dont on ne connaît pas le contenu.
N'ayant aucune information sur la structure des
données, n'ayant aucune conversion à faire, la
lecture et son écriture en sont plus rapides.
 Syntaxe :
 Var f : File Of type ;
 Exemple :
 Var f : File Of Integer
 Syntaxe :
 Var f : File
 10.2. Lecture, écriture
 Avant de travailler sur un fichier, il faut le déclarer en lui
affectant une variable qui servira à désigner le fichier tout
au long du programme. Assign s'applique à tous les types de
fichiers (Text, File Of et File).
 Syntaxe :
 Assign ( variable d'appel , nom du fichier ) ;
 Ensuite, il faut renvoyer le pointeur au début du fichier
pour pouvoir lire (Text, File Ofet File) ou écrire (File Of et
File) à partir du début du fichier. Attention, on ne peut pas
écrire sur un Text avec Reset!
 Syntaxe :
 Reset (variable d'appel) ;
 Il est possible pour le type File uniquement, de
spécifier la taille de chaque bloc de donnée lu ou écrit
sur le fichier, en rajoutant en argument à Reset une
variable (ou un nombre directement) de type Word
(entier) spécifiant cette taille en octet. Cela nécessite
de connaître la taille mémoire de chaque type de
variables (voir section "Les types de variables"). Par
exemple cette taille vaudra 6 si on veut lire des nombres
réels (Real) ou bien 256 pour des chaînes de caractères
(String). Le fait que la variable taille soit de type Word
implique que sa valeur doit être comprise entre 0 et
65535. Par défaut, taille=128 octets.
 Syntaxe :
 Reset ( variable d'appel, taille ) ;
 Pour créer un fichier qui n'existe pas ou bien pour en
effacer sont contenu, on emploi ReWrite qui permet
d'effectuer des lectures (File Of et File) et écritures (Text,
File Ofet File). Attention, on ne peut pas lire sur un Text
avec ReWrite!
 Syntaxe :
 Rewrite ( variable d'appel ) ;
 Tout comme Reset, ReWrite permet de spécifier une taille
aux échanges de données sur un File seulement (aussi bien
en écriture qu'en lecture). Avec ReWrite c'est le cas ou le
fichier n'existe pas encore alors qu'avec Reset c'est le cas ou
il existe déjà.
 Syntaxe : Rewrite ( variable d'appel, taille) ;
 Tableau des correspondances entre procédures et
types de fichiers :
 Syntaxe Types de fichiers associ
 Lecture Ecriture
 Reset(f) -Text -File Of -File -File Of -File
 ReWrite(f) -File Of -File -Text -File Of -File
 Reset(f, taille) File File
 ReWrite(f, taille) File File
 Pour lire le contenu d'une ligne d'un fichier Text ouvert, on
utilise la même instruction qui permet de lire la valeur
d'une variable au clavier à savoir ReadLn. Sera alors lue, la
ou les variable(s) correspondants au contenu de la ligne
courante (celle pointée par le pointeur). Si la ou les
variable(s) n'étai(en)t pas de taille suffisamment grande
pour contenir toutes les données de la ligne, alors
l'excédent serait perdu.
 Syntaxes :
 ReadLn ( variable d'appel, variable ) ;
 ReadLn ( variable d'appel, var1, var2, ... varN) ;
 Pour écrire sur un fichier Text, il suffit d'employer la
commande WriteLn.
 Syntaxes :
 WriteLn ( variable d'appel, variable ) ;
 WriteLn ( variable d'appel, var1, var2, ... varN) ;
 Les procédures Read et Write s'utilisent respectivement de la
même manière que ReadLn et WriteLn mais s'appliquent aux
File Of aussi bien qu'aux Text. Pour lire et écrire sur un File, il
faut utiliser les procédures BlockRead et BlockWrite.
 Syntaxes:
 BlockRead ( f, variable, nbr ) ;
 BlockRead ( f, variable, nbr, result ) ;
 BlockWrite ( f, variable, nbr ) ;
 BlockWrite ( f, variable, nbr, result ) ;
 BlockRead lit sur le fichier f de type File une variable qui
contiendra un nombre de bloc mémoire (dont la taille est définie
par Reset ou ReWrite) égale à nbr. La variable facultative result
prend pour valeur le nombre de bloc effectivement lu (car il peut y
en avoir moins que prévu initialement). BlockWrite écrit sur le
fichier f de type File une variable sur un nombre de bloc mémoire
égale à nbr. La variable facultative result prend pour valeur le
nombre de bloc effectivement écrit (car il peut y en avoir plus à
écrire que ne le permet l'initialisation par Reset ou ReWrite).
Dans le cas ou cette variable result est ommise et qu'il est
impossible d'écrire autant de blocs que voulu, il est généré une
erreur !
 Note : Les variables nbr et result doivent être de type Word.
 Tableau des correspondances entre procédures et
types de fichiers :
 Syntaxe Types de fichiers associés
 WriteLn Text
 ReadLn Text
 Write -Text -File Of
 Read -Text -File Of
 BlockWrite File
 BlockRead File

 Il est impératif de fermer les fichiers ouverts pendant un

programme Turbo Pascal avant de terminer le programme
sous peine de voir les données inscrites perdues.
 Syntaxe :
 Close ( variable d'appel ) ;
 Il est possible de rappeler un fichier Text en cours
de programme même s'il a déjà été refermé grâce à
sa variable d'appel. Et alors la position courante du
curseur sera à la fin du fichier. Ne fonctionne qu'en
écriture et qu'avec un Texet.
 Syntaxe :
 Append ( variable d'appel ) ;
 La syntaxe Append est équivalente au bloc suivant
:
 Begin
 Reset(variable d'appel) ;
 Seek(variable d'appel, FileSize(variable d'appel)) ;
 End ;
  Program exemple10.2;
 Uses crt, dos ;
 Var f : text ;nom : string ;choix : char ;
 Procedure lecture ;
 Begin Append (f) ; Reset (f) ; Readln (f, nom) ; Writeln (nom) ;
 End ;
 BEGIN
 Clrscr ;
 Assign (f, 'init.txt') ;
 Rewrite (f) ; Write ('Entrez un nom d''utilisateur : ') ;
 Readln (nom) ; nom := 'Dernier utilisateur : ' + nom ;
 Writeln (f, nom) ; Close (f) ; Write ('Voulez-vous lire le fichier init.txt ?
[O/N] ') ;
 Readln (choix) ; If (choix='O') or (choix='o') then lecture ;
 END.
 Ici, le programme réinitialise à chaque lancement le fichier init.txt
et y inscrit une valeur entrée par l'utilisateur (son nom, en
l'occurrence). Il permet également à l'utilisateur de lire le contenu
du fichier (qui ne contient qu'une seule ligne de texte).
 11. Caractères et chaînes de caractères
 11.1. Chaînes de caractères
 Syntaxe :
 Var chaine : String ; telephone : String[10] ;
 Lorsqu'une valeur est affectée à une variable chaîne de
caractères, on procède comme pour un nombre mais cette
valeur doit être entre quottes. Si cette valeur contient une
apostrophe, celle-ci doit être doublée dans votre code.
 Syntaxe :
 variable := valeur ; animal := 'l''abeille' ;
 Note importante : le type String est en fait un tableau de
caractères à une dimension dont l'élément d'indice zéro
contient une variable de type Char et dont le rang dans la
table ASCII correspond à la longueur de la chaîne. Il est
donc possible, une chaîne de caractère étant un tableau de
modifier un seul caractère de la chaîne grâce à la syntaxe
suivante :
 chaine[index]:=lettre;
 Program Chaine;
 Var nom:String;
 BEGIN
 nom:='Etiévant'; nom[2]:='Z'; nom[0]:=Chr(4);
 WriteLn(nom); nom[0]:=Chr(28);
 Write(nom,'-tagada');
 END.
 L'exemple Chaine remplace la deuxième lettre de la variable nom en
un "Z" majuscule, puis spécifie que la variable ne contient plus que 4
caractères. Ainsi la valeur de la variable nom est devenue : EZié. Mais
après, on dit que la variable nom a une longueur de 28 caractères et
on s'apperçoit à l'écran que les caractères de rang supérieur à 4 ont
été conservés et des espaces ont été insérés pour aller jusqu'à 28 ! Ce
qui veut dire que la chaîne affichée n'est pas toujours la valeur totale
de la chaîne réelle en mémoire. Attention cependant aux chaînes
déclarées de longueur spécifiée (voir Chapitre 20 sur Types simples et
structurés exemple: Type nom:String[20];) dont la longueur ne doit
pas dépasser celle déclarée en début de programme.
 Concat ( s1, s2, s3, ..., sn) ;
 Cette fonction concatène les chaînes de caractères spécifiés
s1, s2, etc. en une seule et même chaîne. On peut se passer
de cette fonction grâce à l'opérateur + : s1 + s2 + s3 + ... + sn.
Rappelons que les chaînes de caractères sont généralement
définies en string.
 Syntaxes :
 s := Concat ( s1, s2 ) ; s := s1 + s2 ;
 Copy ( s, i, j ) ; Fonction qui retourne de la chaîne de caractère s,
un nombre j de caractères à partir de la position i(dans le sens de
la lecture.
 Delete ( s, i, j ) ; Procédure qui supprime dans la chaîne nommée s,
un nombre j de caractères à partir de la position i.
 Insert ( s1, s2, i ) ; Procédure qui insert la chaîne s1 dans la chaîne
s2 à la position i.
 Pos ( s1, s2 ) ; Fonction qui renvoie sous forme de variable byte la
position de la chaîne s1 dans la chaîne-mère s2. Si la chaîne s1 en
est absente, alors cette fonction renvoie 0 comme valeur.
 Str ( x, s ) ; Procédure qui convertit le nombre (Integer ou Real) x
en chaîne de caractère de nom s.
 Val ( x, s, error ) ; Procédure qui convertit la chaîne de caractère de
nom s en un nombre (Integer ou Real) x et renvoie un code erreur
error (de type integer) qui est égale à 0 si la conversion est
possible.
 FillChar ( s, n, i ) ; Procédure qui introduit n fois dans la chaîne s
la valeur i (de type Byte ou Char).
 11.2. Caractères seuls
 Un caractère est une variable de type Char qui prend 1 octet
( 8 bits) en mémoire. La table ASCII est un tableau de 256
caractères numérotés de 0 à 255 où les 23 premiers sont
associés à des fonction de base de MS-DOS (Suppr, End,
Inser, Enter, Esc, Tab, Shift...) et tous les autres sont
directement affichables (lettres, ponctuations, symboles,
caractères graphiques).
 Dans un programme en Pascal, on peut travailler sur un
caractère à partir de son numéro dans la table ASCII (avec
la fonction Chr(n°) ou #n°) ou directement avec sa valeur
affichage entre quotte ''.
 Exemples :
 espace :=' ';
 lettre :=#80;
 carac :=Chr(102);
 Le type Char défini des variables "caractère seul" ou "lettre"
ayant 1 seul signe, ce dernier appartenant à la table ASCII.
 Syntaxe :
 Var lettre : Char ;
 Lorsqu'on donne une valeur à une variable Char, celle-ci
doit être entre quottes. On peut aussi utiliser les fonctions
Chr et Ord ou même une variable String dont on prend un
caractère à une position déterminée.
 Syntaxe :
 lettre := chaine[position] ; StrUpper ( s ) ;
 Syntaxe :
 Var lettre : Char ;
 Lorsqu'on donne une valeur à une variable Char, celle-ci doit être entre
quottes. On peut aussi utiliser les fonctions Chr et Ord ou même une
variable String dont on prend un caractère à une position déterminée.
 Syntaxe :
 lettre := chaine[position] ; StrUpper ( s ) ;
 Convertit une chaîne de caractères minuscules en MAJUSCULES.
S'applique aux tableaux de caractères.
 Syntaxe de déclaration :
 Var s : Array[1..x] of Char avec x la longueur maximale de la chaîne.
StrLower (s) ; Convertit une chaîne de caractères MAJUSCULES en
minuscules. S'applique aux tableaux de caractères.
 Syntaxe de déclaration :
 Var s : Array[1..x] of Char avec x la longueur maximale de la chaîne.
 UpCase ( k ) ; Cette fonction ne s'applique qu'aux caractères seuls (de
type Char) pris dans une chaîne s. Convertit un caractère minuscule en
MAJUSCULE.
 Syntaxe :
 For i := 1 To Lenght(s)
 Do s[i] := UpCase(s[i]) ;
 Chr ( x ) ; Cette fonction renvoie un caractère Char
correspondant au caractère d'indice x dans la table ASCII.
 Exemple :
 k := Chr(64) ;
 Ord ( y ) ; Cette fonction renvoie l'indice (en byte)
correspondant au caractère y dans la table ASCII. C'est la
fonction réciproque de Chr.
 Exemple :
 i := Ord('M') ;
 Syntaxe :
 Var tab : Array[1..10] Of Record
 nom : String[20] ;age : Byte ; End ;
 Introduire des valeurs dans un tel tableau nécessite d'utiliser en
même temps la syntaxe des tableaux et des types complexes.
 Syntaxe :
 tab[5].nom := 'CyberZoïde' ;
 La déclaration de tableau en tant que constante nécessite de forcer
le type (le type tableau bien sûr) à la déclaration.
 Syntaxe :
 Const a : Array[0..3] Of Byte = (103, 8, 20, 14) ;
 b : Array[-3..3] Of Char = ('e', '5', '&', 'Z', 'z', ' ', #80) ;
 c : Array[1..3, 1..3] Of Integer = ((200, 23, 107), (1234, 0, 5), (1, 2, 3)) ;
 d : Array[1..26] Of Char = 'abcdefghijklmnopqrstuvwxyz';
 Attention : cette forme parenthèse est réservée aux
constantes car elle ne permet pas de passer un tableau en
paramètre à une procédure ou d'initialiser un tableau.
 13. Les algorithmes de tri
 Un algorithme de tri est, en informatique ou en
mathématiques, un algorithme qui permet d'organiser
une collection d'objets selon un ordre déterminé. Les
objets à trier font donc partie d'un ensemble muni
d'une relation d'ordre (de manière générale un ordre
total). Les ordres les plus utilisés sont l’ordre
numérique et l'ordre lexicographique (dictionnaire).
 Suivant la relation d'ordre considérée, une même
collection d’objet peut donner lieu à divers
arrangements, pourtant il est possible de définir un
algorithme de tri indépendamment de la fonction
d’ordre utilisée. Celui-ci ne fera qu'utiliser une certaine
fonction d’ordre correspondant à une relation d’ordre
qui doit permettre de comparer tout couple d'éléments
de la collection.
 13.1. Tri à bulles
 Le tri à bulles ou tri par propagation est un algorithme de
tri qui consiste à faire remonter progressivement les plus
petits éléments d'une liste, comme les bulles d'air
remontent à la surface d'un liquide. L'algorithme parcourt
la liste, et compare les couples d'éléments successifs.
Lorsque deux éléments successifs ne sont pas dans l'ordre
croissant, ils sont échangés. Après chaque parcours
complet de la liste, l'algorithme recommence l'opération.
Lorsqu'aucun échange n'a lieu pendant un parcours, cela
signifie que la liste est triée : l'algorithme peut s'arrêter.
 Cet algorithme est souvent enseigné en tant qu'exemple
algorithmique. Cependant, il présente une complexité en
О(n²) dans le pire des cas (où n est la longueur de la liste),
ce qui le classe parmi les mauvais algorithmes de tri. Il n'est
donc quasiment pas utilisé en pratique.
 Syntaxe :
 Const MAX = 100; (* MAX = 100 est donné en exemple seulement *)
 Type tab = array [1..MAX] of integer;
 Procedure TriBulle(n: integer ; var t: tab);
 Var i, j, tmp: integer;
 begin (* On va trier les n-1 premiers éléments du tableau *)
 for i := 1 to n - 1 do
 begin
 for j := 1 to n - i do
(* on fait n-i-1 comparaisons en avançant dans le tableau *)
 begin
 if(t[j + 1] < t[j]) then
 begin
 tmp := t[j];
 t[j] := t[j + 1];
 t[j+1] := tmp;
 end;
 end;
 end;
 end;
 Ce programme a pour but de trier les éléments d'un
tableau d'entiers dans l'ordre croissant. Une première
procédure saisie charge l'utilisateur d'initialiser le
tableau tab1. Le programme principal copie le contenu
de ce tableau vers un autre appelé tab2. Une procédure
tri range les éléments de tab2dans l'ordre. Et une
procédure affiche affiche à l'écran le tableau tab1 qui
contient les éléments dans introduits par l'utilisateur et
le tableau tab2 qui contient les mêmes éléments mais
rangés dans l'ordre croissant.