Pascali põhitõed (1)

PASCAL
1. loeng.
Looja - N. Wirth, nimi B. Pascali (1623-62) järgi.
+ Üldotstarbeline, hästi õpitav ja õpetatav, head stiili
õpetav, kergesti loetavad programmid.
Struktuurprogrammeerimise klassikaline keel.
- Standardis puuduvad madaltaseme vahendid jms. ->
suhteliselt aeglane programm, arvutist "viimast võtta"
on raske/võimatu.
Enamlevinud IBM PC-tüüpi arvuteil (Turbo Pascal, Object
Pascal (Delphi) jm), kuid ka UNIX ja VAX süsteemides.
SUN-i Pascal (meie töövahend) - üldiselt standard-Pascal.
Märkus edasijõudnutele.
moodulitehnika ( UNIT ) sellisel kujul ei tööta.
andmetüübid - standardsed + string ja alpha.
(string - 255 sümbolit, alpha - 10 sümbolit )
Üldised juhised:
•programm koosneb lausetest. Iga lause on soovitav kirjutada eraldi
reale, rea lõpus vajutada -klahvi.
•Üldiselt iga lause lõpus semikoolon (;), esineb erandeid .
•Suur- ja väiketähed on erinevad märgid: 'A' ja 'a' on kaks ise asja.
Programmilaused (võtmesõnad) - program , begin , end, write jne - väike-
tähtedega, mujal võivad ka suured olla.
Pascal-programmi üldkuju:
program ;
type ;
var ;
begin
;
;
end.
Programmi kirjutamine OpenWindows-keskkonnas.
Meie kasutatavad arvutid on SUN-klassi tööjaamad (tööjaamaks nimetatakse
tüüpiliselt tavalisest personaalarvutist võimsamat arvutit).
Operatsioonisüsteemiks on Solaris UNIX, töökeskkonnaks OpenWindows.
Tüüpiline stardipilt:
Menüü e. käsurida
Command Tool
Text Editor
File Manager
Shell Tool
•avada Text Editor (hiireklõps tühjal ekraanil !)
kirjutada programmi tekst ekraanile .
valida File-menüüst käsk Save As...
panna vasakule ilmunud aknas oma programmile mingi nimi.
!!! Nime järele on soovitav kirjutada ka
laiend (tüübitunnus) .pas (näiteks pindala.pas).
klõpsata hiirega Shell Tool- aknasse .
käivitada Pascali translaator (programm, mis muudab meie kirjutatud
Pascal-keelse programmi arvutile arusaadavaks):
pc
N: pc pindala.pas pindala.out
!!! Soovitav on panna väljund- ehk tööprogrammi nime laiendiks mingi
kindel kolmetäheline kombinatsioon. Kasutada võib ka .EXE -laiendit
nagu PC-del, kuid kinnitamata andmetel võib põhjustada probleeme (arvuti
tõlgendab seda PC- failina !).
Väljundprogrammi nime võib ka ära jätta - arvuti paneb väljundi nimeks
a.out. EI SOOVITA, kuna nimi ei ütle midagi ja iga järgmine samasugune
transleerimine kirjutab selle üle.
Programminäide 1.
program Tervitus;
(* see asi siin on kommentaar - arvuti jätab sellised read *)
(* vahele, aga inimene saab nii programmi sisse märkusi teha. *)
var nimi : string;
vanus, aasta : integer ;
begin
write('Tere, mina olen Pascal. Mis Sinu nimi on? ');
readln(nimi);
write('Väga tore, ' , nimi , '. Aga kui vana Sa oled?');
readln(vanus);
aasta := 1995 - vanus;
writeln(nimi, ', Sa oled sündinud ' , aasta, ' . aastal.');
writeln('Head aega!');
end.
Programmis kasutatakse kolme muutujat - nimi, vanus,aasta.
Kõik muutujad tuleb deklareerida - määrata nende tüüp.
Standardses Pascalis esinevad sagedamini järgmised andmetüübid:
•integer - täisarv (-32 768 - 32 767)
• real - reaalarv (ca +/- 1040)
•string - tekst (kuni 255 märki) NB! Tegelikult ei kuulu päris
standardisse, aga enamik versioone toetab ka seda tüüpi.
• char - märk (1 suvaline täht, sümbol vms)
Mõned programmis esinevad tegevused:
Ekraanile väljastamine - write, writeln
a) teksti väljastamine - write ('soovitav tekst');
b) muutuja väärtuse väljastamine - write (muutuja nimi);
Mingi väärtuse sisestamine klaviatuurilt - read, readln
read(muutuja nimi);
ln-lõpp read'i või write'i järel - tööjärg uuele reale.
Väärtuse omistamine teisele muutujale - :=
•muutuja:=arv - arvväärtuse andmine muutujale
•muutuja1:=muutuja2- muutuja 2 väärtus kopeeritakse muutujasse 1
•muutuja:=muutuja + 3 - muutuja väärtust suurendatakse 3 võrra
PROOVIGE ISE:
•Küsida jalanumbrit ja leida, kui palju on elevandi omast väiksem
(elevandi jalg olgu näiteks nr. 75)
•Küsida pikkust ja kaalu ning leida ligikaudne ideaalkaal: 0,9 x
(pikkus - 100)
PASCAL
2. loeng
Struktuurne programm: kolm komponenti
a) jada: tegevus 1
tegevus 2
tegevus n
b) valik: kui
tegevus 1
vastasel juhul
tegevus 2
c) kordus: näit. tee seni, kui
korratavad tegevused
VALIK.
Variandid:
* mittetäielik kahendvalik
* täielik kahendvalik
* mitmendvalik
Enamikus programmeerimiskeeltes:
kahendvalik - IF-lause
mitmendvalik - CASE -lause
a) mittetäielik kahendvalik - kui toodud tingimus on täidetud,
täidetakse tingimuse järel olev lause, vastasel juhul aga ei tehta midagi.
if vanus to
b) eelkontrolliga kordus - kasutatakse teadmata korduste arvu puhul, kordusplokki täidetakse seni, kuni toodud tingimus on täidetud.
Enamikus keeltes WHILE - või DO WHILE-lause.
Üldkuju:
while do
begin
;
end;
NB! Ka siin toimivad BEGIN ja END n.ö. programmisulgudena.
c) järelkontrolliga kordus - sarnaneb eelmisega , kuid tingimuse täidetust kontrollitakse kordusploki lõpus ja kordusplokki täidetakse igal juhul vähemalt üks kord (WHILE puhul võib tingimus osutuda kohe mittetäidetuks ning seega ignoreeritakse kogu lauset).
Pascalis REPEAT .... UNTIL , teistes keeltes ka DO ... UNTIL jms.
Üldkuju:
repeat
until ;
PASCAL
3. loeng
Programminäide 4. (FOR-tsükkel)
program Fibonacci ;
(* Programm leiab Fibonacci arvud - arvujada , kus iga järgmine liige on *)
(* kahe eelmise liikme summa. Jada pikkuse määrab kasutaja. *)
(* N: 0,1,1,2,3,5,8,13,21,34 .... *)
var i, kordi , F_arv, esimene, teine : integer;
begin
write('Mitu Fibonacci arvu soovid leida? ');
readln(kordi);
esimene := 0; (* esimesed kaks arvu on teada - 0 ja 1 *)
teine := 1;
for i := 1 to kordi do (* i on abimuutuja, mis loendab kordusi *)
begin (* i muutub 1-st kuni 'kordi' väärtuseni *)
F_arv := esimene + teine;
write(F_arv, ', ');
esimene := teine; (* senine teine saab esimeseks... *)
teine := F_arv; (* ja senine F_arv teiseks liikmeks *)
end;
writeln;
writeln('See on kõik.');
end.
Programminäide 5. WHILE-tsükkel.
program Ruutjuur ;
(* Programm küsib kasutaja käest arvu ja väljastab selle ruutjuure. *)
(* Töötatakse seni, kuni kasutaja sisestab arvuks nulli. Kasutatakse *)
(* WHILE-kordust (eelkontrolliga). *)
var arv, juur : real;
begin
arv := 1;
writeln('Töö lõpetamiseks sisesta arvuks 0.');
while arv 0 do (* tee senikaua , kui arv ei ole 0 *)
begin
write('Sisesta arv: ');
readln(arv);
juur := sqrt(arv);
writeln(arv:7:2, ' ruutjuur on ' , juur);
end; (* WHILE-tsükli lõpp *)
writeln('See on kõik.');
end.
Programminäide 6. REPEAT-tsükkel.
program Ruutjuur2;
(* Programm küsib kasutaja käest arvu ja väljastab selle ruutjuure. *)
(* Töötatakse seni, kuni kasutaja sisestab arvuks nulli. Kasutatakse *)
(* REPEAT-kordust (järelkontrolliga). *)
var arv, juur : real;
begin
arv := 1;
writeln('Töö lõpetamiseks sisesta arvuks 0.');
repeat (* korda.... *)
write('Sisesta arv: ');
readln(arv);
juur := sqrt(arv);
writeln(arv:7:2, ' ruutjuur on ' , juur);
until arv=0; (* ... kuni arv on 0. tsükli lõpp *)
writeln('See on kõik.');
end.
MASSIIVID .
Muutuja võib sisaldada ainult üht väärtust ( N: pikkus := 3 tähendab, et
muutuja 'pikkus' sai väärtuseks 3). Tihti on aga tegemist paljude sarnaste
(samatüübiliste) andmetega , näiteks nimed, telefoninumbrid jms. Neist
igaühele eraldi muutuja defineerimine poleks otstarbekas.
Massiiv on andmete esitusviis, kus ühe muutujanime alla koondatakse palju
erinevaid, kuid samatüübilisi andmeid. Erinevatele massiivi elementidele
viitab massiivi indeks - sisuliselt järjekorranumber. Massiiv võib olla
ühe- või mitmemõõtmeline.
Vaatleme esmalt levinuimat varianti - ühemõõtmelist massiivi (vahel
nimetatakse ka vektoriks). See koosneb N samatüübilisest liikmest, mille
määramiseks kasutatakse järjekorranumbrit (sulgudes massiivinime järel).
N: nimed[4], arvud[2] === 4. nimi, 2. arv
Massiivi indeksiks võib olla ka muutuja - sel juhul on indeksi reaalseks
väärtuseks selle muutuja hetkeväärtus.
N: Kui muutuja i väärtus on 3, siis arvud[i] tähendab
massiivi 'arvud' 3. elementi.
Massiivid tuleb programmis deklareerida (defineerida) nagu muutujadki.
Tüübiks on aga mitte lihttüüp (integer, string, char jne), vaid üldkujul:
var massiiv : array [ 1.. ] of
on massiivi elementide arv (see võib olla ka suurem, kui reaalselt
vajaminev arv), on massiivi elementide tüüp.
N: var nimed : array [ 1 .. 10 ] of string;
programminäide 7.
program Fibonacci2;
(* Programm leiab Fibonacci arvud - arvujada, kus iga järgmine liige on *)
(* kahe eelmise liikme summa. Jada pikkuse määrab kasutaja. *)
(* N: 0,1,1,2,3,5,8,13,21,34 .... *)
(* Eelmisele näitele on lisatud arvude asetamine kuni 100 elemendiga *)
(* massiivi 'Fibonacci_arvud', mis lõpuks kontrolli mõttes samuti *)
(* väljastatakse. *)
var i, kordi, F_arv, esimene, teine : integer;
Fibonacci_arvud : array [ 1..100 ] of integer;
(* deklareerime 100- *)
(* elemendilise täisarvumassiivi *)
begin
write('Mitu Fibonacci arvu soovid leida? ');
readln(kordi);
esimene := 0; (* esimesed kaks arvu on teada - 0 ja 1 *)
teine := 1;
for i := 1 to kordi do (* i on abimuutuja, mis loendab kordusi *)
begin (* i muutub 1-st kuni 'kordi' väärtuseni *)
F_arv := esimene + teine;
write(F_arv, ', ');
Fibonacci_arvud[ i ] := F_arv; (* asetame arvu massiivi *)
(* kohale i *)
esimene := teine; (* senine teine saab esimeseks... *)
teine := F_arv; (* ja senine F_arv teiseks liikmeks *)
end;
writeln; (* lihtsalt tühi rida *)
writeln('See on kõik.');
writeln(' Kontrollväljastus massiivist: ');
for i := 1 to kordi do
write(Fibonacci_arvud[ i ];
writeln;
end.
Mitmemõõtmeliste massiivide korral sisaldab massiivielemendi "aadress"
mitut komadega eraldatud numbrit. Praktikas leiab laiemalt kasutamist vaid
kahemõõtmeline massiiv ehk tabel. Tabeli elemente määratakse rea- ja
veerunumbri järgi:
N: arvud[1,2] == tabeli (massiivi) "arvud" 1. rea 2. element.
Programminäide 8. Tabeli sisestamine ja väljastamine.
program tabel;
(* programm sisestab tabeli ja väljastab selle ekraanile *)
var RidadeArv, VeergudeArv : integer;
i, j : integer;
tabel : array[1..10,1..10] of integer; (* kuni 10 rida ja veergu *)
begin
(* kui suur tabel on? *)
write('Sisesta ridade arv: ');
readln(RidadeArv);
write('... ja veergude arv: ');
readln(VeergudeArv);
(* tabeli elementide sisestamine *)
for i := 1 to RidadeArv do (* tabeli puhul tüüpiline lahendus - *)
for j := 1 to VeergudeArv do (* kahekordne FOR-tsükkel *)
begin
write('Sisesta ' , i , ' . rea ' , j , ' . element: ');
readln( tabel[i,j]);
end;
(* tabeli väljastamine - NB! jälgi paigutust *)
for i := 1 to RidadeArv do
begin
for j := 1 to VeergudeArv do
write(tabel[i,j] : 4);
writeln;
end;
PROOVIGE ISE:
Programm, mis väljastab tavalise korrutustabeli 1 - 10. Kasutada kahe-
mõõtmelist massiivi (tabelit) ja kahekordset FOR-tsüklit.
3. ARVESTUSÜLESANNE:
Maatriksite liitmise programm (kasutaja sisestab maatriksite suurused
ja nende elemendid ning saab ekraanile summaarse maatriksi)
Põhiidee : Maatriks C = Maatriks A + Maatriks B ==
=== C[1,1] = A[1,1] + B[1,1], C[1,2] = A[1,2] + B[1,2] jne.
PASCAL 4. loeng.
FAILID.
FAIL üldmõistena on kettale salvestatud ühtne andmekogum . Mingi teksti-
dokument, tabel, graafiline kujutis jms. moodustavad kettale salvestatuna
igaüks mingi faili. Faili iseloomustavad nimi, laiend e. tunnus, suurus e.
maht (baitides) ja loomise aeg.
Pascali kontekstis räägitakse failide puhul enamasti andmefailidest.
Andmefail on mingi programmeerimisülesande puhul kas sisend - või väljund-
andmete hoiukoht. Näiteks võib Pascal-programm lugeda andmeid peale
klaviatuuri (tavaline readln-lause) ka failist või väljastada saadud
tulemused peale kuvari ka mingisse faili. Sisendfaili kasutamine võimaldab
käivitada üht programmi samade andmetega palju kordi (ei pea uuesti sises-
tama - näiteks tabeli puhul suur ajavõit). Väljundfail garanteerib saadud tulemuste säilimise.
Failist sisestamiseks (lugemiseks) ja faili väljastamiseks (kirjutamiseks)
kasutatakse samu lauseid , mida tavaliseks sisestuseks ja väljastuseks.
Lisandub vaid faili nimi:
read( , muutuja );
write( , muutuja );
N: read(andmed, vanus); ---> failist "andmed" loetakse väärtus ja pannakse
muutujasse "vanus".
write( ryhm , nimi); ---> faili "ryhm" kirjutatakse (lisatakse)
muutuja "nimi" väärtus.
Analoogiliselt tavaliste muutujate ja massiividega tuleb ka failid
deklareerida. Pascalis kasutatakse kaht liiki faile. Esimese liigina
vaatleme jadafaile.
Jadafail koosneb ühesugustest andmetest, mis paiknevad failis järjestikku
(tihti iga element eraldi real). Iga faili element aga võib sisaldada
mitut väärtust, näiteks võib programmirida
writeln(andmed, nimi,vanus,jalanumber);
väljastada faili "andmed" kolm väärtust ning faili üks element (rida) võib olla näiteks selline:
Albert 20 43 (nimi vanus ja jalanumber)
Pöördtehtena toimub eelmise rea lugemine failist nii:
readln(andmed, nimi, vanus, jalanumber)
Vastavalt muutuja "nimi" saab väärtuseks "Albert", "vanus" - 20 ja
"jalanumber" - 43
Jadafaili deklareerimine .
Deklareeritakse programmi var-osas, tüübiks pannakse TEXT.
N: var nimekiri : text;
NB!!! TEXT ei tähenda, et fail peab sisaldama ainult teksti. Ka arvandmeid
sisaldavad jadafailid deklareeritakse TEXT-tüübiga.
Lisaks deklareerimisele tuleb kasutatavad failid ka avada. Seda tehakse vastavalt RESET (lugemise või lisamise puhul) või REWRITE (uue faili loomise ja kirjutamise puhul) -lausetega.
Avamislauses sisaldub kaks failinime - loogiline ja füüsiline failinimi.
Loogiline failinimi on see, mida meie programm kasutab selle faili tähisena (nagu ülaltoodud "nimekiri"). Füüsiline failinimi väljendab kettal asuva reaalse infokogumi nime. Seega näiteks lause
Reset ( nimekiri , ‘nimekiri.dat’ );
avab lugemiseks (s.t. sisendfailina) faili, mis saab programmis nimeks "nimekiri" ja mille tegelik nimi kettal on "nimekiri.dat". Seega avamislause seab omavahel vastavusse loogilise (programmi-) ja füüsilise ( ketta -) faili.
Loogiline ja füüsiline nimi võivad ka täiesti erineda. Näiteks:
Rewrite ( andmed, ‘tabel.tab’ );
avab (täpsemalt loob) uue faili, mis salvestatakse kettale nime "tabel.tab" all, kuid millele programmis viidatakse nimega "andmed".
Programminäide 9. REPEAT-tsükkel + väljastamine faili.
program Ruutjuur3;
(*Programm küsib kasutaja käest arvu ja väljastab selle ruutjuure.*)
(*Töötatakse seni, kuni kasutaja sisestab arvuks nulli. Kasutatakse*)
(* REPEAT-kordust (järelkontrolliga). *)
(* Tulemused väljastatakse faili juured.dat . *)
var arv, juur : real;
juurefail : text;
begin
rewrite (juurefail, "juured.dat");
arv := 1;
writeln('Töö lõpetamiseks sisesta arvuks 0.');
repeat (* korda.... *)
write('Sisesta arv: ');
readln(arv);
juur := sqrt(arv);
writeln(arv:7:2, ' ruutjuur on ' , juur;7;2);
(*kirjutame kuvarile ... *)
writeln(juurefail, arv:7:2, ' ruutjuur on ' , juur:7:2);
(* ja faili ka. *)
until arv=0; (* ... kuni arv on 0. tsükli lõpp *)
writeln('See on kõik.');
end.
Programminäide 10. Loome faili ja sisestame rühma nimekirja.
program Nimekiri1;
(* Programm sisestab rühma nimekirja. Nimekirja lõppu *)
(* sisestada nime kohale " - " (kriips või miinus ) *)
var nimi : string;
nimefail : text;
begin
rewrite (nimefail, ‘nimekiri.dat’);
repeat
write ( ' Sisesta nimi: ' );
readln (nimi); (* loetakse nimi .... *)
write(nimefail, nimi); (* ... ja kirjutatakse nimefaili *)
until nimi = ' - ';
writeln('Ongi kõik.');
end.
Programminäide 11. Kasutame eelmise programmi faili.
program Nimekiri2;
(* programm väljastab rühma nimekirja *);
var nimi : string;
nimefail : text;
begin
reset (nimefail, ‘nimed.dat’);
writeln( ' Rühma OHOO-11 nimekiri : ' );
writeln( ' ----------------------------------- ' );
while not Eof( ) do (* tee kuni faili lõpuni *)
begin
read(nimefail, nimi);
writeln(nimi);
end;
end.
PROOVIGE ISE:
1. Lisage eelmisse näitesse programmiosa, mis kontrollib nimekirja mingi etteantud nime suhtes. Näiteks programm otsib isand Orumetsa ja ütleb
väljastamisel selle nime juurde "sai eksmati."
2. Proovige kombineerida eelmises harjutustunnis vaadeldud tabeliprogrammile (näide 8) faili sisestamise osa.
4. ARVESTUSÜLESANNE.
Metsandusfirma palkidearvestus. Eraldi väikese programmiga luua fail, mille igale reale sisestatakse ühe palgi pikkus ning kummagi otsa läbimõõt (oletame, et palk muutub ühtlaselt peenemaks, s.o. on tüvikoonuse kujuga).
Peaprogrammi ülesandeks on lugeda sisendfailist palkide andmed ning leidapalkide ruumala. Ruumalad tuleb väljastada teise faili, palkide kogu- ruumala aga väljastada ekraanile.
PASCAL, 5. loeng;
ALAMPROGRAMMID .
Seni vaadeldud programmid olid kõik n.ö. ühes tükis, kogu programm moodustas ühtse terviku. Enamiku reaalsete, suuremate programmeerimisülesannete juures ei ole selline lahendus otstarbekas, mõnel juhul isegi on see võimatu - kogu programm ei mahu tervikuna arvuti mällu. Programmi liigendamine väiksemateks autonoomseteks osadeks
- muudab enamasti programmi ülevaatlikumaks - lihtsam on lugeda
kümmet 20-realist kui üht 200-realist programmi
- kergendab rühmatööd (eri inimesed võivad tegeleda eraldi alam-
programmide loomisega , kooskõlastades vaid andmevahetuse )
- lihtsustab programmi muutmist ja uuesti transleerimist jne.
Programmi liigendamise võimalusi on mitmeid. Vaatleme esialgu variante , kus programm asub endiselt ühes failis, kuid erinevad alamtegevused on jaotatud erinevate alamprogrammide vahel. Alamprogrammide ja peaprogrammi vaheliseks andmevahetuseks kasutatakse parameetreid.
Näiteks on ringi pindala arvutava alamprogrammi sisendparameetriks (algandmeteks) ringi raadius, väljundparameetriks (tulemuseks) aga pindala.
Pascalis kasutatakse kaht liiki alamprogramme - protseduure ja funktsioone.
Mõlemad deklareeritakse (sisuliselt kirjutatakse valmis) programmi alguses peale var- osa. Seega on alamprogramme sisaldava programmi struktuur järgmine:
program ...
type ...
var ....
begin
....
alamprogrammide väljakutsed
....
end.
Alamprogrammi üldstruktuur on sarnane "päris" programmi omaga, kuid lõpus on punkti asemel semikoolon.
---------------- ---------------
------------>| |-----------> ----------->| | väärtus
sisend- | protseduur | väljund- sisend- | funktsioon | -------->
param-d | | param-d param-d | |
------------>| | -----------> ----------> | |
---------------- ---------------
Protseduuri ja funktsiooni deklareerimine.
Protseduur on alamprogramm, mida kasutatakse harilikult suuremate alam- ülesannete täitmiseks. Protseduuril võib olla palju nii sisend- kui väljund- andmeid (parameetreid). Protseduuri deklaratsioon on üldkujul selline:
procedure ( ; var );
var ....
begin
......
......
end;
Üldiselt võib öelda, et sulgudes on var-i ees sisend- ja järel väljundparameetrid. Tegelikult aga on var- parameetrid kahesuunalised - võivad olla nii sisendiks kui väljundiks.
Järgnev protseduur kasutab sisendandmetena kaht täisarvu a ja b ning annab väljundiks (mida võib kasutada ka teine protseduur sisendina) nende arvude summa ja korrutise.
procedure SumKor (a,b : integer; var Summa, Korrutis : integer);
(* muutujaid juurde pole vaja, var-osa jääb ära *)
begin
Summa := a+b;
Korrutis := a * b;
end;
NB! protseduuri või funktsiooni sees var-iga deklareeritud muutujad kehtivad ainult selle alamprogrammi piires!!!
Funktsiooni kasutatakse siis, kui on vaja leida mingit ühtainsat väärtust. Funktsiooni töö tulemus omistatakse sisuliselt funktsiooni enda nimele , seega peab funktsioonil olema kindel tüüp.
function ( ) : tüüp;
var ...
begin
....
:= ;
end;
Järgnev funktsioon arvutab ringi pindala. Leitud väärtus omistatakse funktsiooni enda nimele (Pindala).
function Pindala (r : integer) : real;
begin
Pindala := 3.141492 * r * r ;
end;
Alamprogrammide kasutamine (väljakutsumine).
Kui protseduur või funktsioon on programmi alguses valmis kirjutatud (deklareeritud), saame teda programmi tekstis kasutada. Näiteks ülaltoodud SumKor-i kasutamine programmis:
program Näide;
var esimene, teine, S, K : integer;
procedure SumKor (a,b : integer; var Summa, Korrutis : integer);
(* muutujaid juurde pole vaja, var-osa jääb ära *)
begin
Summa := a+b;
Korrutis := a * b;
end;
begin (* programmi algus *)
SumKor(esimene, teine, S,K); (* SumKor-i väljakutse *)
writeln ('Summa oli ',S:3, ', korrutis oli ', K:3);
end.
NB!!! Parameetrite puhul ei pea programmis kasutatavad muutujad olema samanimelised parameetritega (sama tüüpi aga küll).
Funktsiooni väljakutse erineb mõneti protseduuri omast, kuna tema töö tulemust esindab vaid üks muutuja. Näiteks funktsiooni Pindala saab kasutada nii:
program Näide;
var r1,r2 : integer;
S : real;
function Pindala (r : integer) : real;
begin
Pindala := 3.141492 * r * r ;
end;
begin
.....
S := Pindala( r1 ); (* S saab väärtuseks funktsiooni Pindala töö *)
(* tulemuse, kusjuures raadiuseks on muutuja *)
(* r1 reaalne väärtus. *)
......
writeln('Pindala on ', Pindala (r2) :3 ); (* Siin on Pindala nagu *)
(* tavaline arvmuutuja *)
end.
Programminäide 11. 3. näite protseduuriga variant.
program LeiaPindala;
(* Programm suudab arvutada ringi, täisnurkse kolmnurga või ruudu *)
(* pindala. Kasutaja ülesandeks on valida kujund ning anda lähteandmed *)
(* Arvutuste tegemine toimub protseduuriga ArvutaPindala. *)
var kujund : char;
a,b,S : real;
procedure ArvutaPindala (MisAsi : char; var pind : real);
(* sisend - kujundi liik, väljund : selle kujundi pindala *)
begin
case kujund of
'r' : begin
write('Sisesta ringi raadius');
readln(a);
S := 3.14 * a * a;
end;
'k' : begin
write('sisesta kolmnurga kaatetid - a, b (tühikud vahele): ');
readln(a,b);
S := (a * b) / 2:
end;
'u': begin
write('sisestage ruudu küljepikkus: ');
readln(a);
S := a * a;
end;
end;
end; (* protseduuri lõpp *)
begin (* Ja peaprogramm on nii jupike ... *)
writeln('Leiame kujundi pindala');
write('Kas kujund on ring (r), täisnurkne kolmnurk(k) või ruut (u)? ');
readln(kujund);
ArvutaPindala(kujund, S);
writeln ('Pindala on ',S:6:2);
end. (* peaprogrammi lõpp *)
Programminäide 12. Protseduur kasutab funktsiooni.
program Maksimum;
var n : integer;
mas : array [1..10] of integer;
procedure Sisesta;
(* n-i ja mas-i ei ole vaja parameetriteks panna, kuna need on deklaree- *)
(* ritud sama programmi deklaratsioonideosas. See lahendus aga teeb *)
(* meie protseduuri sõltuvaks konkreetsest programmist. *)
var i : integer; (* lokaalne muutuja, kehtib vaid protseduuris *)
begin
writeln('Mitu elementi on? ');
readln(n);
for i := 1 to n do
begin
writeln('Sisesta ' , i , '. element: ');
readln(mas[ i ]);
end;
end; (* Protseduuri lõpp *);
function MaxEl(massiiv : array [1..10] of integer; arv : integer ) : integer;
(* erinevalt eelmisest protseduurist on see funktsioon programmist *)
(* sõltumatu - teda võib samal kujul kasutada ka teises programmis *)
var i,suurim : integer;
begin
suurim := 0;
for i := 1 to n do
if massiiv [ i ] >suurim then
suurim := massiiv [ i ];
MaxEl := suurim ; (* Lõpuks omistame leitud arvu f-ninimele *)
end;
procedure Väljasta;
var i, suurim : integer;
begin
writeln('Massiiv oli : ');
for i := 1 to n do
write (mas [ i ] : 6 );
writeln;
suurim := MaxEl (mas);
writeln(' Maksimaalne element oli ', suurim : 4 );
end;
NB! Kui üks alamprogramm kasutab teist, peab teine alamprogramm olema deklareeritud esimesest eespool .
PROOVIGE ISE:
Kirjutage protseduur ja funktsioon (programmist sõltumatud), mis sisestavad tabeli (näit, 4 x 4) ja leiavad selle maksimaalse ja minimaalse elemendi.
5. ARVESTUSÜLESANNE:
Sama mis 4, kuid kasutada alamprogramme:
protseduurid Sisesta ja Väljasta
funktsioon LeiaRuumala