K.
SILUE Cours de programmation (Turbo Pascal)
COURS DE PROGRAMMATION
« TURBO PASCAL »
PARTIE 1
Avril 2015 1
K. SILUE Cours de programmation (Turbo Pascal)
SOMMAIRE
LEÇON 1 : LES BASES DE LA PROGRAMMATION ..................................................................................... 3
I. La structure générale d’un PROGRAMME ................................................................................................. 3
II. Commentaires dans un programme .............................................................................................................. 4
III. Déclaration des variables.......................................................................................................................... 4
IV. Le bloc des instructions : .......................................................................................................................... 5
V. Les primitives : lire(), écrire(), affectation ................................................................................................... 5
VI. Opération et fonctions intrinsèques (prédéfinies) ..................................................................................... 5
VII. Exercices d’application de la leçon .......................................................................................................... 6
LEÇON 2 : LES STRUCTURES CONDITIONNELLES ................................................................................... 8
I. Exercice corrigé .......................................................................................................................................... 12
LEÇON 3 : LES STRUCTURES REPETITIVES (Les itérations) .................................................................... 13
Si le traitement de l’itération REPEAT comporte plus d’une instruction il ne faut pas traduire le traitement à
l’intérieur d’un bloc car REPEAT et UNTIL délimite physiquement les instructions se rapportant ................. 15
LEÇON 4 : LES TABLEAUX ........................................................................................................................... 18
I) Les tableaux à une dimension..................................................................................................................... 18
II) Les tableaux à deux dimensions ............................................................................................................. 19
Avril 2015 2
K. SILUE Cours de programmation (Turbo Pascal)
LEÇON 1 : LES BASES DE LA PROGRAMMATION
I. La structure générale d’un PROGRAMME
Un PROGRAMME est constitué :
d'un entête composé du mot réservé PROGRAM et d'un nom du programme à réaliser ;
d’une zone pour l’inclusion des bibliothèques ou unités comme (Uses nom_bibliothèque ;) ;
d'une zone de déclaration des identificateurs (les objets) utilisés dans l'algorithme. C’est le monde
des données ou on déclare les constantes(CONST) et les variables (VAR);
et d'un corps délimité par deux mots réservés BEGIN et END. C'est ici qu'on écrit les actions du
programme.
Exemple de PROGRAMME :
Program CalculSurface;
Uses CRT; (* déclaration des unités utilisées *)
(* déclaration des constantes *)
(* déclaration des types définis par l’utilisateur *)
(* déclaration des variables *)
var LONG,LARG,SURF : real;
(* déclaration des fonctions et procédures *)
BEGIN (* début programme principal *)
clrscr; (* efface l’écran qui est une fonction de l’unité CRT *)
write (‘entrer la longueur du champs ‘);
readln(LONG);
write (‘entrer la largeur du champs ‘);
readln(LARG);
SURF := LONG * LARG;
writeln (‘la surface est égale à ‘, SURF:8:3);
END. (* fin programme principal *)
Remarque importante de syntaxe :
Toutes les déclarations et les instructions se terminent par un point-virgule « ; » (séparateur).
ATTENTION donc au message de compilation Error 85 : « ; » expected.
begin et end ne sont pas des déclarations ni des instructions mais des délimiteurs de blocs, donc ne
nécessitent pas de ponctuation.
Avril 2015 3
K. SILUE Cours de programmation (Turbo Pascal)
II. Commentaires dans un programme
Les commentaires sont un élément très important dans la lisibilité d’un programme, et dans la
maintenance de celui-ci. Il est donc important d’en mettre régulièrement.
(* commentaires *) ou bien { commentaires }
ou encore
(* commentaires ligne 1 ou { commentaires ligne 1
commentaires ligne 2 commentaires ligne 2
… …
commentaires ligne n *) commentaires ligne n }
III. Déclaration des variables
Toute constante et variable utilisées dans un programme doivent obligatoirement être déclarées dans
la zone référencée à cet effet. Identifier les constantes par le mot clé de Turbo PASCAL
« CONST » et les variables par le mot clé « VAR ».
Les variables seront énumérées et typées à la suite du mot clé VAR; si plusieurs variables ont un
type commun on peut les aligner séparées de virgules.
III.1. Les identificateurs
Les identificateurs sont l’ensemble des noms de variables, de constantes, de types utilisateurs, de
fonctions et procédures, et le nom du programme.
Le nom d’un identificateur commence par une lettre, suivi éventuellement par d’autres lettres,
chiffres, ou le caractère « _ » (souligné) / aucun espace.
La longueur maximum prise en compte par Turbo PASCAL est de 63 caractères.
Turbo PASCAL ne fait aucune différence entre majuscules et minuscules.
L’utilisation de caractères accentués entraîne une erreur de compilation.
Le nom d’un identificateur ne doit pas être un mot du langage.
Les mots réservés en langage PASCAL :
AND , ARRAY, ASM, BEGIN, CASE, CONST, CONSTRUCTOR, DESTRUCTOR, DIV, DO,
DOWNTO, ELSE, END, EXPORTS, FILE, FOR, FUNCTION, GOTO, IF,
IMPLEMENTATION,IN, INHERITED, INLINE, INTERFACE, LABEL, LIBRARY, MOD, NIL,
NOT, OBJECT, OF, OR, PACKED, PROCEDURE, PROGRAM, RECORD, REPEAT, SET, SHL,
SHR, STRING, THEN, TO, TYPE, UNIT, UNTIL, USES, VAR, WHILE, WITH, XOR.
Avril 2015 4
K. SILUE Cours de programmation (Turbo Pascal)
III.2. Les types simples
Les types simples sont résumés dans le tableau ci-dessous :
Types algorithmiques Types Turbo PASCAL
type scalaire
Integer [-32768, 32767]
Entier Byte [0, 255]
Shortint [-127, 128]
Longint [-2147483648, 2147483647]
Real [2.9 10-39, 1.7 10+38]
Réel Single [1.5 10-45, 3.4 10+38]
Double [5 10-324, 1.7 10+308]
type scalaire
Caractère
Char ensemble des caractères ASCII
String de 0 à 255 caractères
Chaîne de caractères
String[20] de 0 à 20 caractères
type scalaire
Booléen
Boolean [true,false]
IV. Le bloc des instructions :
La partie des instructions d’un programme est délimitée par un bloc, qui possède un début et une fin
en PASCAL Begin et end. La fin du programme est marquée par un point «. »
Tout ce qui sera écrit après le point final du programme ne sera pas pris en compte par
le compilateur.
V. Les primitives : lire(), écrire(), affectation
Algorithme PASCAL explication
lire() readln(); lecture de la valeur d’une variable saisie au clavier
écriture à l’écran soit de la valeur de variables et/ou de textes
write();
effectue l’écriture et laisse le curseur en fin d’écriture
écrire()
writeln();
effectue l’écriture et positionne le curseur au début de la ligne suivante
effectue le calcul à droite de l’affectation et transfère le résultat à la
← :=
variable à gauche de l’affectation
VI. Opération et fonctions intrinsèques (prédéfinies)
Les opérations arithmétiques
Définition Opération Algorithme Programmation
Addition + C ←A + 2 C := A + 2 ;
Soustraction - RES ←B - A RES := B - A ;
Multiplication * RES ←C x 0,5 RES := C * 0.5 ;
Division fractionnaire / D ←2 / 4 D := 2/4 ;
DE ←division_entière (5,2)
Division entière DIV DE := 5 DIV 2 ;
DE ←5 DIV 2
Modulo ou reste de la RE ←reste_division_entière (5,2)
MOD RE := 5 MOD 2 ;
division entière
RE ←5 MOD 2
Avril 2015 5
K. SILUE Cours de programmation (Turbo Pascal)
Les priorités des opérations sont celles des mathématiques soit (*, /, DIV, MOD) puis (+, -).
La concaténation de chaînes de caractères
Définition Opération Algorithme Programmation
Concaténation (de
+ CHAIN ←A + ‘Bonjour’ CHAIN := A + ‘Bonjour’ ;
chaîne de caractères)
VII. Exercices d’application de la leçon
Exercice 1
Ecrire un programme permettant de saisir deux nombres entiers et de les afficher.
Correction de l’exercice 1
PROGRAM SaisirAffiche ;
VAR
Nbre1, Nbre2 : INTEGER ;
BEGIN
WRITELN(‘Entrez deux nombres’) ;
READLN(Nbre1,Nbre2) ;
WRITELN(‘Les deux sont :’, Nbre1, Nbre2) ;
END.
Exercice 2
Ecrire un programme permettant de permuter deux nombres entiers.
Correction de l’exercice 2
Pogram Permutation ;
VAR
Nbre1, Nbre2, Interm :Integer ;
begin
writeln(‘Entrez deux nombres entiers’) ;
readln(Nbre1,Nbre2) ;
Interm :=Nbre1 ;
Nbre1 :=Nbre2 ;
Nbre2 :=Interm;
writeln(‘Permutation terminée’) ;
end.
Exercice 3
Ecrire un programme permettant de saisir un prénom et d’afficher « Bonjour et bonne journée » suivi du
prénom saisi.
Correction du programme
program Civilite ;
VAR
Prenom : string ;
begin
writeln(‘Entrez votre prénom SVP’) ;
Avril 2015 6
K. SILUE Cours de programmation (Turbo Pascal)
readln(Prenom) ;
writeln(‘Bonjour et bonne journée’,Prenom) ;
end.
Exercice 4
Ecrire un programme permettant de faire la moyenne de 3 entiers.
Correction du programme
program CalMoyenne ;
VAR
Nbre1,Nbre2, Nbre3 :integer ;
Moy : Real ;
begin
writeln(‘Entrez 3 nombres SVP’) ;
readln(Nbre1,Nbre2,Nbre3) ;
Moy :=(Nbre1+Nbre2+Nbre3)/3 ;
writeln(‘La moyenne des 3 nombres est :’,Moy) ;
end.
Autres exercices de la leçon
Exercice 5
Ecrire un programme permettant de permuter deux nombres entiers en utilisant que deux variables.
Exercice 6
Ecrire un programme permettant de calculer la moyenne d’un étudiant. Il y a deux matières et chaque matière
a deux notes. La première matière a un coefficient de 2 et la deuxième matière a pour coefficient 3.
Avril 2015 7
K. SILUE Cours de programmation (Turbo Pascal)
LEÇON 2 : LES STRUCTURES CONDITIONNELLES
REMARQUE
Une Instruction conditionnelle est programmée sous la forme d'une seule instruction.
RAPPEL sur la notion de BLOC
Un bloc est le regroupement d’une série d’instructions délimitée par les mots clés BEGIN et END
Ces deux mots du langage PASCAL n’étant pas des instructions, ou déclarations, mais des délimiteurs de
blocs, ils ne nécessitent pas de ponctuation spécifique.
I. Syntaxe de IF THEN ELSE (SI ALORS SINON)
Nous avons vu dans la partie algorithmique qu’une instruction conditionnelle standard, et composé des mots
clés suivants :
SI <Conditions> ALORS <Traitement Alors> SINON <Traitements Sinon> FINSI
En Turbo PASCAL on obtient la traduction suivante :
IF <Conditions> THEN <Traitement Alors> ELSE <Traitements Sinon> ;
exemple : Programmation PASCAL d’une conditionnelle
…
IF NOMBR1 > NOMBR2
THEN writeln (‘le premier nombre est le plus grand’)
ELSE IF NOMBR1 < NOMBR2
THEN writeln (‘le second nombre est le plus grand’)
ELSE writeln (‘les deux nombres sont égaux’);
ou encore à l’aide des blocs
IF NOMBR1 > NOMBR2
THEN begin
writeln (‘le premier nombre est le plus grand’);
end
ELSE begin
IF NOMBR1 < NOMBR2
THEN begin
writeln (‘le second nombre est le plus grand’);
end
ELSE begin
writeln (‘les deux nombres sont égaux’);
end;
end;
Avril 2015 8
K. SILUE Cours de programmation (Turbo Pascal)
Générales
Un point-virgule (séparateur) n’est pas obligatoire devant un END
Si la traduction d’un algorithme nous amène à avoir plusieurs points virgules (séparateur) les uns à la suite
des autres ; un seul suffit.
Si une action (traitement) comprend plus d’une instruction alors cette action sera obligatoirement traduite à
l’intérieur d’un bloc (délimité par BEGIN et END).
II. Les CONDITIONS MULTIPLES, COMPOSEES, ou COMPLEXES
Les conditions multiples, composées, ou complexes respectent les règles logiques de priorités (algèbre de
BOOLE) soit : d’abord le NOT (non) puis le AND (et) et enfin OR(ou) et XOR.
Toutefois c’est le développeur de l’application, lors de la conception qui va définir les parenthèses à usage
correct, en fonction du problème à résoudre.
Règle de syntaxe :
Lors de la programmation d'une condition composée, chaque condition simple composant la condition
composée doit être mise entre parenthèses ceci indépendamment des parenthèses à usage logique défini lors
de la conception.
exemple 1 :
Algorithme Programmation
Si A = B ou A = 2
If (A = B) or (A = 2)
alors écrire (A)
then writeln (A)
sinon écrire (B)
else writeln(B);
FinSi
exemple 2 :
Algorithme Programmation
If (N1 > N2) and ((N1 <> 0) or (N2 <> 0))
Si N1 > N2 et (N1 0 ou N2 0) then begin
writeln (N1);
alors écrire (N1)
N1 := N2 + 2;
N1 ←N2 + 2
end
sinon écrire (N2)
else begin
N2 ←N1 + 3 writeln (N2);
FinSi N2 := N1 + 3;
end;
Le cas particulier
Algorithme Programmation
Si A = 1
alors Si B > 1 If A = 1
Then If B > 1
alors A ←4
Then A := 4
Finsi
Else
sinon A ←5 Else A := 5 ;
FinSi
Avril 2015 9
K. SILUE Cours de programmation (Turbo Pascal)
III. EN FONCTION DE <Sélecteur>
Syntaxe
CASE <Sélecteur> OF
V1 : Action1 ;
V2 : Action2 ;
…
Vn-1 : Action n-1 ;
ELSE Action n ;
END; (* fin CASE *)
ou encore
CASE <Sélecteur> OF
V1 : begin Action1 end;
V2 : begin Action2 end;
Vn-1 : begin Action n-1 end;
ELSE begin Action n end;
END; (* fin CASE *)
1) Application
Enoncé : Ecrire un programme permettant de déterminer la valeur absolue d’un nombre entier.
Solution :
program ValAbsolue ;
Var
N :integer ;
begin
writeln(‘Entrez un nombre’) ;
readln(N) ;
If N>=0 then
begin
writeln(‘La valeur absolue de ‘,N,’est ‘,N) ;
end ;
if N<0 then
Avril 2015 10
K. SILUE Cours de programmation (Turbo Pascal)
begin
writeln(‘La valeur absolue de ‘,N,’est ‘,-N) ;
end ;
end.
1) Application
Enoncé : Ecrire un programme permettant de déterminer la valeur absolue d’un nombre entier.
Solution:
program ValAbsolue ;
VAR
N :integer ;
begin
writeln(‘Entrez un nombre’) ;
readln(N) ;
if N>=0 then
begin
writeln(‘La valeur absolue de ‘,N,’est ‘,N) ;
end
else
begin
writeln(‘La valeur absolue de ‘,N,’est ‘,-N) ;
end ;
end.
Exemple :
CASE Note OF
Note ≥ 16 : writeln ('TB') ;
Note ≥ 14 : writeln ('B') ;
Note ≥ 12 : writeln ('AB') ;
Note ≥ 10 : writeln ('Passable') ;
else writeln ('Ajourné') ;
end ;
Avril 2015 11
K. SILUE Cours de programmation (Turbo Pascal)
I. Exercice corrigé
Enoncé : Ecrire un programme permettant de savoir le signe du produit de deux nombres entiers.
Solution :
program SigneProd ;
var
Nbre1,Nbre2,Prod :integer ;
begin
writeln(‘Entrez deux nombres entiers’) ;
readln(Nbre1,Nbre2) ;
Prod :=Nbre1*Nbre2 ;
if Prod>0 then
begin
writeln(‘Le produit est positif’) ;
end
else
begin
if Prod < 0 then
begin
writeln(‘Le produit est négatif’) ;
end
else
begin
writeln(‘Le produit est nul’) ;
end ;
end ;
end.
Autres exercices de la leçon.
Exercice 1
Ecrire un programme permettant de savoir le résultat d’un étudiant. Il a deux notes et il faut avoir une
moyenne supérieure ou égale à 10 pour être admis. Pour une moyenne inférieure à 10 on est ajourné.
Exercice 2
Ecrire un programme permettant de comparer deux nombres.
Avril 2015 12
K. SILUE Cours de programmation (Turbo Pascal)
LEÇON 3 : LES STRUCTURES REPETITIVES (Les itérations)
Remarque
Une instruction itérative va être traduite et donc considérée par le compilateur comme une et une seule
instruction PASCAL.
I. Itérations bornées
POUR <Indice d’itération> DE <Borne de départ> A <Borne d’arrivée> FAIRE
TRAITEMENTs
FinPOUR
Traduction si la borne de départ est inférieure à la borne d’arrivée
FOR <Indice d’itération> := <Borne de départ> TO <Borne d’arrivée> DO
TRAITEMENTs
;
En Pascal, il est impératif que <Indice d’itération> soit défini de type scalaire.
exemple
For i := 1 to 10 do
writeln(i);
ou
For i := 1 to 10 do
begin {début du bloc des instructions de l’itération}
gotoxy(1,i);
write(i);
end; {fin du bloc des instructions de l’itération}
Traduction si la borne de départ est supérieure à la borne d’arrivée
FOR <Indice d’itération> := <Borne de départ> DOWNTO <Borne d’arrivée> DO
TRAITEMENTs
;
exemple
For i := ‘Z’ downto ‘A’ do
writeln(i);
ou
For i := ‘Z’ downto ‘A’ do
begin {début du bloc des instructions de l’itération}
gotoxy(1,i);
write(i);
end; {fin du bloc des instructions de l’itération}
Avril 2015 13
K. SILUE Cours de programmation (Turbo Pascal)
Si le traitement de l’itération bornée comporte plus d’une instruction il faut traduire ce traitement à l’intérieur
d’un bloc BEGIN … END
Si une itération bornée possède un pas différent de 1, On la traduira par une itération TANT QUE ou
REPETER.
Les deux algorithmes suivants sont équivalents :
i =10
Pour i de 10 à 50 faire (pas de 5) Tant que i<50 faire
Traitement Traitement
FinPour i i← i + 5
FinTantQue
II. Itérations conditionnelles
TANT QUE NON <condition d’arrêt> FAIRE
TRAITEMENTS
FinTANTQUE
se traduit en Turbo PASCAL par la séquence suivante
WHILE NON <condition d’arrêt> DO
TRAITEMENTS
;
exemple
While I < 10 do
I := I + 2;
While Not TROUV and (COMPTE < LONG) do
begin {début du bloc des instructions de l’itération}
writeln(‘entrer l’’élément n°’,COMPTE,’:’);
readln(ELEM);
if ELEM = RECH
then TROUV := true
else inc(COMPTE);
end; {fin du bloc des instructions de l’itération}
Si le traitement de l’itération WHILE comporte plus d’une instruction il faut traduire ce traitement à l’intérieur
d’un bloc BEGIN END
ou encore
Avril 2015 14
K. SILUE Cours de programmation (Turbo Pascal)
REPETER
TRAITEMENTs
JUSQU’A <condition d’arrêt>
se traduit en Turbo PASCAL par la séquence suivante
REPEAT
TRAITEMENTS
UNTIL <condition d’arrêt> ;
exemple
repeat
readln(N);
until (N > -50) and (N < 50) ;
Si le traitement de l’itération REPEAT comporte plus d’une instruction il ne faut pas
traduire le traitement à l’intérieur d’un bloc car REPEAT et UNTIL délimite
physiquement les instructions se rapportant
III. Applications
III.1- WHILE …DO
Enoncé :
On veut faire la somme de 10 (dix) entiers. Ecrire le programme en utilisant la structure de contrôle WHILE
…DO.
Solution de l’exercice
program Somme ;
var
Nbre,Som,Cpte :integer ;
begin
Som :=0 ;
Cpte :=0 ;
while Cpte<10 do
begin
writeln(‘Entrez un nombre’) ;
readln(Nbre) ;
Som :=Som+Nbre ;
Cpte :=Cpte+1 ;
end ;
writeln(‘La somme est ‘,Som) ;
end.
Avril 2015 15
K. SILUE Cours de programmation (Turbo Pascal)
III.2- REPEAT …UNTIL
Enoncé : On veut faire la somme de 10 (dix) entiers
Ecrire le programme en utilisant la structure de contrôle REPEAT …UNTIL.
Solution de l’exercice
program Somme2 ;
var
Nbre,Som,Cpte :integer ;
begin
Som :=0 ;
Cpte :=0 ;
REPEAT
writeln(‘Entrez un nombre’) ;
readln(Nbre) ;
Som :=Som+Nbre ;
Cpte :=Cpte+1 ;
UNTIL Cpte >10;
writeln(‘La somme est ‘,Som) ;
end.
Avril 2015 16
K. SILUE Cours de programmation (Turbo Pascal)
III.3- FOR …DO
Enoncé : On veut faire la somme de 10 (dix) entiers
Solution de l’exercice
program Somme3 ;
var
Nbre,Som,Cpte :integer ;
begin
Som :=0 ;
Cpte :=0 ;
FOR Cpte :=1 TO 10 DO
begin
writeln(‘Entrez un nombre’) ;
readln(Nbre) ;
Som :=Som+Nbre ;
end ;
writeln(‘La somme est ‘,Som) ;
end.
Autres exercices de la leçon
Exercice 1
Ecrire un programme permettant de calculer la factorielle d’un nombre entier.
Exercice 2
Ecrire un programme permettant d’afficher des nombres entiers consécutifs de zéro à cent.
Exercice 3
Ecrire un programme permettant d’afficher des nombres entiers consécutifs de cent à zéro.
Avril 2015 17
K. SILUE Cours de programmation (Turbo Pascal)
LEÇON 4 : LES TABLEAUX
I) Les tableaux à une dimension
1) Définition
Un tableau à une dimension également appelé vecteur est une structure de données constituée d’une ligne et de
plusieurs colonnes permettant de contenir des informations de même type. Les tableaux en Pascal sont notés
ARRAY.
2) Déclaration
NomTableau : ARRAY[valeur initiale..valeur finale] OF TYPE
Exemple :
Déclarez un tableau de 10 entiers.
TNbre :ARRAY[1..10] OF INTEGER
Observations :
Chaque case a un indice. Soit le tableau TPrenom de 5 prénoms.
Indice : 1 2 3 4 5
Valeurs : Facto Pluplu Poulili Sacolo Gagoumo
TPrenom[3] contient la valeur Poulili
3) Application
Enoncé : Ecrire un programme permettant de faire la somme et la moyenne de dix nombres que vous
devez saisir au préalable dans un tableau à une dimension.
Solution de l’exercice :
PROGRAM AdditionMoyenne ;
VAR
TNbre :ARRAY[1..10] OF INTEGER ;
i,Som :INTEGER;
Moy :REAL ;
BEGIN
(* La saisie des nombres*)
FOR i :=1 TO 10 DO
BEGIN
WRITELN(‘Entrez le nombre N° ‘,i) ;
READLN(TNbre[i]) ;
END ;
(*Faire la somme*)
Som :=0 ;
FOR i :=1 TO 10 DO
BEGIN
Som;=Som+TNbre[i] ;
END ;
Moy:=Som/i ;
WRITELN(‘La somme est :’,Som) ;
WRITELN(‘La moyenne est :’,Moy) ;
END.
Avril 2015 18
K. SILUE Cours de programmation (Turbo Pascal)
II) Les tableaux à deux dimensions
1) Définition
Un tableau à deux dimensions est une structure de données constituée de plusieurs lignes et de plusieurs
colonnes permettant de contenir des informations de même type.
2) Déclaration
NomTableau :ARRAY[ValeurInitialeLigne..ValeurFinaleLigne, Valeur
initialeColonne..ValeurFinaleColonne] OF TYPE ;
Exemple : Déclarez un tableau de 2 lignes et de 5 colonnes de prénoms.
TPrenom :ARRAY[1..2,1..5] OF STRING ;
Observation : Un tableau à deux dimensions a deux indices. Le premier indique le numéro de la ligne et le
second le numéro de colonne (exemple : TPrenom[2,3] :=’Yaopio’) ;
3) Application
Enoncé : Ecrire un programme permettant de saisir 10 nombres dans un tableau de deux lignes et de cinq
colonnes. Après la saisi votre algorithme doit permettre de déterminer la plus grande valeur du tableau.
Solution de l’exercice 3
PROGRAM Maxi ;
VAR
TNbre :ARRAY[1..2 ,1..5] OF INTEGER
i,j,Max : INTEGER
BEGIN
FOR i :=1 TO 2 DO
BEGIN
FOR j :=1 TO 5 DO
BEGIN
WRITELN(‘Entrez un nombre’) ;
READLN(TNbre[i ,j]) ;
END ;
END ;
Max :=TNbre[1;1] ;
FOR i :=1 TO 2 DO
BEGIN
Avril 2015 19
K. SILUE Cours de programmation (Turbo Pascal)
FOR j :=1 TO 5 DO
BEGIN
IF Max < TNbre[i ,j] THEN
BEGIN
Max :=TNbre[i ,j];
END;
END ;
END ;
WRITELN(‘La plus grande valeur du tableau est ’,Max) ;
END.
Exercices de la même leçon
Exercice 1
Ecrire un programme permettant de trier un tableau de dix entiers.
Exercice 2
Ecrire un programme permettant de déterminer le nombre de notes supérieures ou égales à 10
préalablement saisie dans un vecteur.
Exercice 3
Ecrire un programme permettant de déterminer le nombre de notes inférieures à dix préalablement saisie
dans une matrice deux lignes et cinq colonnes.
Exercice 4
Ecrire un algorithme permettant de remplacer tous les nombres inférieurs à zéro par zéro dans une matrice
de trois lignes et de quatre colonnes.
Avril 2015 20
K. SILUE Cours de programmation (Turbo Pascal)
Bibliothèques de procédures et de fonctions.
Les procédures et fonctions utilisées couramment peuvent être regroupées en bibliothèques appelées
unités en Turbo Pascal. Dans ce cas on déclare l'utilisation des bibliothèques dans la partie
déclarations du programme en utilisant le mot réservé Uses suivi des noms des unités.
Le programmeur peut créer de nouvelles unités.
Le Turbo Pascal fournit un certain nombre d'unités prêtes à l'emploi:
Unité System
Elle contient les procédures et fonctions de base comme Write ou Readln. C'est la seule unité qui n'a
pas besoin d'être déclarée et qui est toujours utilisable.
Unité Crt ou USES Crt
Permet la gestion de l'écran en mode texte, la gestion du clavier, la gestion du son.
Unité Dos
Permet la gestion des fonctions fournies par le DOS.
Unité Lst
Permet la gestion de l'imprimante.
Unité Graph
Permet la gestion de l'écran en mode graphique
Avril 2015 21