Embed Size (px)
Citation preview
CSI2520, Hiver 2007
Le langage Pascal
Un langage de programmation Impérative
Paradigme de programmation impérative
• Abstraction du langage machine– Des instructions, de la mémoire
• Création d’une machine virtuelle
CSI2520, Hiver 2007
MachinePascal
C…
CompilateurInterpréteur
Systèmed’
exploitation
Machineréelle
Principe de base
• Les variables:– Un nom est associé à un emplacement qui contient
une valeur • À la compilation, au chargement ou en cours d’exécution• dimension et représentation binaire• VAR x : REAL
– L’affectation sert à associer une valeur à un emplacement
• X:=2• l-valeur versus r-valeur
CSI2520, Hiver 2007
Programmation structurée
• But: fournir des structures de contrôle facilitant le raisonnment– Composition
• blocs, fonctions
– Sélections• if then else, switch case
– Itérations• do while, for
CSI2520, Hiver 2007
CSI2520, Hiver 2007
Un programme PASCAL est composé d'une entête, des déclarations et des instructions (délimitées par BEGIN et END. ).
PROGRAM cercle (input,output); (* entête *)
VAR perimetre,diametre : REAL; (* déclarations *)
BEGIN
readln(diametre); (* instruction *)
perimetre := 3.141592 * diametre; (* instruction *)
writeln(diametre,perimetre) (* instruction *)
END.
Un Premier Petit Programme
CSI2520, Hiver 2007
PROGRAM NomProgramme (ListeFichiers);
CONST (* declarations de constantes *)
TYPE (* declarations de types *)
VAR (* declarations de variables *)
(* definitions de sous-programmes *)
BEGIN (* instructions executables *)END.
Structure d’un Programme
CSI2520, Hiver 2007
program SumAverage;
const NumberOfIntegers = 5;var A, B, C, D, E : integerinteger; Sum : integerinteger; Average : realreal; Grade : charchar; Fail : booleanboolean;begin (* Main *) A := 45; B := 7; C := 68; D := 2; E := 34; Sum := A + B + C + D + E; Average := Sum / NumberOfIntegers; writeln ('Nombre d''entiers = ', NumberOfIntegers); writeln ('Nombre 1 = ', A); writeln ('Nombre 2 = ', B); writeln ('Nombre 3 = ', C); writeln ('Nombre 4 = ', D); writeln ('Nombre 5 = ', E); writeln ('Sum = ', Sum); writeln (‘Moyenne = ', Average)end. (* Main *)
Constantes, Variables et Assignation
CSI2520, Hiver 2007
• Standard: read, readln: lecture du clavier write, writeln: affichage sur écran
• Fichiers:
program recopier(input,output); var
fic_ent,fic_sor : file of real; x:real; begin
assign(ficEnt,'fichier1'); (* non standard *) reset(ficEnt);
assign(ficSor,'fichier2'); rewrite(ficSor);
while not eof(ficEnt) do begin
read(ficEnt,x); write(ficSor,x)
end; close(ficEnt); close(ficSor) end.
Entrees / Sorties
CSI2520, Hiver 2007
Les principales fonctions standard connues par tous les compilateurs sont :
ABS : renvoie la valeur absolue SIN : sinus
SQR : renvoie le carré ARCTAN : arc tangente
SQRT : racine carrée EXP : exponentielle
COS : cosinus LN : log népérien
SUCC : variable énumérée suivante PRED : précédent
CHR : renvoie le caractere d’un code ASCII ORD : renvoie le code ASCII
ROUND : arrondi à l'entier le plus proche
TRUNC : partie entière (permet de mettre un réel dans un entier:
trunc(4.5)=4)
Fonctions Standards
CSI2520, Hiver 2007
Boucles: While, Repeat, ForPROGRAM racine_a_deux_decimales(input,output); VAR nombre, racine : REAL; BEGIN writeln('entrez un réel entre 0 et 10'); readln(nombre); racine:=0; WHILE racine*racine < nombre DO racine:=racine+0.01; writeln('la racine de ',nombre,' vaut ',racine) END.
PROGRAM racine_a_deux_decimales2(input,output); VAR nombre, racine : REAL; BEGIN writeln('entrez un réel entre 0 et 10'); readln(nombre); racine:=0; REPEAT racine:=racine+0.01 UNTIL racine*racine > nombre; writeln('la racine de ', nombre,' vaut ',racine) END.
CSI2520, Hiver 2007
Boucles: While, Repeat, For• FOR variable_énumérée:=valeur_début TO valeur_fin DO instruction
• La variable_énumérée (non réelle) prend la valeur_début, et l'instruction
est exécutée. Puis elle est incrémentée (on passe à la suivante, c.a.d si
elle est entière on ajoute 1), et ce jusqu'à valeur_fin (compris).
• On peut utiliser un pas dégressif en remplaçant TO par DOWNTO.
ex: for lettre:='Z' downto 'A' do writeln(lettre);
écrit l'alphabet à l'envers (en déclarant LETTRE du type CHAR)
CSI2520, Hiver 2007
IF-THEN-ELSE, CASE - OF• structure : IF condition THEN instruction1 (CAS 1)
ou : IF condition THEN instruction1 ELSE instruction2 (CAS 2)
• IF cond1 then if cond2 then inst1 (*cond1 et cond2*) else inst2 (*cond1 et pas cond2*)
else if cond3 then inst3 (*pas cond1 mais cond3*) else inst4 (*ni cond1 ni cond3*) • structure: CASE expression OF
liste_de_cas1:instruction1; liste_de_cas2:instruction2; .... OTHERWISE instructionN
END • CASE a*b OF (* avec a et b déclarés entiers *)
0 : writeln('un des nombres est nul'); 1,10,100,1000,10000 : writeln('le produit est une puissance de 10'); otherwise writeln('autre produit')
END
CSI2520, Hiver 2007
Procedures et Fonctions
program AddEmUp;
procedure PrintIt( a, b, c: integer ); begin Writeln('The sum of a, b, and c is ', a+b+c, '.'); end; begin PrintIt(2, 3, 4); end.
CSI2520, Hiver 2007
program classer(input,output);
var
a,b,c:real;
function MAX(x,y:real):real;
begin
if x>=y then MAX:=x else MAX:=y
end;
begin
writeln('entrez deux valeurs : ');
readln(a,b);
c:=max(a,b);
writeln('le plus grand est ',c)
end.
Procedures et Fonctions
CSI2520, Hiver 2007
Procedures et Fonctions: Portee• Tous peuvent voir les variables
globales A, B, et C. • Dans la procédure Alpha la définition
globale de A est remplacée par la définition locale.
• Beta1 et Beta2 peuvent voir les variables VCR, Betamax, et cassette.
• Beta1 ne peut voir la variable FailureToo, et Beta2 ne peut voir Failure.
• Aucun sous-programme sauf Alpha peut accéder F et G.
• La procédure Beta1 peut appeler Alpha et Beta.
• La fonction Beta2 peut appeler tous les sous-programmes, incluant lui-même (mais pas le programme principal)
CSI2520, Hiver 2007
PROGRAM portee (input,output); VAR a,b,c,d:real; PROCEDURE aff_somme(a,b:real); var c:real; begin c:=a+b; writeln(a ,' + ', b ,' = ', c) end; BEGIN { programme principal } writeln('entrez 4 valeurs : '); readln(a,b,c,d); aff_somme(a,b); aff_somme(3,5); aff_somme(c+a,d) END.
Procedures et Fonctions: Portee
CSI2520, Hiver 2007
Procedures et Fonctions: Recursiviteprogram TowersofHanoi;Var numdiscs : integer;procedure DoTowers (NumDiscs, OrigPeg, NewPeg, TempPeg : integer);begin if NumDiscs = 1 then writeln (OrigPeg, ' ---> ', NewPeg) else begin DoTowers (NumDiscs-1, OrigPeg, TempPeg, NewPeg); writeln (OrigPeg, ' ---> ', NewPeg); DoTowers (NumDiscs-1, TempPeg, NewPeg, OrigPeg) endend;begin (* Main *) write ('Please enter the number of discs in the tower ===> '); readln (numdiscs); writeln; DoTowers (numdiscs, 1, 3, 2)end. (* Main *)
CSI2520, Hiver 2007
Passage par Valeur et par Reference
program parametres;var alpha, gamma, delta : integer;
procedure Name (a, b : integer; VAR c, d : integer); begin a := 10; c := 20; end;
begin alpha := 1; gamma := 50; delta := 30; Name (alpha, 2, gamma, delta); writeln ('alpha= ', alpha, 'gamma= ', gamma, 'delta= ', delta);end.
CSI2520, Hiver 2007
Declaration Anticipee: Forward Une procédure devant toujours être déclarée pour pouvoir être utilisée, on utilise FORWARD pour les cas de récursivité passant par 2 procédures :
function prem(a,b:real):boolean; FORWARD; {déclaration anticipée de l'entête } procedure deux(x,y:real); var bool:boolean; begin ...... bool:=prem(x,y); {on peut utiliser PREM car déjà déclarée} ...... end; function prem; {ne plus donner les arguments car déjà déclarés} begin ...... if pas_fini then deux(a,b); (* DEUX déjà déclarée*) ...... end;
CSI2520, Hiver 2007
Structures de Donnees
PROGRAM heures(input,output);TYPE tj=(lundi,mardi,mercredi,jeudi,vendredi,samedi,dimanche);VAR jour:tj; nb_heures_cours:ARRAY[tj] OF integer;BEGIN nb_heures_cours[lundi] := 4; … sum := 0; FOR jour:=lundi TO vendredi DO sum = sum + nb_heures_cours[jour]; writeln(‘le nombre d’’heures est : ‘, sum);END.
CSI2520, Hiver 2007
Chaines de Caractèresprogram position(input,output);var ch,sch:string[255]; i,j,n,l,ls:integer;begin writeln('chaîne à tester ? '); readln(ch); writeln('sous-chaîne à trouver ?'); readln(sch); l:=length(ch);ls:=length(sch); n:=0; for i:=1 to l-ls do begin j:=1; while (j<=l)and(ch[i+j-1]=sch[j]) do j:=j+1; if j>ls then begin writeln('trouvé position ',i); n:=n+1 end end; writeln(n,' fois ',sch,' dans ',ch)end.
CSI2520, Hiver 2007
Chaines de Caractères
Var myString : String; Begin myString := 'Hey! How are you?'; Writeln('The length of the string is ',byte(myString[0])); Write(myString[byte(myString[0])]); Write(' is the last character.'); End.
CSI2520, Hiver 2007
Chaines de Caractères
Var S : String; Begin S := 'Hey there! How are you?'; Write('The word "How" is found at char index '); Writeln(Pos('How',S)); If Pos('Why',S) <= 0 then Writeln('"Why" is not found.'); End.
CSI2520, Hiver 2007
Enregistrements
TYPE date = RECORD jour:1..31; mois:1..12; an:1980..1999 END; facture = RECORD reference:integer; jour:date; client:string[100]; total:real END; VAR date1,date2:date; comptes:array[1..100] of facture; fact:facture;
CSI2520, Hiver 2007
EnregistrementType Str25 = String[25]; TBookRec = Record Title, Author, ISBN : Str25; Price : Real; End; Var myBookRec : TBookRec; Begin myBookRec.Title := 'Some Book'; myBookRec.Author := 'Victor John Saliba'; myBookRec.ISBN := '0-12-345678-9'; myBookRec.Price := 25.5; Writeln('Here are the book details:'); Writeln; Writeln('Title: ', myBookRec.Title); Writeln('Author: ', myBookRec.Author); Writeln('ISBN: ', myBookRec.ISBN); Writeln('Price: ', myBookRec.Price); Readln; End.
CSI2520, Hiver 2007
Pointeurs program liste(input,output); TYPE tpoint=^tval; tval=record valeur:integer; suivant:tpoint end; VAR prem,precedent,point:tpoint; i,n:integer; begin write('combien d''éléments comporte votre liste ?'); readln(n); new(prem); (* le 1er est particulier: tete de liste *) write('1ère valeur ? '); readln(prem^.valeur); precedent:=prem; for i:=2 to n do begin new(point); (* création d'une nouvelle variable *) write(i,'ième valeur ? '); readln(point^.valeur); precedent^.suivant:=point; (* mise à jour du chaînage *) precedent:=point (*se préparer pour la prochaine boucle*) end; precedent^.suivant:=NIL; (* NIL signifie "rien" *) point:=prem; (* heureusement, on se souvient du premier *) for i:=1 to n do begin writeln(point^.valeur); point:=point^.suivant (* pour la prochaine boucle *) end end.
CSI2520, Hiver 2007
Exemplesprogram calculatrice(input,output);var val1,val2,resultat:real; operation:char;begin writeln('première valeur ?'); readln(val1); writeln('opération (+ - * /) ? '); readln(operation) writeln('deuxième valeur ? '); readln(val2); case operation of '+':resultat:=val1+val2; '-':resultat:=val1-val2; '*':resultat:=val1*val2; '/':resultat:=val1/val2 end; writeln('résultat : ',resultat)end.
CSI2520, Hiver 2007
Exemplesprogram Fibonacci;var Fibonacci1, Fibonacci2 : integer; temp : integer; count : integer;
begin (* Main *) writeln (‘Les dix premiers nombres Fibonacci sont:'); count := 0; Fibonacci1 := 0; Fibonacci2 := 1; repeat write (Fibonacci2:7); temp := Fibonacci2; Fibonacci2 := Fibonacci1 + Fibonacci2; Fibonacci1 := Temp; count := count + 1 until count = 10; writeln;end. (* Main *)
Les listes
CSI2520, Hiver 2007
type infoType = integer; list = ^listNode; listNode = record info: infoType; next: list end;
var l: list; i: infoType;
Insertion dans les listes (solution récursive)
CSI2520, Hiver 2007
procedure insert(var l: list; i: infoType);var k: list;begin if (l = nil) or (l^.info >= i) then begin new(k); k^.info := i; k^.next := l; l := k end else insert(l^.next, i)end; {insert}
Insertion dans les listes (solution récursive)
CSI2520, Hiver 2007
procedure insertI(var l: list; i: infoType);var k, j, h: list;begin new(k); k^.info := i; if (l = nil) or (l^.info >= i) then begin k^.next := l; l := k end
else begin j := l; h := l^.next; while (h <> nil) and (h^.info < i) do begin j := h; h := h^.next end; j^.next := k; k^.next := h endend; {insertI}
Afficher une liste
CSI2520, Hiver 2007
procedure printList(l: list; width: integer);begin if l <> nil then begin write(l^.info : width); printList(l^.next, width) end else writelnend; {printList}
Les listes
CSI2520, Hiver 2007
begin l := nil; insert(l, 20); insert(l, 5); insert(l, 30); insert(l, 10); insert(l, 8); insert(l, 30); insert(l, 25); printList(l, 3); printListI(l, 4);
l := nil; writeln('Enter integers, ending with 0: '); repeat read(i); insertI(l, i) until i = 0; printList(l, 5)end.
Arbres binaires
CSI2520, Hiver 2007
type Element = record Key: KeyType; end; BinarySearchTree = ^Component; Component = record Datum: Element; Left, Right: BinarySearchTree end;
Construire un arbre
CSI2520, Hiver 2007
function MakeEmptyBinarySearchTree: BinarySearchTree;begin MakeEmptyBinarySearchTree := nilend;
function MakeSingletonBinarySearchTree (Elm: Element): BinarySearchTree;var Result: BinarySearchTree;begin New (Result); Result^.Datum := Elm; Result^.Left := MakeEmptyBinarySearchTree; Result^.Right := MakeEmptyBinarySearchTree; MakeSingletonBinarySearchTree := Resultend;
function EmptyBinarySearchTree (B: BinarySearchTree): Boolean;begin EmptyBinarySearchTree := (B = nil)end;
Insertion dans un arbre
CSI2520, Hiver 2007
procedure InsertIntoBinarySearchTree (Elm: Element; var B: BinarySearchTree);begin if EmptyBinarySearchTree (B) then B := MakeSingletonBinarySearchTree (Elm) else if Elm.Key < B^.Datum.Key then InsertIntoBinarySearchTree (Elm, B^.Left) else InsertIntoBinarySearchTree (Elm, B^.Right)end;
Recherche dans un arbre
CSI2520, Hiver 2007
function SearchBinarySearchTree (Sought: KeyType; B: BinarySearchTree; var Found: Element): Boolean;begin if EmptyBinarySearchTree (B) then SearchBinarySearchTree := False else if Sought < B^.Datum.Key then SearchBinarySearchTree := SearchBinarySearchTree (Sought, B^.Left, Found) else if B^.Datum.Key < Sought then SearchBinarySearchTree := SearchBinarySearchTree (Sought, B^.Right, Found) else begin SearchBinarySearchTree := True; { because Sought = B^.Datum.Key } Found := B^.Datum endend;
Parcours d’un arbre
CSI2520, Hiver 2007
procedure PrintBinarySearchTreeData (B: BinarySearchTree);begin if not EmptyBinarySearchTree (B) then begin PrintBinarySearchTreeData (B^.Left); writeln (B^.Datum.Key); PrintBinarySearchTreeData (B^.Right) endend;
Retrait d’un élément
CSI2520, Hiver 2007
procedure DeleteFromBinarySearchTree (Sought: KeyType; var B: BinarySearchTree);var Delend: BinarySearchTree; { a spare pointer to the component to be recycled }
function DeleteLargest (var Site: BinarySearchTree): Element; var Delend: BinarySearchTree; { a spare pointer to the Component to be recycled } begin if EmptyBinarySearchTree (Site^.Right) then begin DeleteLargest := Site^.Datum; Delend := Site; Site := Site^.Left; Dispose (Delend) end else DeleteLargest := DeleteLargest (Site^.Right) end;
Retrait d’un élément
CSI2520, Hiver 2007
begin { procedure DeleteFromBinarySearchTree } if B <> nil then begin if Sought < B^.Datum.Key then DeleteFromBinarySearchTree (Sought, B^.Left) else if B^.Datum.Key < Sought then DeleteFromBinarySearchTree (Sought, B^.Right) else begin { we've found the datum to be deleted } if EmptyBinarySearchTree (B^.Left) then begin Delend := B; B := B^.Right; Dispose (Delend) end
else if EmptyBinarySearchTree (B^.Right) then begin Delend := B; B := B^.Left; Dispose (Delend) end else B^.Datum := DeleteLargest (B^.Left) end endend;
