BitCell

Your IT power source

Skip to content


Tutorial Pascal - Lectia 5 - Subprograme (proceduri si functii)

Topic locked

Tutorial Pascal - Lectia 5 - Subprograme (proceduri si functii)

Postby DarkByte » 16 Jul 2010, 13:20

Tutorial Pascal



Subprograme (proceduri si functii)


Vi s-a intamplat sa aveti nevoie sa faceti un program si sa fie nevoie sa repetati o secventa de cod in mai multe locuri din program ? Probabil ca da, posibil ca nu.
Vi s-a intamplat sa aveti nevoie sa va ordonati codul in alt fel decat insiruirea liniilor una dupa alta, sa zicem ... dupa functionalitate ?

Pentru a usura aceste lucruri, Pascal ofera subprogramele: proceduri si functii. Pe scurt, acestea sunt parti de program care pot fi folosite apeland numele lor.

Proceduri


Sa vedem cum arata o structura generala a unei proceduri:
Line number On/Off | Expand/Contract | Select all
  1. procedure nume_procedura [(lista_parametri)];
  2.  
  3. CONST
  4.   (* declaratii de constante *)
  5.  
  6. VAR
  7.   (* declaratii de variabile *)
  8.  
  9. BEGIN
  10.   (* instructiuni *)
  11. END;


De remarcat ca, spre deosebire de structura unui program, end-ul de la sfarsit este finalizat cu ; (punct si virgula), nu cu . (punct). Lista de parametri este optionala, motiv pentru care este incadrata intre paranteze drepte. Ce inseamna parametri va fi explicat putin mai tarziu.

Sa vedem un program obisnuit folosind proceduri. Programul original (fara proceduri) ar fi urmatorul:
Line number On/Off | Expand/Contract | Select all
  1. var vector : array[1..200] of integer;
  2.     i, n: integer;
  3. begin
  4.   Write('Dati N: '); ReadLn(n); {N = numarul de elemente}
  5.  
  6.   i := 1; {*}
  7.   while (i <= N) do {citim elementele}
  8.     begin
  9.       Write('Dati elementul ', i, ': ');
  10.       ReadLn(vector[i]);
  11.       i := i + 1;
  12.     end;
  13.  
  14.   i := 1; {*}
  15.   while (i <= N) do {impartim fiecare element la 2 si salvam catul}
  16.     begin
  17.       vector[i] := vector[i] div 2;
  18.       i := i + 1;
  19.     end;
  20.  
  21.   Write('Vectorul modificat este : ');
  22.  
  23.   i := 1; {*}
  24.   while (i <= N) do {afisam noile valori din vector}
  25.     begin
  26.       Write(vector[i] : 5);
  27.       i := i + 1;
  28.     end;
  29.  
  30.   ReadLn; {asteptam sa fie apasat Enter}
  31. end.


Vedeti secventele marcate cu {*} ? Aceeasi instructiune, repetata de 3 ori... Bineinteles, intr-un program mai mare si mai stufos, secventele care se repeta contin mai multe instructiuni ... si probabil se repeta de mai multe ori.

Sa vedem cum rescriem programul folosind o procedura care sa faca acelasi lucru (sa initializeze variabila i cu 1).
Line number On/Off | Expand/Contract | Select all
  1. var vector : array[1..200] of integer;
  2.     i, n: integer;
  3.  
  4.   procedure Init;
  5.   begin
  6.     i := 1;
  7.   end;
  8.  
  9. begin
  10.   Write('Dati N: '); ReadLn(n); {N = numarul de elemente}
  11.  
  12.   Init; {*}
  13.   while (i <= N) do {citim elementele}
  14.     begin
  15.       Write('Dati elementul ', i, ': ');
  16.       ReadLn(vector[i]);
  17.       i := i + 1;
  18.     end;
  19.  
  20.   Init; {*}
  21.   while (i <= N) do {impartim fiecare element la 2 si salvam catul}
  22.     begin
  23.       vector[i] := vector[i] div 2;
  24.       i := i + 1;
  25.     end;
  26.  
  27.   Write('Vectorul modificat este : ');
  28.  
  29.   Init; {*}
  30.   while (i <= N) do {afisam noile valori din vector}
  31.     begin
  32.       Write(vector[i] : 5);
  33.       i := i + 1;
  34.     end;
  35.  
  36.   ReadLn; {asteptam sa fie apasat Enter}
  37. end.


Probabil ca acum va ganditi "Ce mare branza a rezolvat ? Numarul de linii este acum mai mare !". Da, asa e, dar asa cum am mentionat, acest program este doar un exemplu simplist.

In acest caz, variabila i este o variabila globala. Nu e declarata in niciun subprogram, ci direct in programul principal. Procedura Init o poate folosi fiindca variabila a fost declarata inaintea procedurii (daca erau declarate invers, compilatorul ar fi dat eroare spunand ca variabila folosita in procedura nu poate fi gasita).

Variabilele declarate in interiorul unui subprogram se numesc variabile locale.

Atentie: Variabilele globale si locale pot avea acelasi nume, lucru care poate duce la probleme in program.

Sa vedem un alt program care foloseste o procedura pentru a calcula factorialul unui numar (pentru cei care nu stiu, factorialul unui numar N este produsul lui 1 x 2 x ... x N).
Line number On/Off | Expand/Contract | Select all
  1. var i, n, f: integer;
  2.  
  3.   procedure Fact;
  4.   begin
  5.     f := 1;
  6.  
  7.     for i := 1 to n do
  8.       f := f * i;
  9.   end;
  10.  
  11. begin
  12.   Write('Dati N: '); ReadLn(n);
  13.  
  14.   Fact;
  15.   Write('Factorial de N este egal cu : ', f);
  16.  
  17.   ReadLn; {asteptam sa fie apasat Enter}
  18. end.


Destul de clar, cred. Sa trecem la ...

Functii


Functiile sunt foarte asemanatoare procedurilor, singura diferenta fiind faptul ca functiile pot intoarce un rezultat.

Sa vedem cum arata o structura generala a unei functii:
Line number On/Off | Expand/Contract | Select all
  1. function nume_functie [(lista_parametri)] : tip_rezultat;
  2.  
  3. CONST
  4.   (* declaratii de constante *)
  5.  
  6. VAR
  7.   (* declaratii de variabile *)
  8.  
  9. BEGIN
  10.   (* instructiuni *)
  11. END;


Haideti sa vedem cum ar putea arata un program care calculeaza factorialul unui numar, folosind o functie de data asta:
Line number On/Off | Expand/Contract | Select all
  1. var i, n, f: integer;
  2.  
  3.   function Fact: Longint;
  4.   var lFact: Longint; {variabila locala}
  5.   begin
  6.     lFact := 1;
  7.  
  8.     for i := 1 to n do
  9.       lFact := lFact * i;
  10.  
  11.     Fact := lFact; {am asignat rezultatul in numele functiei !}
  12.   end;
  13.  
  14. begin
  15.   Write('Dati N: '); ReadLn(n);
  16.  
  17.   F := Fact;
  18.   Write('Factorial de N este egal cu : ', f);
  19.  
  20.   ReadLn; {asteptam sa fie apasat Enter}
  21. end.


De data asta am asignat variabila F din afara subprogramului, si i-am dat valoarea rezultata din functie. Rezultatul functiei a fost setat asignand valoarea respectiva numelui functiei, in interiorul functiei.

Alta modificare este faptul ca folosim o variabila locala pentru a calcula factorialul. Acest lucru nu este strict necesar, l-am facut doar pentru a exemplifica rolul variabilelor locale.

Parametri


Sa vedem ce sunt parametrii si cum ii folosim in subprograme.

Lista de parametri este scrisa, practic, ca o lista de variabile. Parametrii pot fi scrisi in orice ordine sau pot fi grupati dupa tipul variabilelor.

Parametrii pot fi de doua tipuri, prin modul in care sunt folositi:
  • parametri prin valoare - acesti parametri pot fi modificati in interiorul subprogramului, dar modificarile nu sunt vizibile in exteriorul subprogramului.
  • parametri prin adresa - acesti parametri sunt, de fapt, adresele de memorie ale unor variabile deja declarate. Modificarile aduse unor astfel de parametri in interiorul unui subprogram vor fi vizibile in exterior.

Teoria ca teoria, dar hai sa vedem niste exemple :)
Line number On/Off | Expand/Contract | Select all
  1. var i, n, f: integer;
  2.  
  3.   function Fact(X: Integer): Longint; {X este un parametru transmis prin valoare}
  4.   var lFact: Longint; {variabila locala}
  5.   begin
  6.     lFact := 1;
  7.  
  8.     for i := 1 to X do
  9.       lFact := lFact * i;
  10.  
  11.     X := -1;
  12.     Fact := lFact; {am asignat rezultatul in numele functiei !}
  13.   end;
  14.  
  15. begin
  16.   Write('Dati N: '); ReadLn(n);
  17.  
  18.   F := Fact(N);
  19.   WriteLn('Factorial de N este egal cu : ', f);
  20.   WriteLn('Noua valoare a lui N este   : ', n);
  21.  
  22.   ReadLn; {asteptam sa fie apasat Enter}
  23. end.

Bun. Am calculat din nou factorialul, dar, de data aceasta, functia noastra Fact a primit un parametru prin valoare, pe care-l foloseste sa calculeze factorialul. Pe scurt, o data intrati in corpul functiei (care este apelata ca Fact(N), X este egal cu N. Ce vreau sa remarcati este faptul ca, desi am dat o noua valoare lui X in interiorul functiei, aceasta nu este transmisa inapoi lui N, dovada fiind faptul ca noua valoare a lui N (care este afisata) este aceeasi cu cea introdusa de la tastatura.

Din punctul de vedere al functiei si al metodei de lucru, admitand ca valoarea lui N era egala cu 5, puteam apela Fact(5). Numele generic al parametrului ("prin valoare") este dat tocmai din acest motiv: indiferent ca functia este apelata cu o constanta sau o variabila, doar valoarea ei este transmisa.

Sa vedem acelasi cod, singura diferenta fiind ca acum folosim un parametru prin adresa.
Line number On/Off | Expand/Contract | Select all
  1. var i, n, f: integer;
  2.  
  3.   function Fact(var X: Integer): Longint; {X este un parametru transmis prin adresa}
  4.   var lFact: Longint; {variabila locala}
  5.   begin
  6.     lFact := 1;
  7.  
  8.     for i := 1 to X do
  9.       lFact := lFact * i;
  10.  
  11.     X := -1;
  12.     Fact := lFact; {am asignat rezultatul in numele functiei !}
  13.   end;
  14.  
  15. begin
  16.   Write('Dati N: '); ReadLn(n);
  17.  
  18.   F := Fact(N);
  19.   WriteLn('Factorial de N este egal cu : ', f);
  20.   WriteLn('Noua valoare a lui N este   : ', n);
  21.  
  22.   ReadLn; {asteptam sa fie apasat Enter}
  23. end.


Faptul ca parametrul este transmis prin adresa este simbolizat de cuvantul var care-l precede. Programul afiseaza noua valoare a lui N, asa cum era de asteptat, egala cu -1, dovada ca variabila N a fost modificata in functie.

Diferenta principala intre parametrii transmisi prin valoare si cei transmisi prin adresa este faptul ca, in cazul celor transmisi prin valoare, variabila trimisa ca parametru este copiata intr-o zona de memorie temporara si trimisa functiei, ca si copie, in timp ce in cazul celor transmisi prin adresa variabila trimisa ajunge in functie neschimbata, ca original. Din acest motiv, transmiterea parametrilor prin adresa poate rapidiza executia programului (totusi, sa nu va asteptati la minuni - vorbim de milisecunde si chiar mai putin).

Atentie: Un subprogram poate avea o lista de parametri micsti: o parte dintre ei sa fie trimisi prin valoare, iar altii prin adresa. Tot ce conteaza este modul de declarare al listei.

De remarcat ca parametrii listati in headerul subprogramului se numesc parametri formali (X este un parametru formal in programul de mai sus), care sunt inlocuiti de parametri efectivi, in momentul apelului subprogramului (N este un parametru efectiv in programul de mai sus).

Atentie: Numarul, tipul si ordinea parametrilor efectivi trebuie sa corespunda cu numarul, tipul si ordinea parametrilor formali !

Vizibilitatea variabilelor


Dupa cum am explicat mai sus, se pot declara variabile in interiorul subprogramelor, chiar si cu nume de variabile care exista deja definite in programul principal. Problema care se ridica este urmatoarea : de unde stie compilatorul (si implicit, programatorul) care variabila va fi folosita in anumite zone ale programului ?

Nu trebuie sa va speriati, este foarte simplu si usor de inteles.

Variabilele globale ale programului sunt vizibile oriunde in program. Daca un subprogram isi defineste o variabila cu acelasi nume, atunci variabila locala e prioritara in acel subprogram (si in posibilele subprograme ale subprogramului !).

Sa vedem un exemplu.
Line number On/Off | Expand/Contract | Select all
  1. var i, n, f, lFact: integer;
  2.  
  3.   function Fact(X: Integer): Longint; {X este un parametru, transmis prin valoare}
  4.   var lFact: Longint; {variabila locala}
  5.   begin
  6.     lFact := 1;
  7.     WriteLn('lFact local  = ', lFact);
  8.  
  9.     for i := 1 to X do
  10.       lFact := lFact * i;
  11.  
  12.     X := -1;
  13.     Fact := lFact; {am asignat rezultatul in numele functiei !}
  14.   end;
  15.  
  16. begin
  17.   Write('Dati N: '); ReadLn(n);
  18.  
  19.   lFact := 157;
  20.   WriteLn('lFact global = ', lFact);
  21.  
  22.   F := Fact(N);
  23.   WriteLn('Factorial de N este egal cu : ', f);
  24.  
  25.   ReadLn; {asteptam sa fie apasat Enter}
  26. end.


Acest program va afisa urmatoarele linii (pentru N egal cu 5):
Line number On/Off | Expand/Contract | Select all
  1. Dati N: 5
  2. lFact global = 157
  3. lFact local  = 1
  4. Factorial de N este egal cu : 120


Recursivitate


Un lucru important de stiut, legat de subprograme, este ca ele sunt necesare daca vrem sa folosim recursivitate.

Un subprogram este recursiv daca in implementarea lui se apeleaza pe el insusi.

Recursivitatea poate fi un concept destul de greu de inteles, asa ca vom incepe cu un exemplu. Sa vedem cum rescriem functia care calculeaza factorialul, folosind recursivitatea.
Line number On/Off | Expand/Contract | Select all
  1. function Fact(X: Integer): Longint;
  2. begin
  3.   if X > 1
  4.     then Fact := Fact(X - 1) * X
  5.     else Fact := 1
  6. end;


Dupa se poate vedea, recursivitatea permite si formularea mai eleganta a solutiei.

Sa incercam sa intelegem ce se intampla. Factorial de N (notat si N!) este definit ca o inmultire succesiva a numerelor de la 1 la N (1 x 2 x ... x N). Din asta putem vedea ca N! este egal cu (N-1)! x N. La randul lui, (N-1)! = (N-2)! x (N-1) si asta poate continua, pana cand N este egal cu 1. Daca incercam sa calculam 1! folosind aceeasi relatie (adica 1! = 0! x 1) o sa cam dam gres, fiindca 0, inmultit cu orice numar, da 0.

Pe scurt, daca avem un caz initial caruia ii stim rezultatul, iar restul cazurilor se pot rezolva in functie de cazul initial, problema poate fi rezolvata recursiv. Cazul initial, pe functia de mai sus, este cazul in care X nu este mai mare decat 1 (adica este mai mic sau egal !), acest caz avand rezultatul 1. Pentru orice alta valoare pozitiva a lui X, rezolvarea se face in functie de X-1, pana cand X ajunge in cazul initial.

Ca urmare, aceste doua relatii de mai sus:
  • N! = (N-1)! x N
  • 1! = 1
sunt tot ce ne trebuie pentru a ne defini functia recursiva de calculare a factorialului.

Sa vedem ce se intampla, pas cu pas, pentru N egal cu 3.
Line number On/Off | Expand/Contract | Select all
  1. Fact(3)
  2. X = 3 -> apelam Fact(2) si inmultim cu 3
  3. X = 2 -> apelam Fact(1) si inmultim cu 2
  4. X = 1 -> 1, se termina functia, revenim in apelul precedent
  5. Fact = 1, care inmultit cu 2 este egal cu 2, revenim in apelul precedent
  6. Fact = 2, care inmultit cu 3 este egal cu 6, se termina functia si revenim in locul unde a fost initial apelata functia.


Deci, daca avem o problema care poate fi exprimata prin subprobleme ale ei si putem gasi o conditie de terminare a apelurilor recursive (in acest caz, X = 1), problema poate fi rezolvata printr-un subprogram recursiv.

Atentie: Apelurile recursive consuma relativ multa memorie. Daca o problema poate fi rezolvata iterativ (fara apeluri recursive), e de preferat (in general) ca problema sa fie rezolvata iterativ. O lista prea lunga de apeluri recursive poate genera "stack overflow" si bloca programul / calculatorul.

Pentru edificare, atasez acelasi program care calculeaza factorialul, modificat pentru a afisa ce se intampla. Sper sa va fie de ajutor, impreuna cu explicatiile de mai sus.

Codul sursa al programului:
Line number On/Off | Expand/Contract | Select all
  1. uses crt;
  2.  
  3. const lin = 9;
  4.       line = '-----------------------------------------------------------------';
  5.       Wait = 1000;
  6.  
  7. var i, n, f, lFact, test: longint;
  8.  
  9.   function Fact(X: Integer): Longint; {X este un parametru, transmis prin valoare}
  10.   begin
  11.     if X > 1
  12.       then
  13.         begin
  14.           WriteLn('Fact(', X, ') = Fact(', X - 1 ,') * ', X);
  15.           WriteLn(line);
  16.           Delay(Wait);
  17.  
  18.           Fact := Fact(X - 1) * X;
  19.           Delay(Wait);
  20.  
  21.           TextColor(LightGreen);
  22.           if Test > 0 then
  23.             Test := Test * X;
  24.           GotoXY(40, (N - X) * 2 + lin);
  25.           Write('Fact(', X,') = ', Test);
  26.         end
  27.       else
  28.         begin
  29.           TextColor(LightRed);
  30.           WriteLn('X = 1                                  ' +
  31.                   'Fact(1) = 1, caz initial !');
  32.           TextColor(LightGray);
  33.           WriteLn(line);
  34.           Delay(Wait);
  35.           WriteLn('Functia s-a terminat, revenim din apel ^^^');
  36.           Delay(Wait);
  37.           Fact := 1;
  38.           Test := 1;
  39.         end;
  40.   end;
  41.  
  42. begin
  43.   test := 0;
  44.   repeat {verificam daca 1 <= N <= 6}
  45.     ClrScr;
  46.     Write('Dati N (maxim 6): '); ReadLn(n);
  47.   until (N > 0) and (N < 7);
  48.   ClrScr;
  49.  
  50.   TextColor(LightRed);
  51.   GotoXY(Length(line) div 2 - 16 ,2);
  52.   WriteLn('Calculul factorialului - recursiv');
  53.   WriteLn(line);
  54.   WriteLn;
  55.   TextColor(LightGray);
  56.   WriteLn('Se apeleaza Fact(', N,') ...');
  57.   Delay(Wait);
  58.  
  59.   TextColor(lightGray);
  60.   GotoXY(1, lin);
  61.   F := Fact(N);
  62.  
  63.   Delay(Wait);
  64.   GotoXY(1, N * 2 + lin + 3);
  65.   TextColor(LightGray);
  66.  
  67.   Write('Fact(', N, ') este egal cu : ');
  68.   TextColor(LightGreen);
  69.   WriteLn(f);
  70.   TextColor(LightGray);
  71.   Write('... apasa orice tasta pentru a termina programul ...');
  72.  
  73.   While Keypressed Do
  74.     Readkey; {daca s-a apasat o tasta in timp ce programul rula,
  75.               va astepta totusi apasarea urmatoarei taste}
  76.   ReadKey;
  77. end.

Surse si executabil -

Screenshot din timpul rularii programului:
pascal factorial recursiv

7 points / 3 votes
Image

If you can't learn to do something well, learn to enjoy doing it poorly !
User avatar
DarkByte
Admin
 
Joined: 29 Dec 2009
Points: 71
Top
Topic locked

Return to Tutoriale Pascal

Who is online

Users browsing this forum: No registered users and 0 guests



Powered by phpBB © 2000, 2002, 2005, 2007 phpBB Group

phpBB SEO