TARTU ÜLIKOOLI
TEADUSKOOL PROGRAMMEERIMISE ALGKURSUS 2005-2006
Sisukord
KURSUSE TUTVUSTUS: Programmeerimise algkursus.........................................6
Kellele see algkursus on mõeldud?..................................................................6
Mida sellel kursusel ei õpetata?.......................................................................6
Mida selle kursusel õpetatakse?......................................................................6
Kuidas õppida?.................................................................................................7
Mis on
kompilaator ?.............................................................................................8
Milliseid kompilaatoreid kasutada ja kust neid saab?......................................8
Millist keelt valida?...........................................................................................8
ESIMENE TEEMA:
sissejuhatav sõnavõtt ehk 'milleks on vaja
programmeerimist?'..........................................................................................10
Programmeerimise koht muude maailma asjade seas...............................10
Masinad ja nende juhtimine...................................................................10
Masin arvutamise jaoks - arvuti .............................................................10
Kaudne juhtimine ehk
programmeerimine ............................................11
Arvutite
rakendusala laienemine ...........................................................11
Programmeerimine tänapäeval..............................................................12
Programmeerimiskeelte üldine jaotus .......................................................13
Imperatiivsed ehk käskivad keeled........................................................14
Funktsionaalsed keeled .........................................................................14
Loogilised keeled....................................................................................14
Esimese teema kokkuvõte.........................................................................15
TEINE TEEMA: PÕHIMÕISTED. OMISTAMISLAUSE. .............................................16
Sissejuhatus...............................................................................................16
Programmeerimise mõisted.......................................................................16
Algoritm ..................................................................................................16
Programmeerimiskeel.............................................................................17
Lause......................................................................................................18
Võtmesõna..............................................................................................18
Andmeobjekt..........................................................................................18
Identifikaator ..........................................................................................18
Andmetüüp.............................................................................................19
Väärtus...................................................................................................19
Konstant.................................................................................................19
Muutuja ..................................................................................................20
Andmemudel ..........................................................................................20
Arvutiga seotud mõisted............................................................................21
Protsessor ...............................................................................................21
Mälu........................................................................................................22
Välisseade..............................................................................................22
Omistamislause..........................................................................................22
Omistamislause
süntaks .........................................................................23
Omistamise olemus................................................................................23
Omistamislause keeles
Pascal ................................................................25
Omistamislause keeles C........................................................................25
Omistamislause keeles
Basic .................................................................25
KOLMAS TEEMA: aritmeetiline ja loogiline
avaldis .
Operand ja
operaator .........................................................................................26
2 / 115
Sissejuhatus...............................................................................................26
Avaldis........................................................................................................26
Operand ja operaator.............................................................................27
Aritmeetiline avaldis...............................................................................27
Loogiline avaldis.....................................................................................27
Ülevaade aritmeetilistest operaatoritest....................................................28
Aritmeetilised
operaatorid keeles Pascal................................................29
Aritmeetilised operaatorid keeles C.......................................................29
Aritmeetilised operaatorid keeles QBasic...............................................29
Ülevaade loogilistest operaatoritest..........................................................30
Loogilised operaatorid keeles Pascal......................................................30
Loogilised operaatorid keeles C..............................................................30
Loogilised operaatorid keeles QBasic.....................................................30
NELJAS TEEMA: standardprotseduurid andmete sisestamiseks ja väljastamiseks.
..........................................................................................................................31
Sissejuhatus...............................................................................................31
Standardprotseduurid andmete väljastamiseks.........................................33
Andmete väljastamise olemus...............................................................33
Andmete väljastamine keeles Pascal......................................................34
Andmete väljastamine keeles C.............................................................34
Andmete väljastamine keeles Qbasic.....................................................35
Standardprotseduurid andmete sisestamiseks..........................................35
Andmete sisestamise olemus.................................................................35
Andmete
sisestamine keeles Pascal.......................................................36
Andmete sisestamine keeles C...............................................................37
Andmete sisestamine keeles QBasic......................................................38
Väljundi vormistamine................................................................................38
Mis on väljundi vormistamine?...............................................................38
Väljundi vormistamise võimalused keeles Pascal...................................39
Väljundi vormistamise võimalused keeles C...........................................39
Väljundi vormistamise võimalused keeles QBasic..................................41
VIIES TEEMA:
tingimuslause . suunamislause. valikulause.................................42
Sissejuhatus...............................................................................................42
Tingimuslause............................................................................................42
Tingimuslause keeles Pascal..................................................................44
Tingimuslause keeles C..........................................................................46
Tingimuslause keeles Qbasic..................................................................47
Suunamislause...........................................................................................48
Suunamislause keeles Pascal.................................................................49
Suunamislause keeles C.........................................................................49
Suunamislause keeles Qbasic................................................................50
Valikulause.................................................................................................50
Valikulause keeles Pascal.......................................................................50
Valikulause keeles C...............................................................................51
Valikulause keeles Qbasic.......................................................................52
KUUES TEEMA: struktuursed andmetüübid: jada,
massiiv , kirje, fail. ...............54
Sissejuhatus ..............................................................................................54
Jada. Massiiv. Massiivi mõõtmed ...............................................................54
Massiivi
deklareerimine .............................................................................55
Massiivi deklareerimine keeles Pascal ...................................................55
3 / 115
Massiivi deklareerimine keeles C ...........................................................56
Massiivi deklareerimine keeles Qbasic ..................................................56
Massiivi kasutamine ..................................................................................57
Kirje ...........................................................................................................57
Kirje deklareerimine ..................................................................................58
Kirje deklareerimine keeles Pascal ........................................................58
Kirje deklareerimine keeles C ................................................................58
Kirje deklareerimine keeles Qbasic ........................................................59
Kirje kasutamine .......................................................................................59
Fail .............................................................................................................60
Faili deklareerimine ...................................................................................60
Faili kasutamine ........................................................................................61
SEITSMES TEEMA: määratud kordus. eelkontrolliga kordus. järelkontrolliga
kordus................................................................................................................63
Sissejuhatus...............................................................................................63
Määratud kordus........................................................................................63
Eelkontrolliga kordus..................................................................................64
Järelkontrolliga kordus................................................................................65
Korduslaused keeles Pascal........................................................................65
Korduslaused keeles C...............................................................................66
Korduslaused keeles Qbasic.......................................................................66
Korduslausete kasutamine.........................................................................67
KAHEKSAS TEEMA: viitmuutuja. arvuti mälu paindlik kasutamine.....................72
Sissejuhatus...............................................................................................72
Viitmuutuja olemus....................................................................................72
Viitmuutuja kasutamine.............................................................................73
Viitmuutuja kasutamine keeles Pascal.......................................................73
Viitmuutuja kasutamine keeles C...............................................................74
Mälu paindlik kasutamine..........................................................................75
Mälu
hõivamine ..........................................................................................75
Mälu vabastamine......................................................................................76
Tüüpilised komistuskivid.............................................................................77
Dünaamilised andmestruktuurid ................................................................77
Ahel ja
järjekord .........................................................................................78
Pinumälu ehk magasinmälu.......................................................................82
ÜHEKSAS TEEMA:
alamprogrammid .
protseduur ja funktsioon..........................86
Milleks on vaja alamprogramme?...............................................................86
Protseduuri ja funktsiooni erinevused........................................................86
Alamprogrammide kasutamine..................................................................87
Pascal.........................................................................................................87
C.................................................................................................................88
Qbasic........................................................................................................89
Parameeter ................................................................................................90
Globaalsed ja
lokaalsed muutujad.............................................................95
Ülevaade standardprotseduuridest ja -funktsioonidest .............................97
Pascal.........................................................................................................97
C.................................................................................................................99
Qbasic........................................................................................................99
KÜMNES TEEMA: Programmide vormistamine. ...............................................102
1. Milleks on vaja
programme hästi
vormistada ?.........................................102
4 / 115
2. Identifikaatorite süstematiseerimine. .....................................................103
3. Taanete kasutamine.............................................................................104
ÜHETEISTKÜMNES TEEMA: programmi
dokumenteerimine . kommentaarid....106
PROGRAMMI
PROJEKTEERIMINE JA
TESTIMINE ..............................................106
1. Kellele ja milleks on vaja dokumentatsiooni?.......................................106
KAHETEISTKÜMNES TEEMA: Struktuur- ja
objektorienteeritud programmeerimise
põhimõtted .....................................................................................................111
Sissejuhatus.................................................................................................111
Struktuurprogrammeerimine.......................................................................111
Objektorienteeritud programmeerimine......................................................112
Objekt, atribuut, meetod..........................................................................112
Klass.........................................................................................................113
Kapseldumine...........................................................................................113
Sündmused ja
teated ...............................................................................114
Pärilikkus ja polümorfism.........................................................................114
Mis on kasu objektorienteeritusest?.........................................................115
Objektorienteeritud maailm.....................................................................115
5 / 115
KURSUSE TUTVUSTUS: Programmeerimise
algkursusKellele see algkursus on mõeldud?
See algkursus on mõeldud eeskätt kooliõpilastele, kes tahaksid osata
arvutil programme kirjutada ja kellel ei ole õpetajat. Kuid muidugi võivad selle kursuse
materjale kasutada enesetäiendamiseks kõik, kes antud teema vastu huvi
tunnevad . Oodatud on nii
neiud kui ka
noormehed .
Kogu Teaduskooli informaatikakoolitus on jaotatud kolme taseme peale nii, et
• ESIMESEL tasemel (ehk alamastmes) õpitakse programmeerimise
põhitõdesid,
• TEISEL tasemel (ehk põhiastmes) mitmesuguseid vajaminevaid tehnikaid
ja algoritme ning
• KOLMANDAL tasemel (ehk ülemastmes) keskendutakse ülesannetele,
mille kallal murravad hambaid informaatika olümpiaadidest osavõtjad.
Niisiis on
käesolev kursus loodud selleks, et pakkuda õppematerjale kursuse
esimesel tasemel õppijatele, teise ja kolmanda taseme õppematerjale ja
ülesandeid
levitab TK algkursusele registreerunud ja selle TK juures lõpetanud
õpilastele. (Kui õpilane on algteadmised programmeerimisest
omandanud omal
käel, siis II
tasemele saab õppima
asuda üldistel alustel, vaata TK infolehte.)
Mida sellel kursusel ei õpetata?
Loomulikult ei õpetata selle kursuse raames midagi, mis ei ole
teemaga kuidagiviisi seotud (kokakunst on küll seotud algoritmidega, aga jääb siiski
arvutitest kaugele - vähemalt esialgu). Samuti ei süveneta arvutiga
seonduvatesse (programmi-) tehnilistesse probleemidesse, nagu
operatsioonisüsteemi madalama taseme funktsioonid ja muu
sedasorti 'maagia'.
Mida selle kursusel õpetatakse?
Esimese astme materjalid on jaotatud
12-ks teemaks, millest üheksaga
kaasnevad ülesanded harjutamiseks. Nendeks teemadeks on:
1. Suurem sissejuhatav sõnavõtt ehk 'Milleks on vaja programmeerimist?'
2. Põhimõisted: andmetüüp, väärtus, konstant, muutuja, identifikaator,
võtmesõna, operand, operaator. Omistamise lause.
3. Aritmeetiline ja loogiline avaldis.
4. Standardprotseduurid andmete sisestamiseks ja väljastamiseks.
5. Tingimuslause. Suunamislause. Valiklause.
6. Struktuursed andmetüübid: jada, massiiv, kirje, fail.
7. Määratud kordus. Eelkontrolliga kordus. Järelkontrolliga kordus.
8. Viitmuutuja. Arvuti mälu paindlik kasutamine.
6 / 115
9. Alamprogrammid. Protseduur ja funktsioon.
10.Programmide vormistamine. Identifikaatorite süstematiseerimine.
Taanete kasutamine.
11.Programmi dokumenteerimine. Kommentaarid. Programmi
projekteerimine. Programmi testimine.
12.Struktuurprogrammeerimise põhimõtted. Objektorienteeritud
programmeerimise põhimõtted.
Kui mõni eelmistest pealkirjadest jäi arusaamatuks, siis pole põhjust
muretsemiseks. Kõiki neid mõisteid õpite tundma selle kursuse käigus.
Esimesel tasemel kasutatakse näidetes samaaegselt kolme programmeerimise
keelt, milleks on
Pascal,
C (ja
Basic). Siinkohal tahaks rõhutada, et
antud
kursuse eesmärgiks ei ole mitte programmeerimiskeele täiuslik
omandamine, vaid programmeerimise oskuse omandamine - need
kaks oskust on erinevad! Samuti on kursuse materjalidesse peidetud soov
näidata, et
samasse klassi kuuluvad programmeerimiskeeled on oma
olemuselt samasugused.
Kuidas õppida?
Siinkohal saan ma jagada ainult järgmiseid
soovitusi :
• Õpi sammhaaval,
teemasid numeratsiooni järjekorras läbides.
• Püüa aru saada kirjutatu mõttest - ilma arusaamiseta ei ole kõigel sellel
mõtet. ;-)
• Püüa läbi lahendada kõik teemaga kaasa antud kodused ülesanded. Need
leiad ülesannete lehelt.
• Kui tekib
küsimusi , siis küsi julgesti.
Küsimusi võib saata juhendajale. Tema hoolitseb selle eest, et need küsimused
ka vastuse saaksid.
Kui
• Sulle antud
temaatika meeldib,
• kõik teemad on läbi loetud ja selged,
• ülesanded
lahendatud ja küsimusi ei ole ning
• Sa
tahad saada süvendatud õpetust,
siis on sul võimalus registreerida end Teaduskoolis programmeerimise
kursusele "Programmeerimise alused I".
Viimane
sisuline muudatus on tehtud 17.08.2004.a.
Õppematerjalid pani kokku Indrek Jentson.
Muutnud, parandanud, täiendanud Avo Muromägi.7 / 115
Mis on kompilaator?
Kompilaator on spetsiaalne programm, mis teeb programmi lähtekoodi
operatsioonisüsteemile arusaadavaks. Programmi lähtekood on aga see, mille
kirjutab
programmeerija . Teie vajate kompilaatorit just selleks, et oma
programme käivitada (
vaevalt keegi viitsib väga kaua programmeerimisega
tegeleda, kui ta ei saa näha, kuidas see, mis ta teinud on, tegelikult töötab).
Milliseid kompilaatoreid kasutada ja kust neid saab?
Kuna kompilaatorid võivad üksteisest pisut erineda, siis on
soovitav kasutada
samu kompilaatoreid, mida on kasutatud kursuse koostamisel (vastasel juhul
võib tunduda, et õppematerjalides pakutav näidisprogramm tegelikult ei
töötagi).
Kõik
Pascali programmid on kirjutatud FreePascalis, mistõttu neile, kes
otsustavad ülesannete lahendamiseks Pascalit kasutada, soovitan kasutada
just seda. FreePascali puhul on tegemist vabavaraga, mistõttu
võite ta muretult
alla
laadida . Kaasa saate ka keskkonna, kus on suhteliselt mugav Pascali
programme kirjutada, kuid kuna tegemist on vabavaraga ja keskkond ise on
alles arendusjärgus, siis pole ta päris töökindel.
Kõik C programmid on kirjutatud Dev-C++'s, mistõttu neile, kes otsustavad
ülesannete lahendamiseks kasutada keelt C, soovitan kasutada just Dev-C++.
Ka selle programmi puhul on tegemist vabavaraga ning ka tema
kasutajaliides pole 100% töökindel, kuid vähemalt minul pole ei Dev-C++, ega ka FreePascali
viimaste versioonidega
suuremaid probleeme olnud.
Muuseas Dev-C++
kasutajaliides on kirjutatud
Delphis (Delphi puhul on aga tegemist tegelikult
Pascaliga).
Millist keelt valida?
Teil on valida kahe keele vahel: C või Pascal (kuigi kursus sisaldab ka materjale
Basicu kohta tuleks esitatavates lahendustest kasutada kas C-d või Pascalit).
Miks? Näiteks kaheksandat
kodutööd polegi võimalik Basicus lahendada, kuna
õppematerjalides puuduvad vastavad näited keeles Basic. Näidete puudumine
on aga põhjustatud sellest, et keeles Basic puuduvad vastavad vahendid,
mistõttu polegi võimalik näiteid kirjutada. Lisaks sellele on Basicul veel
miinuseid (eriti programmeerimisega alustajate jaoks), mistõttu seda me teil
õppimiseks valida ei soovita. Basic on lisatud kursusesse rohkem silmaringi
laiendamiseks.
Kuidas valida C ja Pascali vahel? Mõlemal keelel on oma eelised. Algajatele
sobib Pascal oma lihtsuse ja inglise keele sarnasusele
kahtlemata paremini.
Lisaks sellele on ta teatud ülesannete lahendamiseks mugavam (
mõningaid nendest eelistest näete ka selle kursuse jooksul), kui C-s. Samas on C-s
kirjutatud programmid sageli kiiremad ja loomulikult on C-l olemas ka teisi
eeliseid . Näiteks on
ekraanil väljundi vormistamine mõnevõrra mugavam
8 / 115
(samas nõuab see märksa rohkem õppimist). C suurimaks
eeliseks võib lugeda
ilmselt asjaolu, et mitmed levinud keeled on sarnased pigem C, kui Pascaliga
(näiteks
Java , PHP) mistõttu õppides ära Pascali peate te varem või hiljem
õppima ka C-d (kuid see saab olema oluliselt kergem, kui kohe C õppimine).
Samas peaks iga endast lugupidav programmeerija oskama nii C-d kui ka
Pascalit.
9 / 115
ESIMENE TEEMA: sissejuhatav sõnavõtt ehk
'milleks on vaja programmeerimist?'Programmeerimise koht muude maailma asjade seasMasinad ja nende juhtimine
Oli kord aeg, mil inimene tegi tööd vaid käsitsi. Ta võttis küll kasutusele
töövahendid oma töö kergendamiseks, kuid
tänapäevases mõttes tegi ta tööd
ikkagi käsitsi. Mõningate jõudu nõudvate tööde tegemiseks hakkas ta kasutama
loomi, hiljem masinaid, kuid ilma inimese juuresolekuta saadi hakkama vaid
väga vähestes kohtades - nii loomad kui ka masinad vajasid juhtimist.
Kujutame seda järgneva joonisega:
--------- juhtimine -----------
| Masin | 10 -> C
------------------------------------------------------------------
Sellest tabelist võib näha, et konstandi väärtuse omistamisel muutujale
kirjutatakse väärtus 10 muutujanimega
A tähistatud mälupesa(de)sse. Muutuja
väärtuse omistamisel teisele muutujale toimub esiteks väärtuse 10 lugemine
muutujanimega
A tähistatud mälupesa(de)st ja seejärel selle väärtuse
kirjutamine muutujanimega
B tähistatud mälupesa(de)sse. See on sellise
protsessi tegelik kirjeldus. Edaspidi räägime ainult, et "
muutuja A väärtus
omistatakse muutujale B".
Kellele see jutt ikkagi segasena tundus, sellel soovitan kodus mängida
järgmiste reeglite järgi:
1.
muutujaks on tühi tikutops;
2.
muutuja nimeks on tikutopsile peale kirjutatud täht või nimi;
3.
väärtuseks on selline paberitükk, mis
mahub tikutopsi ja mille peal on
vastav arv;
4. tikutopsis tohib
korraga olla
vaid üks paberitükk;
5. muutujale
väärtuse omistamine on samaväärne
tegevusega , kus
vastava arvuga paberitükk asetatakse tikutopsi, kuid vastavalt reeglile
(4) võetakse sealt
eelmine paberitükk välja (kui see seal oli);
6. muutujast
väärtuse lugemine on samaväärne ühe uue paberitüki
võtmisega ja sinna muutujaga samasuguse väärtuse peale kirjutamisega.
24 / 115
Tehes täpselt nende reeglite järgi, saate Te modelleerida operatsioone
muutujatega ilma otseselt arvutit kasutamata. Ja ärge unustage, et kui
mänguruum hakkab
kitsaks jääma , siis võite ju endale uue muutuja
deklareerida (kui muidugi tikutopsid otsas ei ole ;-).
Omistamislause keeles Pascal
Keeles
Pascal on omistamislause süntaks järgmine:
':='
Et eristada üksteisele järgnevaid
lauseid , pannakse nende vahele semikoolon
';', välja arvates mõned
erijuhud . Eelnev näide keeles
Pascal näeb välja
niisugune:
A := 10;
B := A;
C := A;
Omistamislause keeles C
Keeles
C on omistamislause süntaks järgmine:
'=' ';'
Eelnev näide keeles
C näeb välja niisugune:
A = 10;
B = A;
C = A;
Omistamislause keeles Basic
Et programmeerimiskeeli, mille nimes esineb sõna "Basic" on suhteliselt palju
ja süntaksi poolest pisut erinevaid, siis valisin välja ühe sellise, mida levitatakse
koos operatsioonisüsteemiga
MS-DOS 6.2 ja selle nimi on
MS-DOS QBasic 1.1.
Samasugust süntaksit kasutab ka
Visual Basic.
Keeles
QBasic on omistamislause süntaks järgmine:
[
'LET' ]
'='
Nurksulud eelnevas definitsioonis tähendavad, et nurksulgude vahel olevad
sümbolid võib ära jätta, need ei ole kohustuslikud.
Eelnev näide keeles
QBasic näeb välja niisugune:
A = 10
B = A
C = A
Selle peatüki materjalide peale on "Kodutöö nr. 2"
25 / 115
KOLMAS TEEMA: aritmeetiline ja loogiline
avaldis.
Operand ja operaator.Sissejuhatus
Kui Te olete edukalt omandanud meie kursuse kaks esimest teemat, siis olete
poolel teel
eesmärgini . See tähendab, et kõige raskem osa programmeerimise
õppimisel - muutuja mõistest arusaamine - on juba seljataga. Edasised
teadmised saavad Teile
tugevaks toeks , aga Te olete
niiöelda püsti tõusnud ja
liikuma hakanud.
Eelmises teemas omistamislause süntaksi defineerimisel
kasutasin ma mõistet
'
avaldis' ja lihtsuse mõttes
vaatasin seda kui ühte muutujat või konstanti.
Sellega tahtsin ma keskendada tähelepanu
esmajoones omistamise tegevusele
ja jätta
avaldise tegelik sisu meie järgmise (ehk käesoleva) kokkusaamise
jaoks.
Avaldis
Me kõik oleme koolis
õppinud matemaatikat ja teame, et
arvudega saab teha
tehteid ja kui tuleb lahendada üht mitme
tehtega ülesannet ehk leida
matemaatilise avaldise väärtust, siis tuleb arvestada
tehete järjekorda jne. Kõik
see teadmine kehtib ka programmeerimises
kasutatava avaldise juures.
Mis on
siis avaldis?
AVALDIS on väärtuse leidmise eeskiri , mis moodustatakse
operandidest ja operaatoritest ning nende grupeerimiseks
kasutatakse sulgusid.
Kui matemaatikas vajaduse korral on lubatud ja lausa soovitatav esitada
avaldisi "
mitmekorruselistena", siis programmeerimiskeeltes tuleb kõik
avaldised paigutada järjestikku. Toome mõned näited (
püüdke vasakpoolsest
kirjaviisist õigesti aru saada ;-) :
a
- c ==> a/b*c
või (a/b)*c
b
a + b + c
--------- ==> (a+b+c)/2
2
ad + bc
------- ==> (a*d+b*c)/(b*d)
bd
/------
26 / 115
\ / 2 2
\/ a + b ==>
sqrt (a^2+b^2)
Operand ja operaator
Avaldise väärtuse leidmise puhul tuleb meil tihti rääkida tehete ehk
operatsioonide sooritamisest. Sellest tuleneb ka kaks uut mõistet - operand ja
operaator. OPERAATOR on see, kes või mis sooritab talle spetsiifilise
operatsiooni. OPERAND on see väärtus, millega operaator oma operatsiooni
sooritab.
Matemaatikas on üheks tuntumaks operaatoriks plussmärk ehk
liitmisoperaator . Nii nagu nimigi ütleb, on plussmärgi tegevuseks kahe väärtuse
kokkuliitmine. Me ütleme "kaks pluss kolm on viis" ja mõistame selle lause all
seda, et kui liita kokku väärtused 2 ja 3, siis tulemuseks saame väärtuse 5.
Plussmärgi ja liitmisoperaatori samastamine tuleneb meie kooliharidusest. Kui
õpetaja koolis
esimesest klassist alates õpetaks, et pluss tähistab kahe arvu
kõrvutiasetamist ehk "2 + 3 on 23", siis kooli lõpetades te selle peale enam ei
mõtleks ja võtaksite seda kui iseenesest mõistetavat tõsiasja.
Liitmisoperaatorit võib kujutada ka
funktsioonina LIIDA(a,b). Siis on täiesti
samaväärne, kas me kirjutame
1 + 2 + 3
või
LIIDA(1, LIIDA(2,3)),
tulemuseks on mõlemal juhul väärtus 6 (funktsiooni LIIDA väärtus arvude 2 ja 3
puhul on 5).
Operaatoreid on mitmesuguseid. Meile tuntumad on operaatorid, mis nõuavad
kahe operandi olemasolu. Esineb ka ühe operandiga operaatoreid. Näiteks
arvu
astendamise operaator on kahe operandiga ( 2^10 ), arvu
märgi muutmise
operaator aga ühe operandiga ( -5 ). Eelmises teemas
käsitletud omistamise
märk on ka operaatori tunnustega. Seda võib nimetada omistamisoperaatoriks,
mille tegevuseks on avaldise väärtuse kirjutamine muutujasse.
Programmeerimiskeeltes eristatakse kahte liiki avaldisi -
aritmeetilisi avaldisi,
mille tulemuse väärtuseks on arv ja
loogilisi avaldisi, mille tulemuseks on
tõeväärtus.
Aritmeetiline avaldis
Aritmeetilises avaldises kasutatakse eeskätt arvutüüpi andmeobjekte ja
aritmeetilisi
tehtemärke . Ka võib aritmeetilises avaldises kasutada arvutüüpi
funktsioone. Kõik
eespool toodud näited
avaldiste kohta on olnud aritmeetilised
avaldised.
Loogiline avaldis
Loogiline avaldis sisaldab ühte või enamat loogilist
operaatorit ja võib tihti
sisaldada aritmeetilisi avaldisi. Matemaatikast tuntud loogiline avaldis on
27 / 115
võrratus , mille puhul on tulemuseks samuti tõeväärtus:
2 tõene
2 = 8 ==> väär
x + 3 > 10 ==> tõene, kui x >= 8, muidu väär
Lisaks operaatoritele, mida kasutatakse operandide võrdlemiseks, on loogilistes
avaldistes kasutusel loogikatehted
JA (
loogiline korrutamine ehk
konjunktsioon ),
VÕI (
loogiline liitmine ehk
disjunktsioon ),
POLE (
loogiline eitus
ehk
negatsioon) ja mõned teised. Need
tehted jäävad kahjuks väljapoole meie
koolide
matemaatika programmi, kuid programmeerimine ilma neid
kasutamata läbi ei saa. Loogikatehetest saab kõige paremini aru, kui õppida
selgeks vastavad
tõeväärtustabelid (
analoogia korrutustabeliga, see tuli ka
pähe õppida):
JA | tõene | väär |
Selgituseks :
------################# (tõene JA tõene) on tõene
tõene # tõene | väär # (tõene JA väär) on väär
------#-------+-------# (väär JA tõene) on väär
väär # väär | väär # (väär JA väär) on väär
------#################
VÕI | tõene | väär | Selgituseks:
------################# (tõene VÕI tõene) on tõene
tõene # tõene | tõene # (tõene VÕI väär) on tõene
------#-------+-------# (väär VÕI tõene) on tõene
väär # tõene | väär # (väär VÕI väär) on väär
------#################
POLE | tõene | väär | Selgituseks:
------################# (POLE tõene) on väär
# väär | tõene # (POLE väär) on tõene
------#################
Seega, loogiline avaldis kujul
(A 10)
on tõene ainult siis, kui mõlemad tingimused on tõesed.
Ülevaade aritmeetilistest operaatoritest
Alljärgnevalt teen ma väikese ülevaate aritmeetilistest operatsioonidest. See
ülevaade ei ole kaugeltki täielik, kuid see ei olegi antud juhul eesmärgiks.
Operatsioonid on järgnevas tabelis esitatud
prioriteedi (tehete järjekorra
tähtsuse)
kahanemise järjekorras. See tähendab, et märgi muutmine tehakse
alati enne kui
astendamine või korrutamine ja korrutamine omakorda eelneb
liitmisele või lahutamisele.
Sellest tulenevalt on avaldise 2 + 7 * 3 väärtuseks 23 mitte 27.
Operatsiooni nimetus | operandi tüüp | tulemuse tüüp | operande
------------------------+------------------+---------------------+---------
märgi muutmine |
täisarv ,
reaalarv | sama, mis operandil | 1
astendamine | täisarv,reaalarv | sama, mis operandil | 2
korrutamine | täisarv,reaalarv | sama, mis operandil | 2
28 / 115
jagamine | täisarv,reaalarv | sama, mis operandil | 2
täisarvuline jagamine | täisarv | täisarv | 2
jagamise jäägi leidmine | täisarv | täisarv | 2
nihutamine paremale | täisarv | täisarv | 2
nihutamine vasakule | täisarv | täisarv | 2
liitmine | täisarv,reaalarv | sama, mis operandil | 2
lahutamine | täisarv,reaalarv | sama, mis operandil | 2
Kui operatsioonist võtavad osa nii
täisarvud kui ka
reaalarvud , siis harilikult on
tulemuseks reaalarv.
Aritmeetilised operaatorid keeles Pascal
Operatsiooni nimetus | operandi tähis
------------------------+---------------
märgi muutmine | -
astendamine | puudub, kasutatakse funktsioone: sqr(x)=>x
ruudus korrutamine | *
jagamine | /
täisarvuline jagamine | DIV ; nt ((5 div 2) = 2), ((4 div 2) = 2)
jagamise jäägi leidmine | MOD
nihutamine paremale | SHR ; (5 SHR 1) on sama, kui (5 DIV 2)
nihutamine vasakule | SHL ; (5 SHL 1) on sama, kui (5 * 2)
liitmine | +
lahutamine | -
Aritmeetilised operaatorid keeles C
Operatsiooni nimetus | operandi tähis
------------------------+---------------
märgi muutmine | -
astendamine | puudub, kasutatakse funktsiooni: pow(x,y)
korrutamine | *
jagamine | /
täisarvuline jagamine | /
jagamise jäägi leidmine | %
nihutamine paremale | >>
nihutamine vasakule | =
väiksem kui | =
väiksem kui | =
väiksem kui | 12,5%.
Nende andmete põhjal kirjutame võrrandi, kus küsitud koguse
tähistame tähega K:
K 100
--- = ---- ehk (K/350)=(100/12,5).
350 12,5
Sellest võrrandist avaldame K:
K = (100/12,5)*350 = 2800.
31 / 115
Seega on konkreetse ülesande vastus 2800 tonni.
Ja kus on siin programmeerimine? Asi on nimelt selles, et
arvuti ei ole
võimeline sellist ülesannet lahendama. Küll aga on arvuti võimeline
etteantud programmi alusel arvutusi tegema. Seega antud ülesannet lahendav
programm oleks järgmine:
P r o g r a m m N1.1K = (100/12.5)*350
VÄLJASTA K
Või saab kasutada ka üherealist programmi:
P r o g r a m m N1.2VÄLJASTA (100/12.5)*350
Seega,
Teie lahendate ülesannet, arvuti teostab arvutused - selline on
tööjaotus . Selles väikeses üherealises
programmis tähistab sõna 'VÄLJASTA'
standardprotseduuri sellele sõnale järgneva väärtuse väljastamiseks
väljundseadmele.
Täiesti kohane on küsimus, et milleks on vaja sellist programmi, mis lahendab
ainult üht konkreetset ülesannet?
Õigustatud on selline programm siis, kui kalkulaatorit pole
käepärast ja peast
arvutada ei viitsi. Palju kasulikum on aga selline programm, mis lahendab selle
ülesande kõikvõimalikke
variante , see tähendab ülesannet, mille
sõnastus võiks olla järgmine:
NÄIDE 2.
Ü l e s a n n eSaadava suhkru mass moodustab
P % töödeldava suhkrupeedi
kogusest. Kui palju on vaja suhkrupeeti
X tonni suhkru saamiseks?
L a h e n d u sAvaldame
K analoogiliselt eelmisele näitele:
K = (100/P)*X
Selleks, et leida suurus
K, on meil vaja teada suurusi
P ja
X.
Programmeerimise kontekstis öelduna tähendab see seda, et
muutuja K väärtuse leidmiseks on meil tarvis omistada
muutujatele
P ja
X väärtused. Eelmise näitega samaväärse programmi saame, kui
omistame neile
muutujatele eelmises ülesandes püstitatud
väärtused:
P r o g r a m m N2.1P = 12.5
X = 350
K = (100/P)*X
VÄLJASTA K
32 / 115
Lisaks omistamislausele leidub veel teinegi võimalus muutujale väärtuse
omistamiseks - see on
väärtuse sisestamine standardprotseduuri abil.
Tähistame sellist protseduuri sõnaga '
SISESTA ' ja kirjutame programmi, mis
aitab meil lahendada kõiki teise näite alla kuuluvaid ülesandeid:
P r o g r a m m N2.2SISESTA P
SISESTA X
K = (100/P)*X
VÄLJASTA K
Standardprotseduur 'SISESTA' töötab harilikult järgmise
algoritmi järgi:
1. Loeme kokku klaviatuurilt
sisestatud sümbolid, kuni vajutatakse
reavahetuse klahvi ('
Return ' või 'Enter').
2. Kui sisestatud sümbolid moodustavad väärtuse, mis sobib kokku
protseduuri väljakutsega kaasa antud muutuja tüübiga, siis omistame
saadud väärtuse sellele muutujale, vastasel korral teatame kasutajale, et
sisestatud väärtusel ei ole sobiv andmetüüp.
Tegelikes programmeerimisekeeltes on see algoritm tihti keerulisem kui
eelkirjeldatu, kuid üldine põhimõte on sama.
Kõiki programme võib üldjuhul vaadelda
koosnevana kolmest osast:
1) andmete
sisestamine;
2) andmete
töötlemine;
3) andmete
väljastamine.
Erandjuhtudel võib olla programm ilma andmesisestuseta, nagu programmid
N1.1 ja N1.2. Veelgi harvemini võib tulla ette programme, millel ei ole andmete
väljastamist. Selline olukord
viitab kasutule programmile, sest mida see ka ei
teeks , tulemusi selline programm ei esita.
Vaatleme nüüd järgnevalt, milliseid võimalusi andmete sisestamiseks ja
väljastamiseks pakuvad kursusel kasutatavad programmeerimiskeeled ning
mida andmete sisestamine ja väljastamine tegelikult tähendavad.
Standardprotseduurid andmete väljastamiseksAndmete väljastamise olemus
Andmete väljastamisel leitakse etteantud avaldise väärtus ja kirjutatakse see
väljundvoogu.
VÄLJUNDVOOG on programmeerimises kasutatav
üldistus kõigi andmete kohta,
mis liiguvad programmist väljundseadmele.
Tüüpiliselt on väljundvoog
suunatud kuvari
ekraanile . Enamikus programmeerimiskeeltest loetakse seda
standardseks väljundvooks ja kui ei ole kuidagi teistmoodi defineeritud, siis
kasutatakse seda. Kuid väljundvoo sihtpunktiks võib olla ka kettal paiknev fail
või
printer .
33 / 115
Andmete väljastamine keeles Pascal
Väljastamiskäsu süntaks keeles Pascal on järgmine:
'WRITE' '(' ')' |
'WRITELN' [ '(' ')' ]
avaldiste_loetelu -> [ ',' ]
Protseduuride 'Write' ja 'WriteLn' erinevus seisneb selles, et viimane viib
väljastamise järjekorra uuele reale ehk teeb reavahetuse.
P r o g r a m m N1.1.P
Program N1_1_P; { Programmi
algusesse kirjutame programmi nime. }
Var { Keeles Pascal on vaja kõik muutujad
deklareerida.}
K :
Real ; { Ütleme, et K on
reaalarvu tüüpi muutuja.}
Begin { Põhiprogrammi algus }
K := (100/12.5)*350;
Writeln(K); { Väljasta tulemus }
End.
Nagu Te ehk juba taipasite, kirjutatakse keeles Pascal kommentaarid loogeliste
sulgude ( '{' , '}' ) vahele.
Andmete väljastamine keeles C
Väljastamiskäsu süntaks keeles C on järgmine:
'printf' '(' ',' ')'
Keeles C tuleb tähele panna, et
suured ja
väikesed tähed on translaatori
jaoks erinevad. Nii võib defineerida muutujad nimedega '
k' ja '
K' ning kasutada
neid samaaegselt. Sellegipoolest ei ole see soovitatav, sest võib põhjustada
valestimõistmist ja programmeerijapoolseid vigu. Küll aga tuleb veateadete
korral, mis väidavad muutuja '
p' puudumist, kontrollida, kas ei peaks '
p' asemel
olema kasutatud muutujat '
P'. Selliseid näpukaid tuleb kõigil ette, eriti aga
algajatel.
P r o g r a m m N1.1.C
#
include /* Ütleme, et on vajalik lugeda päisfaili
'
stdio .h'. Selles asuvad C standartsete
sisend -
väljundfunktsioonide kirjeldused. /*
main() /* Põhiprogrammi algus */
float K; /* Ütleme, et K on reaalarvu tüüpi muutuja.
K = (100/12.5)*350; /* 'Andmetöötlus' */
printf("%f", K); /* Väljasta tulemus */
34 / 115
} /* Põhiprogrammi lõpp. */
Kommentaarid kirjutatakse sümbolipaaride '/*' ja '*/' vahele.
Kontrollstringi abil on võimalik kujundada väljundit. Sellest tuleb
juttu allpool.
Andmete väljastamine keeles Qbasic
Väljastamiskäsu süntaks keeles QBasic on järgmine:
'
PRINT ' |
'WRITE'
avaldiste_loetelu -> [ ( ',' | ';' )
Väljastusprotseduur 'Write' erineb protseduurist 'Print' selle poolest, et kirjutab
väljastatud väärtuste vahele
komad ja stringide ümber
jutumärgid . Käsuga
'Write' väljastatud andmete
formaat on kokkusobiv sisestusprotseduuri 'Input'
sisendformaadiga.
P r o g r a m m N1.1.BK = (100/12.5)*350 ' Andmetöötlus
print K ' Väljasta tulemus
Kommentaarid kirjutatakse rea lõppu ühekordse apostroofi järele.
Standardprotseduurid andmete sisestamiseksAndmete sisestamise olemus
Nagu ma juba eespool märkisin, on andmete sisestamine veel üheks
meetodiks muutujale väärtuse omistamisel. Kui omistamislause saab väärtuse avaldiselt,
siis sisestamisprotseduur saab väärtuse
sisendandmete voost ehk
sisendvoost.
SISENDVOOG on programmeerimises kasutatav üldistus kõikide programmi
sisestatavate andmete kohta. Tüüpiliselt saabub sisendvoog klaviatuurilt.
Enamikus programmeerimiskeeltest loetakse seda
standardseks sisendvooks ja
kui ei ole kuidagi teistmoodi defineeritud, siis kasutatakse seda. Kuid sisendvoo
lähtepunktiks võib olla ka kettal paiknev andmefail või mõni sisendseade.
Iga sisestamisprotseduuri
väljakutse loeb sisendvoost järgmise hulga
informatsiooni ja omistab selle etteantud muutujale.
Sissejuhatuses esitatud
programmis N2.2 käsu 'SISESTA P' tegevust võib kirjeldada järgmiselt:
1) Loeb kasutaja klahvivajutusi kuni vajutatakse klahvi [Enter] (mõnel
klaviatuuril on selleks [Return]). Iga klahvivajutusega kaasneb
vastava sümboli väljastamine kuvari ekraanile (kuid on ka selliseid
sisestusprotseduure, mis sümboleid ei väljasta).
35 / 115
2) Teisendab kogutud klahvivajutused väärtuseks. Antud näite korral
me eeldasime, et vajutati ainult punkti ja
numbreid tähistavatele
klahvidele, seega on sisestatud väärtus reaalarvu tüüpi.
3) Omistab saadud väärtuse muutujale P.
Sisendprotseduur võib ühe väljakutse ajal sisestada väärtused ka
mitmele muutujale. Programmi N2.2 võib kirja panna ka järgmisel viisil:
P r o g r a m m N2.3SISESTA P, X
K = (100/P)*X
VÄLJASTA K
Mõnedes programmeerimiskeeltes on kasutajaga dialoogi pidamise huvides
võimaldatud enne muutujasse väärtuse sisestamist väljastada kasutajale
viip,
mis võib kirjeldada
kasutajalt oodatavat tegevust. Viibaks on sellisel juhul
stringikonstant. Toon jällegi näite N2.2 baasil:
P r o g r a m m N2.4SISESTA "Palun sisesta saagikuse protsent: ", P
SISESTA "Palun sisesta vajalik kogus: ", X
K = (100/P)*X
VÄLJASTA K
Kui sisestatud väärtuse tüüp ja muutuja tüüp ei lange kokku ega ole ka
vaikimisi teisendatav (näiteks arv 5 on küll täisarv, aga selle võib teisendada ka
reaalarvuks 5.0 ja omistada reaalarvu tüüpi muutujale), siis sõltuvalt
programmeerimiskeelest püütakse tekkinud situatsioonist üle saada kas vea
teatamise ja töö lõpetamisega või võimaldatakse kasutajal
veelkord väärtus
sisestada.
Andmete sisestamine keeles Pascal
Sisestamiskäsu süntaks keeles Pascal on järgmine:
'READ' '(' ')' |
'READLN' [ '(' ')' ]
muutujate_loetelu -> [ ',' ]
P r o g r a m m N2.3.P
Program N2_3_P; { Programmi algusesse kirjutame programmi nime. }
Var { Keeles Pascal on vaja kõik muutujad deklareerida.}
P, X, K : Real; { Ütleme, et P, X ja K on reaalarvu tüüpi muutujad.}
Begin { Põhiprogrammi algus }
Read(P, X); { Sisesta P ja X }
K := (100/P)*X; { 'Andmetöötlus' }
Writeln(K); { Väljasta tulemus }
End.
36 / 115
Viiba
esitamist keele Pascal standardses sisestusprotseduuris ei ole ette
nähtud. Selleks tuleb kasutada väljastusprotseduuri abi.
Sisestusprotseduur READ loeb sisendvoost üksteisele järgnevaid sümboleid ja
ei arvesta nende paiknemist ridadel. See tähendab, et
käsk READ(A,B,C), kus A,
B ja C on täisarvutüüpi muutujad, loeb ühesuguse tulemusega mõlemaid
sisestusvariante:
1)
12 569 -5
2)
12
569
-5
Sisestusprotseduur READLN loeb sisendvoost muutujatele vajalikud väärtused
ja viib sisselugemise järjekorra edasi järgmisele "reale". Seega käsk
READLN(A,B) loeb eelnevalt esitatud esimesest sisestusvariandist väärtused 12
ja 569 ning jätab väärtuse -5 tähelepanuta. Teises sisestusvariandis lõpetab
see käsk andmete sisestamise enne väärtuse -5 sisestama hakkamist.
Andmete sisestamine keeles C
Sisestamiskäsu süntaks keeles C on järgmine:
'scanf' '(' ','
')'
muutuja_aadresside_loetelu ->
[ ','
muutuja_aadress -> '&' |
P r o g r a m m N2.3.C#include /* Ütleme, et on vajalik lugeda päisfaili
'stdio.h'. Selles asuvad C standartsete
sisend -
väljundfunktsioonide kirjeldused. /*
main() /* Põhiprogrammi algus */
float P, X, K; /* Ütleme, et P, X ja K on reaalarvu tüüpi. */
scanf("%f%f", &P, &X); /* Sisesta P ja X */
K = (100/P)*X; /* 'Andmetöötlus' */
printf("%f", K); /* Väljasta tulemus */
} /* Põhiprogrammi lõpp. */
Viiba esitamist keele C standardses sisestusprotseduuris ei ole ette nähtud.
Selleks tuleb kasutada väljastusprotseduuri abi.
Kontrollstringi abil on võimalik sisestada väga keerulise struktuuriga
sisendinformatsiooni ja näidata täpselt, kuidas saadud informatsiooni
interpreteerida. Esialgu on piisav, kui teame järgmisi kontrollstringi kujusid:
37 / 115
int i; scanf("%d", &i); /* sisestab
täisarvu */
float r; scanf("%f", &r); /* sisestab ühekordse täpsusega reaalarvu
char c; scanf("%c", &c); /* sisestab sümboli */
char s[30]; scanf("%s", s); /* sisestab stringi */
Keeles C leidub veel suurel hulgal igasuguseid spetsiifilisi sisestusfunktsioone,
kuid neid ma tutvustan kunagi hiljem.
Andmete sisestamine keeles QBasic
Sisestamiskäsu süntaks keeles QBasic on järgmine:
'INPUT' [ ';' ] [ ( ';' | ',' ) ]
'LINE INPUT' [ ';' ] [ ';' ]
P r o g r a m m N2.3.B
input P, X ' Sisesta P ja X
K = (100/P)*X ' Andmetöötlus
print K ' Väljasta tulemus
Sellele programmile andmeid sisestades peab teadma, et arvud tuleb kirjutada
ühele reale ja eraldada üksteisest komaga.
Keeles Basic on üldiselt lubatud kasutada deklareerimata lihtmuutujaid. Antud
programmis N2.3.B tekitatakse muutujad P ja X sisestuskäsu töötamise ajal ja
nende tüüp määratletakse vastavalt sisestatud väärtuse
tüübile . Kord juba
tekitatud muutuja tüüpi hiljem muuta ei saa.
P r o g r a m m N2.4.B
input "Palun sisesta saagikuse protsent: ", P ' sisesta P
input "Palun sisesta vajalik kogus: ", X ' sisesta X
K = (100/P)*X ' Andmetöötlus
print K ' Väljasta tulemus
Sisestamiskäsku kirjutades on süntaksi järgi võimalik kasutada kas
koma või
semikoolonit. Seda, mis toimub ühe või teise
eraldaja kasutamise korral, on
õpetlik endal järele proovida.
Väljundi vormistamineMis on väljundi vormistamine?
Tihti on vaja vormistada väljastatav informatsioon mingisugusele nõutud
kujule. Kõige
tavalisem on andmete esitamine tabelina. Põhjuseks on tabelina
38 / 115
esitatud andmete parem loetavus. Sageli soovitakse näha reaalarvulisi
andmeid ühesuguse hulga kohtadega pärast koma jne. Selleks on paljudes
programmeerimiskeeltes väljastamisprotseduurile lisatud juba
spetsiaalsed vormistamise vahendid.
Väljundi vormistamise võimalused keeles Pascal
Väljastusprotseduurile 'Write' etteantud avaldise võib kirja panna ka järgmise
süntaksi järgi:
[ ':' [ ':'
Sellisele süntaksile vastavad väljastuskäsud ja tulemused võivad olla
järgmised:
writeln('|',123.8,'|'); | 1.2380000000E+02|
writeln('|',123.8:8,'|'); | 1.2E+02|
writeln('|',123.8:8:2,'|'); | 123.80|
writeln('|',123.8:8:0,'|'); | 124|
writeln('|',123.8:-8:0,'|'); |124 |
writeln('|','Tere':10,'|'); | Tere|
writeln('|','Tere':-10,'|'); |Tere |
Nagu toodud näidetest võib tähele panna, tähendab negatiivne väljundi pikkus
hoopis andmete paigutamist välja vasakpoolsesse otsa.
Väljundi vormistamise võimalused keeles C
Kõik väljastusprotseduuri vormistamise võimalused on seotud kontrollstringiga.
Järgnevalt püüan ma anda
lühikese ülevaate keelest, mille abil väljundit
kontrollstringis vormistatakse.
Kontrollstringis saab kasutada järgmisi sümbolipaare vastava mõiste
tähenduses:
\a
hoiatus , genereerib helisignaali
\b
backspace , samm tagasi koos kustutamisega
\c rea väljastamine ilma reavahetuseta
\f form-
feed , lehekülje
lõpetamine \n new-line, reavahetus
\r carriage return, väljastamisjärje toomine rea algusesse
\t tabulaator
\v vertikaalne tabulaator
39 / 115
\' apostroof
\\ backslash, tagurpidine kaldkriips
\n väljastab 8-
bitise sümbol, mille
ASCII kood on kuni neljakohaline
kaheksandsüsteemi arv n ja mille esimene number on 'null'.
Märgiga '%' alustatakse andmete teisendamise informatsiooni blokki, mille
üldine süntaks on:
'%' [ ][ ][ '.' ]
kus
lipud -> '-' | '+' | ' ' | '#'
teisendustähis -> 'd' | 'i' | 'o' | 'u' | 'x' | 'X' | 'f' | 'e' | 'E'
'g' | 'G' | 'c' | 's'
-
teisenduse resultaat paigutatakse välja vasakusse otsa;
+ teisenduse
arvuline resultaat omab alati kas '+' või '-' märki;
# kasutatakse 'alternatiivset vormi'.
d,i täisarv väljastatakse kui märgiga täisarv;
o täisarv väljastatakse kui märgita kaheksandsüsteemi arv;
u täisarv väljastatakse kui märgita täisarv;
x,X täisarv väljastatakse kui märgita kuueteistkümnendsüsteemi arv;
f reaalarv väljastatakse normaalsel kujul ([-]nnn.nnnn);
e,E, reaalarv väljastatakse eksponendi abil kujul ([-]n.nnne(+|-)nn);
g,G
c väärtuse esimene
bait väljastatakse kui sümbol;
s väärtust vaadeldakse kui stringi ja väljastatakse kuni stringi lõpu
tunnuseni.
Järgnevalt mõned näited kontrollstringi kasutamisest:
printf("%#o, %#x, %#X, %#f, %#g, %#e\n", 123, 123, 123, 123, 123,
123);
Tulemus -> 0173, 0x7b, 0X7B, 123.000000, 123.000, 1.230000e+02
printf("%.6d,%10.6d,%.6f,%.6e,%.6s\n", 123, 123, 1.23, 123.4,
"MoreThan");
Tulemus -> 000123,000123,1.230000,1.234000e+02,MoreTh
40 / 115
Väljundi vormistamise võimalused keeles QBasic
Väljastamiskäsu 'PRINT'
harilike vormistamisvahendite hulka kuulub koma ja
semikooloni sihipärane kasutamine. Kui on vaja kasutada täpsemat
väljundformaati, siis on abiks järgmine käsk:
'PRINT' 'USING' ';'
Formaadikirjeldus on spetsiaalne
string , mis võib sisaldada järgmisi sümboleid:
Numbriliste väärtuste vormistamine
# Numbri koht.
- Kui on paigutatud numbrikohtade taha, siis väljastab negatiivse arvu
märgi ka arvu taha.
. Arvu koma koht.
, Kui on paigutatud komakohast vasakule, siis väljastab koma iga kolme
numbri järel.
$$ Väljastab numbri ette märgi '$'.
+ Numbri märgi koht.
** Väljastab arvu ette jäävatele kohtadele märgid '*'.
^^^^ Väljastab arvu eksponentsiaalsel kujul.
**$ Kombineerib käskude ** ja $$ mõju.
Stringide vormistamine
& Väljastab terve stringi.
\ \ Väljastab esimesed n sümbolit,
kusjuures n on kaldkriipsude vahel
olevate tühikute arv + 2.
! Väljastab ainult esimese sümboli stringist.
Selle peatüki materjalide peale on "Kodutöö nr. 4"
41 / 115
VIIES TEEMA: tingimuslause. suunamislause.
valikulause.Sissejuhatus
Oma
igapäevases elus teeme me kas teadlikult või alateadlikult tuhandeid
valikuid ja võtame vastu otsuseid edaspidiseks tegevuseks. Meie valikud
sõltuvad nendest kriteeriumidest, mida me oleme enda jaoks kujundanud kogu
eelneva elu jooksul. Kriteeriumid võivad olla seotud meie teadmistega,
tõekspidamistega, seadustega, kasutada olevate vahenditega, eesmärkidega,
hetke meeleoluga jne. Mingisugust valikut tehes kasutame me üht kriteeriumi
selleks, et hinnata valikust tulenevate tagajärgede
kasulikkust,
tulemuslikkust,
meeldivust ja teisi
aspekte .
Programmeerimises on valiku
tagamaad teistsugused kui elus. Programmi
kirjutades me teame valiku tagajärgi täpselt (need kujundame ja kirjutame ju
ise) ja seega peame keskendama oma tähelepanu nendele
kriteeriumidele , mis
on valiku tegemise aluseks. Programmeerimises kasutatavate valikutega on
lihtsam kui elus ettetulevatega - nad on
formaliseeritavad ehk
üheseltmõistetavalt kirja pandavad. Programmis ei saa kasutada valiku
tegemiseks tingimust kujul '
Kui see värv on meeldiv, siis ...', sest meeldivuse
hindamine on
mitteformaliseeritav tegevus.
Järgnevalt püüan ma anda ülevaate erinevatest valikute realiseerimise
võimalustest meie poolt vaadeldavates programmeerimiskeeltes.
Tingimuslause
Väga tihti on programmi
kirjutamisel vaja käskude täitmise järjekord suunata
sõltuvalt mingisuguste muutujate hetkeväärtustest kahte erinevat rada mööda.
Sellist muutujate väärtusi kontrollivat
avaldist nimetatakse
TINGIMUSEKS .
Kujutame sellist programmilõiku
blokk -
skeemina :
|
v
--------
+ / \ -
----------
| \ / |
v -------- v
------------ ------------
| | | |
| tegevus1 | | tegevus2 |
| | | |
------------ ------------
| |
----------------------
|
v
42 / 115
Seega, kui TINGIMUS on täidetud, järgneb TEGEVUS1, vastasel korral
TEGEVUS2. Piltlikult öeldes toimub käskude jada
hargnemine , mistõttu
tingimuslauset nimetatakse ka HARGNEMISLAUSEKS (-käsuks).
TINGIMUSLAUSE on programmi juhtkonstruktsioon, mis võimaldab
vastavalt etteantud loogilise avaldise väärtusele suunata programmi
täitma kas üht või teist programmiharu.
Tingimuslause üldine süntaks on järgmine:
'KUI' 'SIIS'
tegevus1
[ 'MUIDU'
tegevus2 ]
'KUILÕPP'.
tingimus -> .
tegevus -> .
lausete jada -> [ ].
NÄIDE 1.
Ü l e s a n n eKirjutada programm protsentarvutuse ülesannete lahendamiseks.
Protsentarvutuse kolmeks põhiülesandeks on:
1) Osamäära M leidmine terviku T ja osa O järgi ehk kahe
arvu suhte väljendamine protsentides;
2) Osa O määramine protsendi M ja terviku T järgi;
3) Terviku T määramine, kui on teada protsent M ja vastav
osa O.
L a h e n d u sEsimeseks probleemiks on meie jaoks see, kuidas saada aru, millist
ülesandeliiki kolmest eelnimetatust kasutaja soovib lahendada.
Lihtsaimaks lahenduseks on seda küsida otse kasutaja käest,
esitades eelnevalt ekraanile pakutavad võimalused ja nendele vastavad
koodid, milleks võivad olla
numbrid 1, 2 ja 3.
Seejärel küsime vastavalt kasutaja poolt tehtud valikule ülesandes
antud väärtused ja arvutame otsitava väärtuse.
P r o g r a m m N1.1VÄLJASTA "PROTSENTARVUTUSED"
VÄLJASTA "[1] Osamäära M leidmine terviku T ja osa O järgi"
VÄLJASTA "[2] Osa O määramine protsendi M ja terviku T järgi"
VÄLJASTA "[3] Terviku T määramine protsendi M ja vastav osa O järgi"
SISESTA "Palun sisesta vajalik ülesandetüüp : ", N
KUI N = 1 SIIS
43 / 115
SISESTA "Palun sisesta terviku väärtus : ", T
SISESTA "Palun sisesta osa väärtus : ", O
VÄLJASTA "
Osamäär on "; O/T*100; "%"
MUIDU
KUI N = 2 SIIS
SISESTA "Palun sisesta terviku väärtus : ", T
SISESTA "Palun sisesta protsendi väärtus : ", M
VÄLJASTA "Osa väärtus on "; T/100*M
MUIDU
KUI N = 3 SIIS
SISESTA "Palun sisesta protsendi väärtus : ", M
SISESTA "Palun sisesta osa väärtus : ", O
VÄLJASTA "Terviku väärtus on "; O/M*100
KUILÕPP
KUILÕPP
KUILÕPP
Toodud näites on üks kahest programmiharust jagatud veelkord kaheks ja
saadud sellega kokku kolm võimalikku haru. Sellesama programmi võib kirja
panna ka üksteisele järgnevate valikulausete jadana:
P r o g r a m m N1.2VÄLJASTA "PROTSENTARVUTUSED"
VÄLJASTA "[1] Osamäära M leidmine terviku T ja osa O järgi"
VÄLJASTA "[2] Osa O määramine protsendi M ja terviku T järgi"
VÄLJASTA "[3] Terviku T määramine protsendi M ja vastav osa O järgi"
SISESTA "Palun sisesta vajalik ülesandetüüp : ", N
KUI N = 1 SIIS
SISESTA "Palun sisesta terviku väärtus : ", T
SISESTA "Palun sisesta osa väärtus : ", O
VÄLJASTA "Osamäär on "; O/T*100; "%"
KUILÕPP
KUI N = 2 SIIS
SISESTA "Palun sisesta terviku väärtus : ", T
SISESTA "Palun sisesta protsendi väärtus : ", M
VÄLJASTA "Osa väärtus on "; T/100*M
KUILÕPP
KUI N = 3 SIIS
SISESTA "Palun sisesta protsendi väärtus : ", M
SISESTA "Palun sisesta osa väärtus : ", O
VÄLJASTA "Terviku väärtus on "; O/M*100
KUILÕPP
Midagi on nendel programmidel siiski sisuliselt erinevat. Programmi töö
tulemuses see ei kajastu, kuid kui vaadata tehtava töö hulka ehk täidetavate
lausete hulka, siis näeme, et kui esimeses näites valib kasutaja
variandi 1, siis
rohkem muutuja
N väärtust ei
kontrollita . Teises näites aga toimub kontroll veel
ka siis, kui esimese variandi tegevused on juba täidetud.
Sama funktsionaalsusega programmi võib kirjutada kõigis meie poolt
vaadeldavates keeltes:
Tingimuslause keeles Pascal
Tingimuslause süntaks:
44 / 115
'IF' 'THEN'
[ '
ELSE '
].
tegevus -> [ ] | 'BEGIN' [ ][ ';' ]
'END'.
lausete jada -> [ ';' ].
NB! Võtmesõna 'ELSE' ees ei tohi olla semikoolonit ( ';' )!
P r o g r a m m N1.1.PProgram N1_1_P;
Var { deklareerime vajalikud muutujad }
N :
Integer ;
T, O, M : Real;
Begin<
WriteLn('PROTSENTARVUTUSED');
WriteLn('[1] Osamäära M leidmine terviku T ja osa O järgi');
WriteLn('[2] Osa O määramine protsendi M ja terviku T järgi');
WriteLn('[3] Terviku T määramine protsendi M ja vastav osa O järgi');<
Write('Palun sisesta vajalik ülesandetüüp : '); Read(N);
If N = 1 Then
Begin
Write('Palun sisesta terviku väärtus : '); Read(T);
Write('Palun sisesta osa väärtus : '); Read(O);
{ ja teatame arvutuste tulemuse }
WriteLn('Osamäär on ', O/T*100:5:1, '%');
End
Else
If N = 2 Then
Begin
Write('Palun sisesta terviku väärtus : '); Read(T);
Write('Palun sisesta protsendi väärtus : '); Read(M);
WriteLn('Osa väärtus on ', T/100*M)
End
Else
If N = 3 Then
Begin
Write('Palun sisesta protsendi väärtus : '); Read(M);
Write('Palun sisesta osa väärtus : '); Read(O);
WriteLn('Terviku väärtus on ', O/M*100)
End
End.
45 / 115
Tingimuslause keeles C
Tingimuslause süntaks:
'if' '(' ')'
[ 'else'
].
tegevus -> [ ] ';' | '{' '}'.
lausete jada -> ';' [ ].
P r o g r a m m N1.1.C#include
main()<
else
if (N == 2)
else
46 / 115
if (N == 3)
} /* main */
Tingimuslause keeles Qbasic
Tingimuslause süntaks:
'IF' 'THEN'
[ '
ELSEIF ' 'THEN'
[ ]]
[ 'ELSE'
[ ]]
'END IF' .
tegevus -> .
lausete jada -> [ ].
P r o g r a m m N1.1.B' esitame valikuinfo kasutajale
print "PROTSENTARVUTUSED"
print "[1] Osamäära M leidmine terviku T ja osa O järgi"
print "[2] Osa O määramine protsendi M ja terviku T järgi"
print "[3] Terviku T määramine protsendi M ja vastav osa O järgi"
' sisestame kasutaja valiku
input "Palun sisesta vajalik ülesandetüüp : ", N
if N = 1 then ' kui valiti 1. variant,
' siis sisestame teadaolevad väärtused
input "Palun sisesta terviku väärtus : ", T
input "Palun sisesta osa väärtus : ", O
' ja teatame arvutuste tulemuse
print using "Osamäär on ###.#%"; O/T*100
elseif N = 2 then
input "Palun sisesta terviku väärtus : ", T
input "Palun sisesta protsendi väärtus : ", M
print "Osa väärtus on "; T/100*M
elseif N = 3 then
input "Palun sisesta protsendi väärtus : ", M
input "Palun sisesta osa väärtus : ", O
print "Terviku väärtus on "; O/M*100
end if
47 / 115
Suunamislause
SUUNAMISLAUSE on käsk, millega suunatakse programmi täitmine
suunamislausega defineeritud punkti.
Veel kümmekond aastat tagasi oli suunamislause väga laialdaselt kasutusel.
Programmeerimiskeelte
Fortran ja
Basic varasemates versioonides oli see
kohati asendamatu. Tänapäeva keeltesse on see jäänud pigem vanade
programmidega ühilduvuse tagamise mõttes, sest on võimalik kirjutada
programme ilma suunamislauset üldse kasutamata. Siiski on meie poolt
vaadeltavates programmeerimiskeeltes kasutusele võetud nn. '
maskeeritud
suunamislauseid'.
Rääkides suunamislausest, ei saa ma
rääkimata jätta, mis asi on märgend.
MÄRGEND on programmeerija poolt defineeritav identifikaator, mis
märgib ära ühe lause programmis. Seega võib programmis iga lause ette
kirjutada märgendi. Soovides programmi tööjärge suunata mingi konkreetse
lause täitmise juurde, tuleb meil kasutada suunamislauset koos soovitud lause
ees oleva märgendiga.
Toon ühe näite, mille stiil ja süntaks pärinevad
vanematest Basic-keelsetest
programmidest. Suunamislauset alustab võtmesõna 'GOTO':
P r o g r a m m N1.1.B.210 print "PROTSENTARVUTUSED"
20 print "[1] Osamäära M leidmine terviku T ja osa O järgi"
30 print "[2] Osa O määramine protsendi M ja terviku T järgi"
40 print "[3] Terviku T määramine protsendi M ja vastav osa O järgi"
70 input "Palun sisesta vajalik ülesandetüüp : ", N
80 if N 1 then goto 130
90 input "Palun sisesta terviku väärtus : ", T
100 input "Palun sisesta osa väärtus : ", O
110 print using "Osamäär on ###.#%"; O/T*100
120 goto 220
130 if N 2 then goto 180
140 input "Palun sisesta terviku väärtus : ", T
150 input "Palun sisesta protsendi väärtus : ", M
160 print "Osa väärtus on "; T/100*M
170 goto 220
180 if N 3 then goto 220
190 input "Palun sisesta protsendi väärtus : ", M
200 input "Palun sisesta osa väärtus : ", O
210 print "Terviku väärtus on "; O/M*100
220 end
Ma loodan, et Te kujutate ette, kui keeruliseks tegid need 'GOTO'-
laused inimestele programmi lugemise ja parandamise.
Maskeeritud suunamislauseteks on vaadeldavates keeltes sellised
laused , mille
tulemusena toimub samuti programmi täitmise järjekorra ümbersuunamine.
Harilikult on selleks sihtpunktiks käesolevat lauset sisaldava juhtimislause
algus või sellele juhtimislausele järgneva lause algus. Nendest
suunamislausetest räägime koos juhtimislausetega, kus neid kasutatakse.
48 / 115
Suunamislause keeles Pascal
Suunamislause süntaks:
'GOTO' .
märgend -> .
Märgendi defineerimise süntaks:
'LABEL' ';' .
märgendite
loetelu -> [ ',' ].
Märgendi kasutamise süntaks:
':' .
P r o g r a m m N2.1.P
Program N2_1_P;
Label 9999;
Var N :
Integer ;
Begin
Read(N);
If N .
Märgendi kasutamise süntaks:
':' ';' .
P r o g r a m m N2.1.C
main()
int N;
scanf("%d", &N);
if (N .
Märgendi kasutamise süntaks:
':' .
P r o g r a m m N2.1.B
input N
if N .
variantide jada -> [ ';' ].
variant -> ':' .
valikute jada -> [ ',' ] .
valik -> | .
konstantide vahemik -> '..' .
P r o g r a m m N3.1.P
Program N3_1_P;
Var { deklareerime vajalikud muutujad }
N : Integer;
T, O, M : Real;
50 / 115
Begin
WriteLn('PROTSENTARVUTUSED');
WriteLn('[1] Osamäära M leidmine terviku T ja osa O järgi');
WriteLn('[2] Osa O määramine protsendi M ja terviku T järgi');
WriteLn('[3] Terviku T määramine protsendi M ja vastav osa O
järgi');
Write('Palun sisesta vajalik ülesandetüüp : '); Read(N);
Case N Of
1 : { kui valiti 1. variant, }
Begin { siis sisestame teadaolevad väärtused }
Write('Palun sisesta terviku väärtus : '); Read(T);
Write('Palun sisesta osa väärtus : '); Read(O);
WriteLn('Osamäär on ', O/T*100:5:1, '%');
End;
2 :
Begin
Write('Palun sisesta terviku väärtus : '); Read(T);
Write('Palun sisesta protsendi väärtus : '); Read(M);
WriteLn('Osa väärtus on ', T/100*M)
End;
3 :
Begin
Write('Palun sisesta protsendi väärtus : '); Read(M);
Write('Palun sisesta osa väärtus : '); Read(O);
WriteLn('Terviku väärtus on ', O/M*100)
End
End
End.
Valikulause keeles C
Valikulause süntaks :
'
switch ' '(' ')'
'{'
[ 'default' ';' ]
'}' .
selektor -> .
variantide jada -> [ ].
variant -> 'case' ':' ';' [ 'break' ';' ].
valik -> .
51 / 115
Siinkohal ongi võimalus rääkida käsust '
break', mis kujutab endast tüüpilist
maskeeritud suunamislauset. Selle käsu inglisekeelne tähendus (antud
kontekstis - '
katkesta') kajastab hästi selle käsu tegevust, mille tulemusena
katkestatakse valikulause täitmine ja juhtimine antakse edasi valikulausele
järgnevale lausele. Kui seda katkestamise käsku ei kasutata, siis täidetakse
järjest kõik tegevused alates selektori väärtusega määratud sisendpunktist kuni
valikulause lõpuni.
P r o g r a m m N3.1.C
#include
main()<
} /* main */
Valikulause keeles Qbasic
Valikulause süntaks :
'
SELECT CASE'
52 / 115
[ 'CASE' 'ELSE'
]
'END SELECT'.
selektor -> .
variantide jada -> [ ].
variant -> 'CASE' ':' .
valikute jada -> [ ',' ] .
valik -> | | 'IS'
vahemik -> 'TO' .
P r o g r a m m N3.1.B
' esitame valikuinfo kasutajale
print "PROTSENTARVUTUSED"
print "[1] Osamäära M leidmine terviku T ja osa O järgi"
print "[2] Osa O määramine protsendi M ja terviku T järgi"
print "[3] Terviku T määramine protsendi M ja vastav osa O järgi"
' sisestame kasutaja valiku
input "Palun sisesta vajalik ülesandetüüp : ", N
select case N
case 1 : ' kui valiti 1. variant,
' siis sisestame teadaolevad väärtused
input "Palun sisesta terviku väärtus : ", T
input "Palun sisesta osa väärtus : ", O
' ja teatame arvutuste tulemuse
print using "Osamäär on ###.#%"; O/T*100
case IS = 2 :
input "Palun sisesta terviku väärtus : ", T
input "Palun sisesta protsendi väärtus : ", M
print "Osa väärtus on "; T/100*M
case 3 :
input "Palun sisesta protsendi väärtus : ", M
input "Palun sisesta osa väärtus : ", O
print "Terviku väärtus on "; O/M*100
end select
Selle peatüki materjalide peale on "Kodutöö nr. 5"
53 / 115
KUUES TEEMA: struktuursed andmetüübid:
jada, massiiv, kirje, fail. Sissejuhatus
Käesolevas teemas käsitlen ma andmeobjekte, mis omavad erinevalt lihttüüpi
muutujatest
struktuuri. Sellest omadusest tulenevalt nimetatakse neid objekte
struktuurset tüüpi andmeobjektideks. Nende koostisosadeks võivad olla
meile juba tuttavad lihttüüpi andmeobjektid - täisarv, reaalarv ja sümbol - ning
lisaks saab veel kasutada teisi juba olemasolevaid struktuurseid tüüpe.
Milleks on meil struktuurseid tüüpe vaja? Asi on nimelt selles, et praktilised
ülesanded tulenevad igapäevasest elust ja meid ümbritsevad objektid on oma
atribuutide ehk omaduste poolest liiga keerulised selleks, et neid saaks
kirjeldada vaid ühe arvuga. Näiteks inimese kirjeldamiseks peame kasutusele
võtma mitmeid muutujaid - inimese ees- ja
perekonnanimi , vanus, sugu, kaal,
kasv jne. Kas ei võiks kasutada programmis selle asemel andmetüüpi nimega
'Inimene'?
Selgub , et see on võimalik ja allpool me
selleni jõuamegi.
Jada. Massiiv. Massiivi mõõtmed
Kõige lihtsam struktuursetest andmetüüpidest on
jada, milleks nimetatakse
samatüübiliste ühe nime alla koondatud indekseeritavate muutujate komplekti.
Liiga keeruline mõiste? Räägime selle siis lahti ja alustame seejuures
definitsiooni
lõpust .
Mida tähendab
muutujate komplekt? See tähendab, et meil on rohkem kui
üks muutuja üksteise kõrval. Näiteks
selliselt :
----------------------------------------------------------------
| 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 |
----------------------------------------------------------------
Mida tähendab
indekseeritavad? See tähendab, et neid saab eristada
üksteisest nende järjekorranumbri ehk
indeksi järgi. Et sellele muutujate
komplektile on pandud
üks nimi, siis on see ka ainus võimalus neid jadast üles
leida. Ja väga oluline on ka see, et kõik jada elemendid (üksikud muutujad) on
sama tüüpi.
Jada nimetatakse teinekord ka
järjendiks või
ühemõõtmeliseks massiiviks.
Kõige kasutatavam jada on sümbolite jada, mida nimetatakse
stringiks ning
kasutatakse igasuguste nimetuste ja teksti hoidmiseks.
Massiiv on jadast üldisem mõiste, kuid olemuselt sama - hulk samatüübilisi
muutujaid, kõigile on pandud üks nimi ja igal
muutujal on oma indeks. Kui jada
on alati
ühemõõtmeline , siis massiivi mõõtmelisuse ehk
dimensiooni piirid on
piiratud vaid konkreetse keele võimalustega.
54 / 115
Selleks, et massiivi mõõtmetest paremini aru saada, võtame kasutusele
väikese analoogia geomeetriaga:
Ühele muutujale vastab geomeetrias
punkt, ühemõõtmelisele massiivile
(jadale) vastab
sirglõik, kahemõõtmelisele massiivile (maatriksile) vastab
ristkülik ja kolmemõõtmelisele massiivile
risttahukas. Ja nii edasi, kui keegi
teab vastavaid nimetusi.
Massiivi deklareerimine
Massiiv kui muutujate komplekt vajab vastavalt oma suurusele mälu. Selle
jaoks tuleb massiiv alati deklareerida. Keeltes, kus on lubatud massiivide
kasutamine esialgselt deklareerimata, on kasutusel vaikimisi massiivisuurus,
mis ei pruugi Teid kui programmeerijat rahuldada.
Sõltuvalt arvutist, operatsioonisüsteemist või translaatorist võib esineda
piiranguid massiivi suurusele või kasutadaolevale mälule. Deklareerides
massiivitüüpi muutujaid peab nende piiridega arvestama.
Massiivi indeksi kõige väiksemat ja kõige suuremat väärtust nimetatakse
vastavalt
alumiseks rajaks ja
ülemiseks rajaks.
Massiivi deklareerimine keeles Pascal
Massiivitüüpi muutuja deklareerimise lause on üks variant üldisest muutujate
deklareerimise lausest, mille süntaks keeles Pascal on järgmine:
'VAR' .
muutujadeklareerimise_laused ->
';' [] .
muutujadeklareerimise_lause -> ':' .
muutujate_loetelu -> [ ',' ] .
tüüp -> | .
struktuurne_tüüp -> | | .
massiivitüüp -> '
ARRAY ' '[' ']' 'OF' .
indeksitüüpide_loetelu -> >indeksitüüp> [ ',' ] .
indeksitüüp -> | 'CHAR' | 'BOOLEAN' .
alamhulgatüüp -> '..' .
Massiivi indeksite hulk peab olema loetletav, seetõttu ei ole lubatud kasutada
indeksina reaalarvutüüpi
konstante . Kuna sümbolitüübi 'CHAR' ja
tõeväärtustüübi 'BOOLEAN' väärtused on loetletavad, siis on lubatud
deklaratsioonid kujul
Kood : ARRAY[Char] OF INTEGER;
ja
Olekutabel : ARRAY[Boolean, Boolean] OF Boolean;
55 / 115
Massiivis 'Kood' on 256 elementi ja kuna täisarv on 2 baidi suurune, siis massiiv
võtab ruumi (256 * 2)
baiti . Massiivis 'Olekutabel' on 2 * 2 elementi.
Keeles Pascal võivad olla massiivi radadeks mistahes Teie poolt valitud ja
indeksitüübi väärtuste
piiridesse jäävad väärtused. Järgnevalt veel näiteid
õigetest massiivi deklareerimise lausetest:
Jada : ARRAY[1..100] OF Real;
Maatriks : ARRAY[0..9, 0..19] OF Boolean;
Malelaud : ARRAY['A'..'H', 1..8] OF Char;
X, Y, Z : ARRAY[-100..100] OF Integer;
Massiivi deklareerimine keeles C
Massiivitüüpi muutuja deklareerimise lause süntaks keeles C on järgmine:
muutujadeklareerimise_lause ->
[ ] [ ] ';' .
mäluklass -> 'auto' | '
extern ' | '
register ' | 'static' .
modifikaator -> '
unsigned ' | 'long' | 'short' .
tüüp -> | .
struktuurne_tüüp -> .
muutujate_loetelu ->
[ ] [ ',' ] .
dimensioonid -> '[' ']' [ ] .
dimensiooni_suurus -> .
Keeles C on massiividel alumise raja väärtus alati 0. Ülemise raja väärtus on
aga dimensiooni
suurusest ühe võrra väiksem. Seetõttu ei ole massiivi otsene
kasutamine keeles C nii mugav kui keeles Pascal, kuid see ei ole põhimõtteline
erinevus ja C-fänne see ei sega.
Järgnevalt mõned massiivideklaratsioonide näited keeles C, mis on
samaväärsed eespool esitatud näidetega Pascali jaoks:
float Jada[100];
int Maatriks[10][20];
char Malelaud[8][8];
int X[201], Y[201], Z[201];
Massiivi deklareerimine keeles Qbasic
Massiivitüüpi muutuja deklareerimise lause süntaks keeles QBasic on järgmine:
'DIM' ['SHARED'] .
muutujadeklareerimise_laused ->
[',' ] .
muutujadeklareerimise_lause ->
[ '(' ')' ] ['AS' ] .
rajad -> [ 'TO' ] [ ',' ] .
alumine_rada -> .
ülemine_rada -> .
Kui alumist rada ei deklareerita, siis on selle vaikimisi väärtus 0.
56 / 115
Võtmesõna 'SHARED' kasutatakse aga siis, kui soovitakse, et massiivi saavad
kasutada ka teised programmiosad (funktsioonid, protseduurid).
Ja järgnevad jällegi
eestpoolt tuttavad deklaratsioonid,
seekord siis keeles
QBasic:
DIM Jada(1 TO 100) AS
SINGLE DIM Maatriks(9, 19) AS INTEGER
DIM Malelaud(1 TO 8, 1 TO 8) AS STRING * 1
DIM X(-100 TO 100) AS INTEGER, Y(-100 TO 100) AS INTEGER
DIM Z(-100 TO 100) AS INTEGER ' ei mahtunud enam eelmisele reale ära :-)
Massiivi kasutamine
Massiive kasutatakse praktiliselt igas programmis. Programm, milles ei ole
ühtegi massiivi, on väga erandlik. Sest tuletage meelde, isegi string on massiiv!
Teise kasutusalana võiks märkida korduvaid protsesse, milles massiivi
kasutatakse andmete hoidmiseks.
Massiivi kasutatakse keeles kui harilikku muutujat, kusjuures muutujanimele
lisatakse indeks, mis peab mahtuma massiivi radade vahele. Vaatame
järgnevalt näidet, kus massiivmuutuja 'Jada' esimesed kolm liiget
summeeritakse kokku.
Pascal Summa := Jada[1] + Jada[2] + Jada[3];
C Summa = Jada[0] + Jada[1] + Jada[2];
Qbasic Summa = Jada(1) + Jada(2) + Jada(3)
Nii nagu lihtmuutujate, nii ka massiivi elementide väärtused on enne
algväärtustamist määramata. Mõnes programmeerimiskeeles
automaatne algväärtustamine siiski toimub, kuid võtke endale reegliks, et MASSIIVI
ELEMENDID TULEB ENNE MASSIIVI KASUTAMIST ALGVÄÄRTUSTADA.
Kirje
Reaalses maailmas leidub siiski vähe objekte, mille struktuuri saab kirjeldada
mitme ühetüübilise muutujaga. Seega on
massiivid sobilikud sarnaste
andmehulkade töötlemisel, kuid
üksiku objekti kirjeldamisel võib vaja minna
erinevat tüüpi andmeobjekte. Sellisel juhul on meil kasutada KIRJE, mis on üht
loogilist
tervikut iseloomustavate muutujate kogum ning need muutuja võivad
olla erinevat tüüpi. Ühte kirje muutujat nimetatakse
väljaks. Põhimõtteliselt ei
ole välja tüübil mitte mingisuguseid piiranguid.
Kirjete koostamisel tuleb mõelda
üldisemast konkreetsema suunas. Tahtes
57 / 115
deklareerida kirjetüüpi nimega 'Isik' ja
otsides välja meile vajalikke atribuute,
võime me algselt deklareerida stringitüüpi välja 'Nimi'. See väli võib rahuldada
meie vajadusi, võib ka mitte. Näiteks hakkab meid huvitama, et saaks eristada
isiku ees- ja
perekonnanime . Me võime siis välja 'Nimi' asemele tekitada kaks
vastavat välja, aga võime ka muuta välja omakorda kirjeks, mis sisaldab
vajalikke üksikasju. Võimalusi on palju.
Kirje deklareerimine
Kuna kirje deklareerimine on suhteliselt töömahukam kui teiste andmetüüpide
kirjapanemine, siis harilikult deklareeritakse kirje uue tüübina ja sellele tüübile
pannakse nimi, mida saab edaspidi muutujate deklareerimisel kasutada.
Muidugi ei ole selline teguviis kohustuslik, kuid siiski soovitatav.
Kirje deklareerimine keeles Pascal
Kirjetüübi deklareerimise süntaks keeles Pascal on järgmine:
'TYPE' '=' '
RECORD ' [';'] 'END' .
väljade_loetelu -> [ ';' ] .
väli -> ':' .
väljanimede_loetelu -> [ ',' ] .
Paneme kirja ka sobiliku tüübideklaratsiooni isiku andmete jaoks:
Type Isik = Record
Eesnimi ,
Perekonnanimi : String[20];
Vanus : Integer;
Isikukood : String[11];
End;
Kirje deklareerimine keeles C
Kirjetüübi deklareerimise süntaks keeles C on järgmine:
'
struct ' '{' '}' ';' .
väljade_loetelu -> ';' [ ] .
väli -> .
muutujate_loetelu ->
[ ] [ ',' ] .
Ja isikuandmete kirje
deklaratsioon keeles C:
struct Isik
;
58 / 115
Kirje deklareerimine keeles Qbasic
Kirjetüübi deklareerimise süntaks keeles C on järgmine:
'TYPE' 'END' 'TYPE' .
väljade_loetelu -> [ ] .
väli -> 'AS' .
Ja isikuandmete kirje deklaratsioon keeles Qbasic:
TYPE Isik
Eesnimi AS STRING * 20
Perekonnanimi AS STRING * 20
Vanus AS INTEGER
Isikukood AS STRING * 11
END TYPE
Kirje kasutamine
Deklareeritud kirjetüübi kasutamiseks tuleb deklareerida muutuja, mille
tüübiks on kirjetüüp. Kuna massiivi deklareerimisel on lubatud elemendi tüübina
kasutada igasugust tüüpi, siis võib moodustada ka kirjete massiive, mida
nimetame tabeliks . Paneme kirja muutujate deklaratsioonid vastavates
keeltes:
Pascal Var
Patsient : Isik;
Patsiendid : ARRAY[1..1000] OF Isik;
C struct Isik Patsient;
struct Isik Patsiendid[1000];
Qbasic Patsient AS Isik
DIM Patsiendid(1000) AS Isik
Kirjemuutuja
kasutamisel võib kirjet vaadelda kui üht terviklikku muutujat ja
selliste muutujate vahel on lubatud omistamise
operatsioon . Kui on vajadus
kasutada üht välja kirjest, siis kõigi kolme keele süntaks langeb selle koha peal
kokku:
'.' .
Tühikuid identifikaatorite ja punkti vahele jätta ei tohi. Kirje kasutamist
illustreerib järgmine näide:
if Patsiendid[x].Vanus > 50 then
Patsient := Patsiendid[x];
59 / 115
Fail
Failiks nimetatakse samatüübiliste komponentide jada, kusjuures erinevalt
ühemõõtmelisest massiivist ei ole komponentide arv jadas kindlaks määratud
ja võib olla kuitahes suur. Faili
komponendiks võib olla mistahes tüüpi
andmeobjekt. Kui
failis ei ole ühtegi komponenti, on meil tegemist tühja failiga.
Failil on kindlasti olemas nimi. Failiga saab teostada järgmisi
elementaaroperatsioone: faili
avamine ja
sulgemine , komponendi lugemine ja
kirjutamine.
Failist komponendi
kustutamise operatsiooni üldjuhul ei ole.
Mõningates keeltes leidub funktsioon vajaliku järjenumbriga komponendi
leidmiseks failist. Failide omapära seisneb selles, et neid tuleb käsitleda
komponenthaaval. Faili
avamise järgselt on aktiivseks esimene
komponent ,
selle lugemise järel teine jne. Ka kirjutamise puhul liigutakse automaatselt
järgmise komponendi alguskohale. Magnetofonilindi kasutamine on faili
kasutamisega sarnane tegevus - saab kuulata (ehk lugeda) ja lindistada (ehk
kirjutada), kustutamine on tõlgendatav lihtsalt vaikuse kirjutamisena lindile.
Faili deklareerimine
Failide deklareerimisel
luuakse sobivat tüüpi failimuutuja, mis on oma
olemuselt kirje ja võib kanda endas informatsiooni faili nime, käsitlemise
staatuse ja viimati loetud komponendi kohta.
Failide deklareerimise ja avamise süntaks vastavates keeltes on järgmine:
Pascal Süntaks:
'TYPE' '=' 'FILE' 'OF' ';' .
'VAR' ':' ';' .
'Assign' '(' ',' ')' ';' .
Lugemiseks avamine toimub järgmise käsuga (operatsiooni õnnestumise
eelduseks on faili olemasolu):
'
Reset ' '(' ')' ';' .
Kirjutamiseks avamine toimub järgmise käsuga:
'Rewrite' '(' ')' ';' .
Näide:
Type
Tekstifail = File Of Char;
Var Sisendfail : Tekstifail;
...
Assign(Sisendfail, 'LOEMIND.TXT');
Reset(Sisendfail);
C Süntaks:
'FILE' ';' .
'=' 'fopen' '(' ',' ')' ';'.
60 / 115
viitmuutuja_nimi -> '*' .
moodus -> '"' 'r' ['+'] '"' | '"' 'w' ['+'] '"' | '"' 'a' ['+'] '"'.
Näide:
FILE *Sisendfail;
Sisendfail = fopen("LOEMIND.TXT", "r");
Qbasic Süntaks:
'
OPEN ' ['FOR' ] 'AS' ['#'] .
moodus -> 'APPEND' | '
BINARY ' | 'INPUT' | 'OUTPUT' | '
RANDOM ' .
failinumber -> .
Näide:
OPEN "LOEMIND.TXT" FOR INPUT AS #1
Faili kasutamine
Pärast faili avamist saab faili lugeda ja kirjutada vastavalt sellele, missuguste
parameetritega fail avati. Pärast töö lõpetamist tuleb fail sulgeda. Kui seda
mitte teha, siis ei pruugi Teie poolt kirjutatud andmed faili jõuda. Failide
kasutamise kõigi võimalustega
tutvumine ei mahu kahjuks selle kursuse
raamidesse ja seda tuleb igalühel õppida läbi oma kogemuste.
Toon järgnevalt mõned näited faili kasutamise kohta.
Pascal Var
Rida : String[80];
SF, VF : Text;
begin
Assign(SF, 'Input.txt');
Assign(VF, 'Output.txt');
Reset(SF);
Rewrite(VF);
ReadLn(SF, Rida); { loeb failist 'Input.txt' esimese rea }
WriteLn(VF, Rida);
Close (VF);
Close(SF);
end.
C #include
main()
Qbasic DIM Rida AS STRING * 80
OPEN "Input.txt" FOR INPUT AS #1
OPEN "Output.txt" FOR OUTPUT AS #2
LINE INPUT #1, Rida$
PRINT #2, Rida$
CLOSE ' sulgeb kõik avatud failid
Selle peatüki materjalide peale on "Kodutöö nr. 6"
62 / 115
SEITSMES TEEMA: määratud kordus.
eelkontrolliga kordus. järelkontrolliga kordus.Sissejuhatus
Nüüd, kus me oleme tutvunud peaaegu kõigi programmeerimise põhilisemate
ehituskividega - muutuja, avaldise, sisend-, väljund- ja tingimuslausega -, jääb
meil minimaalsest vajalikust komplektist puudu vaid KORDUSLAUSE. Kui
osatakse neid põhilisi ehituskive kasutada, võib kirjutada programme
igasuguste ülesannete lahendamiseks. Kõik ülejäänud 'värvid ja
viled ' on
keeltesse sisse toodud programmeerijate töö lihtsustamiseks ja tööviljakuse
tõstmiseks.
Juba KORDUSLAUSE nimetus ise selgitab tema otstarvet - selle lause abil saab
lasta arvutil täita mingisugust hulka lauseid mitu korda järjest. Millises
olukorras läheb sellist tegevuste kordamist vaja? Toome näiteks eelmisest
teemast
tuttava jada ja ülesande, kus me ühe jadaliikme M[i] korral peame
tagama, et tema väärtus ei oleks negatiivne:
KUI M[i] M[i] := 0
KUILÕPP
Laiendades seda
nõudmist kogu jada peale, peaksime seda tegevust
kordama iga jadaliikmega. Siin me saamegi kasutada korduslauset:
i := 1 -- alustame jada esimesest liikmest
KORDUS SENIKUI i .
algväärtus -> .
lõppväärtus -> .
samm -> .
tegevus -> .
Selle lause võtmesõnana kasutatakse põhiliselt stringi "FOR", mistõttu võidakse
määratud kordusest rääkida ka kui
for-lausest.
Eelkontrolliga kordus
EELKONTROLLIGA KORDUS on korduslause, mille korral täidetakse
etteantud tegevust seni, kui esitatud tingimus on täidetud. Tingimust
kontrollitakse ENNE tegevuse täitmist. Lause täitmise algoritm on järgmine:
A) Kui esitatud tingimus pole tõene, siis lõpetatakse korduslause
täitmine ja juhtimine läheb järgneva lause kätte.
B) Täidetakse korduslause
sisuks olevad laused.
C) Pöördutakse sammu A) juurde tagasi.
Graafiliselt kujutatuna võiks eelkontrolliga kordus välja näha järgmine:
|
V
------------------ jah +---------+
-------> | Tegevus |
------------------ +---------+
| ^ |
| ei | |
| +-----------------+
v
Selle korduslause eripäraks on, et tegevust võidakse teha
0 ... N korda,
kusjuures väärtus
N on sõltuvuses esitatud tingimusest ja ei ole ette määratud.
Üldistatud süntaks eelkontrolliga korduse jaoks on järgmine:
'KORDUS SENIKUI'
'KORDUSELÕPP' .
tingimus -> .
64 / 115
Järelkontrolliga kordus
JÄRELKONTROLLIGA KORDUS on korduslause, mille korral täidetakse
etteantud tegevust vastavalt PÄRAST tegevust esitatud tingimusele.
Lause täitmise algoritm on järgmine:
A) Täidetakse korduslause sisuks olevad laused.
B) Kui esitatud tingimus pole tõene, siis lõpetatakse korduslause
täitmine ja juhtimine läheb järgneva lause kätte.
C) Pöördutakse sammu A) juurde tagasi.
Graafiliselt kujutatuna võiks järelkontrolliga kordus välja näha järgmine:
|
| -----+
----------
|
v
Selle korduslause eripäraks on, et tegevust võidakse teha
1 ... N korda,
kusjuures väärtus
N on sõltuvuses esitatud tingimusest ja ei ole ette määratud.
Põhiline erinevus eel- ja järelkontrolliga korduse vahel on see, et eelkontrolliga
korduse puhul võib jääda tegevus üldse tegemata, aga järelkontrolliga korduse
puhul tehakse seda vähemalt üks kord.
Üldistatud süntaks järelkontrolliga korduse jaoks on järgmine:
'KORDUS'
'KUNI' .
tingimus -> .
Tingimuse kasutamine järelkontrolliga korduslauses võib jääda pisut segaseks
ning sellel on ka põhjus. Ma ei saa
konkreetsemalt rääkida, sest erinevad
keeled kasutavad seda tingimust erinevalt. Näiteks keeles Pascal lõpetatakse
tegevus siis, kui tingimus on tõene ning vastupidisel juhul jätkatakse tegevust.
Keeles C toimitakse vastupidiselt. Kuid see ei ole põhimõtteline erinevus.
Korduslaused keeles Pascal
Määratud korduse süntaks:
'FOR' ':=' ( 'TO' | 'DOWNTO' ) 'DO'
.
Eelkontrolliga korduse süntaks:
65 / 115
'
WHILE ' 'DO'
.
Järelkontrolliga korduse süntaks:
'
REPEAT '
'
UNTIL ' .
tegevus -> [ ] | 'BEGIN' [ ][ ';' ] 'END'.
lausete jada -> [ ';' ].
Korduslaused keeles C
Määratud korduse süntaks:
'for' '(' []';'[] ';' [] ')'
.
initsialiseerimine -> [ ',' | '{' '}' .
Korduslaused keeles Qbasic
Määratud korduse süntaks:
'FOR' ':=' ( 'TO' | 'DOWNTO' ) 'DO'
.
Eelkontrolliga korduse süntaks:
'DO' ( 'WHILE' | 'UNTIL' )
'
LOOP ' |
'WHILE'
'
WEND ' .
Järelkontrolliga korduse süntaks:
'DO'
66 / 115
'LOOP' ( 'WHILE' | 'UNTIL' ) .
Korduslausete kasutamine
Kõige parem on korduslausete kasutamist selgitada näidete kaudu. Võtame ühe
lihtsa ülesande ja kirjutame vastava programmi.
Näide 1. Ü l e s a n n e: Koostada programm, mis leiab sisestatud
arvujada kõige
suurema väärtuse.
Lahenduse
panen ma kirja keeles Pascal: <
Program Jada_Suurim_Vaartus;
Const MaxN = 100;
Var
Jada : array [1..MaxN] of Integer;
N,
Max,
i : Integer; { loendaja }
Begin
Writeln('See programm leiab arvujada suurima väärtuse.')
Write('Palun sisesta jada pikkus : '); Read(N);
For i := 1 to N do { küsime N arvu }
begin
Write('Palun sisesta jada ',i,'. elemendi väärtus : ');
Read(Jada[i]);
end;
Write('
Tänan !
Otsin suurimat väärtust ...');
Max := Jada[1];
For i := 2 to N do {
kontrollin kõiki jadaliikmeid }
if Jada[i] >
Max := Jada[i];
Writeln;
Writeln('Jada suurim väärtus on ', Max);
End.<
Nagu näha, saab iga jadaliiget töödelda
samade lausetega. Korduslause abiga
tagab programmeerija massiivi indeksi muutumise nii, et järjest vaadeldakse
kõiki jadaliikmeid. Tulemuste hoidmiseks kasutatakse harilikke muutujaid,
antud juhul muutujat 'Max'.
Sama programm keeles C :
/* P r o g r a m m i a l g u s */
#include
#
define maxn 100 /*defineerime maksimaalse jada pikkuse */
int main(){
int jada[maxn]; /* arvude massiiv */
int n; /* jada tegelik pikkus */
printf("See programm leiab arvujada suurima väärtuse.\n");
printf("Palun sisesta jada pikkus : ");scanf("%d", &n);
for (int i = 0; i
printf("Tänan! Otsin suurimat väärtust ...\n");
int max = jada[0]; /* alguses võtan suurimaks esimese väärtuse */
for (int i = 1; i if (jada[i] > max) /* kas vaadeldav väärtus on eelmistest suurem */
max = jada[i]; /* kui, on siis jätan meelde */
printf("Jada suurim väärtus on %d", max);
return 0;
/* P r o g r a m m i l õ p p */
Näide 2. Ü l e s a n n e: Kirjutada programm, mis teisendab etteantud tekstifailis olevad
väikesed ladina tähed suurteks ladina
tähtedeks .
Lahenduse idee on lugeda sisendfaili sümbolhaaval ning kui vaadeldav sümbol
on väiketäht, siis teisendada ta suurtäheks.
Kirjutan selle programmi keeles Pascal : <
Program vaiketahed_suurtahtedeks;
var
c : char;
sNimi : string;
vNimi : string;
sf : text; { sisendfail }
vf : text; { väljundfail }
begin
write('Sisesta sisendfaili nimi : ');readln(sNimi);
write('Sisesta väljundfaili nimi : ');readln(vNimi);
assign(sf, sNimi);{$I-}reset(sf);{$I+}
begin
writeln('Sisendfaili ei õnnestunud avada.');
writeln('Palun kontrollige, kas see fail üldse eksisteerib!');
halt;
end;
assign(vf, vNimi);{$I-}rewrite(vf);{$I+}
begin
writeln('Väljundfaili ei õnnestunud luua.');
writeln('Palun kontrollige, ega
ketas pole write-protected!');
halt;
end;
while not eof(sf)
begin
while not eoln(sf)
begin
read(sf, c); { loeme failist sümboli }
write(vf, upCase(c));
end;
readln(sf);
writeln(vf); { kuvame rea lõpu ekraanile }
end;
68 / 115
close(sf);
close(vf);
end.<
Sama programm keeles C :
/* P r o g r a m m i a l g u s */
#include
#include /* vajalik funktsiooni toupper kasutamiseks */
int main(){
char c; /* töödeldav sümbol */
char sNimi[40]; /* sisendfaili nimi */
char vNimi[40]; /* väljundfaili nimi */
FILE *sf; /* sisendfail */
FILE *vf; /* väljundfail */
printf("Sisesta sisendfaili nimi : ");scanf("%s", sNimi);
printf("Sisesta väljundfaili nimi : ");scanf("%s", vNimi);
sf = fopen(sNimi, "r");
if (!sf) //kui sisendfaili avamine ebaõnnestus
vf = fopen(vNimi, "w");
if (!vf) /* kui väljundfaili loomine ebaõnnestus */
while (!feof(sf)) /* kordame, kuni pole jõudnud faili lõppu */
fclose(sf); /* sulgeme failid */
fclose(vf);
return 0;
/* P r o g r a m m i l õ p p */
Selles programmis on kasutatud eelkontrolliga korduslauset eeskätt sellepärast,
et faili pikkus ja seega ka korduste arv ei ole teada. Kui sisendfail on tühi, siis ei
ole vajadust ühtegi sümbolit läbi vaadata.
Näide 3. Ü l e s a n n e: Leida kõik
algarvud , mis on väiksemad kui 1000.
Ma loodan, et Te teate, mis on
algarv . Ja loodetavasti olete Te
kuulnud , mis asi
on Eratosthenese
sõel ? Ei ole?
Niimoodi nimetatakse meetodit, mille abil võibki
leida etteantud naturaalarvust väiksemad algarvud. Vaatame seda siis
lähemalt.
69 / 115
Algarvu definitsioonist selgub, et algarv on ühest suurem ning jagub
parajasti arvuga 1 ja
iseendaga . Kui me nüüd võtame meile antud arvude hulga { 2, ...,
999 } ( arvu 1 ei ole vajadust vaadelda) ja hakkame nende hulgast eemaldama
arve, mis
jaguvad 2-ga, 3-ga, 5-ga ja teiste juba leitud algarvudega, siis
jäävadki alles ainult algarvud. Üksikasjad leiate alljärgnevast Basic-
programmist.
' P r o g r a m m i a l g u s
DIM arv(2 TO 999) AS INTEGER ' vaadeldav arvuhulk
FOR i = 2 TO 999 ' algväärtustame massiivi
arv(i) = 1 ' 1=arv on olemas, 0=arv on
eemaldatud NEXT
jagaja = 2 ' sõel alustab tööd
DO WHILE jagaja
i = jagaja + jagaja
DO WHILE i
arv(i) = 0 ' ja eemaldab jagajaga jaguvad arvud
i = i + jagaja
LOOP
i = jagaja ' seejärel suurendab jagajat
DO
i = i + 1 ' uueks jagajaks on järgmine
LOOP UNTIL arv(i) = 1 ' eemaldamata arv
jagaja = I
LOOP
FOR i = 2 TO 999 ' kui sõel on oma töö lõpetanud, siis
IF arv(i) = 1 THEN ' väljastame kõik allesjäänud arvud
PRINT i;
END IF
NEXT
' P r o g r a m m i l õ p p
Sama programm keeles Pascal : <
Program Eratosthenese_soel;
const maxArv = 999; { sõela suurus }
var
arv : array [2..maxArv] of boolean;
i : integer; //tsüklimuutuja
jagaja : integer;
begin
for i := 2 to maxArv do { algväärtustame massiivi }
arv[i] := true;
jagaja := 2; { sõel alustab tööd }
while jagaja jagaja }
begin
i := jagaja + jagaja;
while i = sqrt(maxArv + 1));
70 / 115
jagaja := i;
end;
for i := 2 to maxArv do { kui sõel on oma töö lõpetanud, siis }
if arv[i] then write(i, ' ');
end.<
Ja nüüd ka keeles C :
/* P r o g r a m m i a l g u s */
#include
#include /* tahame kasutada meetodit sqrt */
#define maxArv 999 /*s õela suurus */
int main(){
bool arv[maxArv - 1]; //vaadeldav arvuhulk
for (int i = 0; i arv[i] = true; /* true - arv on olemas; false - arv on
eemaldatud */
int jagaja = 2; /* sõel alustab tööd */
while (jagaja jagaja */
P := @B; { paigaldame viida muutuja B peale }
Writeln('Nendest arvudest väiksem on ',P^);
end.
Nagu näitest näha võis, kasutatakse aadressi järgi viitamiseks viitmuutujat,
millele järgneb vahetult märk '^'. Selline programm on muidugi teostatav ka
lihtsamalt, kuid see demonstreerib viida kasutamise võimalusi. Dünaamiliste
muutujate kasutamine on aga ilma viitmuutujata raske kui mitte lausa võimatu.
Aga sellest tuleb juttu allpool.
Viitmuutuja kasutamine keeles C
Viitmuutujate tähistamine keeles C on mõnevõrra segadusttekitav, sest selleks
kasutatakse märki '*', mis langeb kokku korrutamise operaatoriga. Seega on
oluline jälgida, et ei tekiks kahemõttelisust ja sinna, kus selline oht on olemas,
tuleb panna sulud.
Viitmuutuja deklareerimine käib järgmiselt:
int *lp; /* lp on
viit täisarvu peale */
Tühja väärtuse määramine viidale toimub kas arvu 0 või eeldefineeritud
konstandi NULL (mis harilikult on pikk täisarv 0 ehk (long int)(0)) omistamisega:
lp = NULL;
Olemasoleva muutuja X aadressi omistamine viidale toimub operaatori '&' abil:
lp = &X;
Ja kirjutame eespool esitatud programmi keele C:
/* N8_1_C */
#include
main()
/* lõpp */
Mälu paindlik kasutamine
Ei ole
harvad sellised ülesanded, mida saab täita mitmes osas ja millest iga osa
vajab suurt hulka mälu. Kui lahendada ülesanne staatiliste muutujatega, see
tähendab selliste muutujatega, mille jaoks reserveeriti mälu programmi töö
alguses ja nad eksisteerivad kuni programmi lõppemiseni, siis võib meil mälust
puudus tulla. Üks võimalik lahendusvariant on selline, et vajaminevad
muutujad luuakse vahetult enne seda, kui neid kasutama hakatakse ja siis, kui
neid enam vaja ei ole, kaotatakse nad ära. Selliseid muutujaid nimetataksegi
DÜNAAMILISTEKS MUUTUJATEKS.
Mälu hõivamine
Dünaamilise muutuja tekitamine algab muutuja jaoks mälu küsimisega. Mälu
võib küsida,
andes ette konkreetse arvu (baitides) või andmetüübi. Kui küsitud
hulk vaba mälu on veel olemas, siis hõivatakse see ja vastav aadress
omistatakse viitmuutujale.
Mälu hõivamiseks on programmeerimiskeeles spetsiaalsed funktsioonid.
Kindlasti eksisteerib konkreetse suurusega mäluala hõivamise funktsioon.
Keeles Pascal on selleks protseduur GETMEM, mille deklaratsioon on järgmine:
procedure GetMem(var P: Pointer; Suurus: Word);
Kasutades seda protseduuri võib hõivata mälu 'Suurus' arv baite ja aadressi
omistada viitmuutujale P. Tüüp 'Pointer' on puhas viidatüüp.
Keeles C on selleks funktsioon MALLOC, mille deklaratsioon on järgmine:
void *malloc( size_t suurus );
Funktsioon
tagastab puhta viidatüüpi (void *) väärtuse 'suurus' arv baite
sisaldavale mäluosale.
Teine liik mälu hõivamise funktsioone on seotud konkreetse andmetüübiga.
Keeles Pascal on selleks protseduur New:
procedure New(var P: Pointer);
See protseduur uurib järele viida P tegeliku tüübi ja eraldab mälu vastavalt
tüübi suurusele. Näiteks täisarvu viida tüübi korral eraldatakse mälu ühe
täisarvu hoidmiseks.
Keeles C "tüübiga" mäluhõivamist ei ole, see on lisatud keele C++ süntaksile.
Võib tekkida küsimus, et "mis saab siis, kui vaba mälu ei ole?". Programmi
käitumine sellises situatsioonis sõltub keelest ja translaatori versioonist. Pascali
puhul võib ette tulla nii väärtuse 'Nil' tagastamist kui ka veateadet. Keeles C on
üldiselt tavaks tagastada tühi väärtus, mida saab sellisel juhul kontrollida ja
75 / 115
valida vastav käitumine.
Mälu vabastamine
Kui dünaamilised muutujad on oma töö teinud, siis on ilus nad ära kaotada ja
vabastada nende jaoks hõivatud mälu. Selle jaoks on olemas vastavad
protseduurid. Keeles Pascal on nendeks:
procedure FreeMem(var P: Pointer; Suurus: Word);
procedure Dispose(var P: Pointer );
FreeMem vabastab GetMem'iga hõivatud mälu, kusjuures arv 'Suurus' peab
olema sama, ja Dispose vabastab protseduuriga New hõivatud mälu.
Keeles C on mälu vabastamiseks funktsioon FREE:
void free(void *viit);
Vaatame siinkohal samasisulisi näiteprogramme nii Pascalis kui ka C-s, kus
toimub mälu hõivamine ja vabastamine.
Ü l e s a n n e: Sisestada üks rida teksti ja leida reas olevate tühikute arv.
Program N8_2_P;
Var
S : ^String; { viitmuutuja }
i, n : Integer;
begin
Writeln('Palun sisesta üks rida teksti:');
GetMem(S, 81); { küsime 81 baiti mälu }
Readln(S^);
n := 0; { n on tühikute
loendur , algväärtuseks on 0 }
For i := 1 to
Length (S^) do { vaatame kõiki märke reas }
If S^[i] = ' ' then { ja kui märk on tühik }
n := n + 1; { siis suurendame loendurit ühe võrra }
FreeMem(S, 81);
Writeln('Selles reas on ', n, ' tühikut.');
end.
/* N8_2_C */
#include
#include
#include
main()
else /* kui liikme info jaoks mälu ei jätkunud */
}
}
} while (strcmp(S, "0") && LV != NULL);
if (LV == NULL)
printf("Mälu sai otsa.\n");
printf("Alustan väljastamist\n");
LV = Pinu;
while (LV != NULL)
printf("See on kõik!\n");
return 0;
}
Selles näites on kasutatud kaheetapilist mäluvõtmist -
kõigepealt pinumälu
lülile ja siis jadaliikme infole. Järgmine joonis annab sellisest struktuurist hea
ülevaate:
Pinu
|
V
+-----+ +-----+ +-----+ +-----+
| 4 |--->| 3 |--->| 2 |--->| 1 |--->|
+-----+ +-----+ +-----+ +-----+
| | | |
V V V V
Info Info Info Info
83 / 115
Ja nüüd sama programm keeles Pascal : <
Program N8_4_P;
type
PLyli = ^Lyli;
Lyli = record
Liige : ^string;
Jargmine : PLyli;
end;
var
Pinu, LV : PLyli;
S : string[80];
begin
Pinu := nil;
Writeln('Jada
liikmeteks võivad olla suvalised tekstiread.');
Writeln('Lõpu tunnuseks on 0.');writeln;
Writeln('Alustan jada sisestamist');
Repeat
Write('>');Readln(s);
If S '0' then
begin
New(LV); { võtame lüli jaoks mälu }
if LV nil then
begin { küsime ka liikme jaoks mälu }
GetMem(LV^.Liige, length(s));
If LV^.Liige nil then
begin
LV^.Liige^ := S; { salvestame liikme info }
LV^.Jargmine := Pinu;
Pinu := LV;
end
else
begin
Dispose(LV);
LV := nil;
end;
end;
end;
Until (S = '0') or (LV = nil);
If LV = nil then
Writeln('Mälu sai otsa!');
Writeln('Alustan väljastamist');
LV := Pinu;
While LV nil do
begin
Writeln(LV^.Liige^);
Pinu := LV^.Jargmine; { võtame järgmise pealmiseks }
FreeMem(LV^.Liige, length(LV^.Liige^));
Dispose(LV);
LV := Pinu;
end;
Writeln('See on kõik.');
end.<
Selle peatüki materjalide peale on "Kodutöö nr. 8"
84 / 115
85 / 115
ÜHEKSAS TEEMA: alamprogrammid.
protseduur ja funktsioonMilleks on vaja alamprogramme?
Neljandas teemas käsitlesime standardprotseduure andmete sisestamiseks ja
väljastamiseks. Seekord vaatame alamprogramme
üldisemalt ja tutvume
sellega, kuidas neid ise kirjutada.
Tüüpiliselt on vaja kasutada alamprogramme siis, kui
samasisuline tegevus
(ehk
samasugune käskude jada) esineb programmis kahes või enamas kohas.
Sellega me taotleme, et programm tuleks võimalikult lühikene. Kuid see ei ole
ainus põhjus. Tihti on otstarbekas jagada programm loogilisteks üksusteks
parema loetavuse huvides. Kui kogu programmi
pikkuseks on
tuhat rida ja see
kõik paikneb põhiprogrammis, siis selle programmi tekst on äärmiselt raskesti
loetav . Selline loogilisteks üksusteks eraldamine käib harilikult käsikäes
ülesande lahendamiseks vajalike algoritmide valimise ja kombineerimisega.
Näiteks me teame, et ülesande lahendamine eeldab andmete sisestamist,
töötlemist ja vastuse väljastamist. Seetõttu võiks põhiprogramm välja näha
järgmine:
Programm
Andmete_Sisestamine
Andmete_Töötlemine
Vastuse_Väljastamine
Lõpp
Järgnevalt võib vaadata iga osa (ehk protseduuri) lähemalt ja leida nendes
terviklikke tegevusi, mida võib samuti vormistada protseduuridena. Millal
selline tegevus lõpetada? See sõltub konkreetsest programmi kirjutajast.
Tavaliselt piisab, kui ühe protseduuri pikkus on umbes 20 rida (mahub ekraanile
ära ;). See ei ole mingisugune reegel, aga üle 20-realiste protseduuride
olemasolul peaks olema põhjendus.
Selliselt 'tükeldatud' programme on kergem lugeda ja
vigade otsimine on
samuti lihtsam, sest vea tekkimise koht on tihti lokaliseeritav protseduuri
täpsusega.
Protseduuri ja funktsiooni erinevused
Nii protseduur kui ka funktsioon on alamprogrammid. Nende põhiliseks
erinevuseks on täidetav ülesanne.
Protseduur on keele konstruktsioon,
mille abil võib sooritada programmi osadeks jaotamist ja korduvalt
kasutatava tegevuse defineerimist. Põhimõtteliselt võib protseduur
sisaldada mistahes ülesande lahendamiseks vajalikku programmiosa.
Protseduuri kasutamine toimub
omaette lausega, mis siis nagu laiendaks keele
86 / 115
lausete hulka.
Funktsioon on mõnevõrra spetsiifilisem alamprogramm. Olles
oma
struktuurilt sarnane protseduuriga, on tema ülesandeks mingisuguse
väärtuse väljaarvutamine. Tõsi küll, selle väärtuse leidmise käigus võib ta teha
kõike
sedasama , mis protseduurgi. Funktsiooni kasutatakse harilikult
avaldistes.
Kas ainult ühe alamprogrammi liigiga ei saaks hakkama? Saab küll, sest näiteks
keeles C on ainult funktsioonid (meetodid). See on saavutatud mõninga
ranguse kaotamisega - programm ei pea funktsiooni poolt leitud väärtust
kasutama - ning sellest tuleneb, et programmeerija peab ise täpselt teadma,
mida ta teeb. Teised meie poolt vaadeldavad keeled - Pascal ja Qbasic - teevad
protseduuride ja funktsioonide vahel ranget vahet.
Alamprogrammide kasutamine
Alamprogrammidega on programmi koostamisel seotud kaks tegevust:
alamprogrammi
deklareerimine ja
väljakutsumine . Deklareerimise abil anname
me teada alamprogrammi olemasolu - nime,
parameetrid ja funktsionaalsuse,
väljakutsumine on teiste sõnadega konkreetse alamprogrammi kasutamine.
Sõltuvalt keeltest ja translaatoritest kaasneb alamprogrammide
deklareerimisega mitmesuguseid nüansse, mida ma siinkohal ei käsitle ja tuleb
vajaduse korral raamatutest välja otsida.
Pascal
PROTSEDUURI DEKLAREERIMISE SÜNTAKS:
'PROCEDURE' [ ] ';'
[ ]
'BEGIN'
'END' ';' .
protseduuri_nimi -> .
formaalsed_parameetrid -> '(' ')' .
deklaratsioonid -> [ ] .
deklaratsioon ->
| |
| .
parameetri_deklaratsioonid ->
[ ';' ] .
parameetri_deklaratsioon ->
|
.
sisendparameetri_deklaratsioon ->
':' .
sisend-väljundparameetrideklaratsioon ->
'VAR' ':' .
identifikaatorite_jada ->
[ ',' ] .
87 / 115
Näide: Procedure Vaheta( var a, b : Integer );
var c : Integer;
begin
c := a; a := b; b := c;
end;
FUNKTSIOONI DEKLAREERIMISE SÜNTAKS:
'
FUNCTION ' [ ]
':' ';'
[ ]
'BEGIN'
'END' ';' .
väärtuse_tüüp -> | .
Näide: Function Max( a, b : Integer ) : Integer;
begin
If a > b then
Max := a
else
Max := b
end;
PROTSEDUURI VÄLJAKUTSUMISE SÜNTAKS:
[ ] ';' .
tegelikud_parameetrid -> '(' ')' .
parameetrite_jada -> [ ',' ] .
parameeter -> | .
sisendparameeter -> .
sisend-väljundparameeter -> .
Näide:
Vaheta(k, l);
FUNKTSIOONI VÄLJAKUTSUMISE SÜNTAKS:
[ ] .
Näide: M := Max(i, j);
C
Juba eespool sai
mainitud , et keeles C puuduvad protseduurid. Nende asemel
on olemas funktsioonid(meetodid), mille väärtuse tüüp on 'void' (tühi).
FUNKTSIOONI DEKLAREERIMISE SÜNTAKS:
'(' [ ] ')'
[ ]
88 / 115
parameetrite_nimed -> [ ',' ] .
parameetrite_deklaratsioonid ->
[ ] .
parameetri_deklaratsioon -> ';' .
Näide: int Max( a, b )
int a, b;
if ( a > b)
return a;
else
return b;
FUNKTSIOONI VÄLJAKUTSUMISE SÜNTAKS:
'(' [ ] ')' .
Näide: M = Max(i, j);
Qbasic
PROTSEDUURI DEKLAREERIMISE SÜNTAKS:
'SUB' [ '(' ')' ]
'END' 'SUB' .
formaalsed_parameetrid ->
[ '(' ')' ] ['AS' ] [',' ] .
Näide: SUB Vaheta ( a AS INTEGER, b AS INTEGER )
c = a
a = b
b = c
END SUB
FUNKTSIOONI DEKLAREERIMISE SÜNTAKS:
'FUNCTION' [ '(' ')' ]
[ ]
=
[ ]
'END' 'FUNCTION' .
Näide:
FUNCTION Max ( a AS INTEGER, b AS INTEGER )
89 / 115
IF a > b THEN
Max = a
ELSE
Max = b
ENDIF
END FUNCTION
Parameeter
Enne, kui hakkan selgitama mõningaid mõisteid,
esitan ma ühe keeles Pascal
kirjutatud näiteprogrammi, kus on kasutatud nii protseduure kui ka funktsioone
koos parameetritega ja ilma.
Ü l e s a n n e: On antud N (b);
3. täidetakse protseduuri tegevustik, mille tulemusena
a ja
b väärtused
vahetavad omavahel koha ning kuna
X ja
Y on nende parameetritega
seostatud , siis vahetavad ka
X ja
Y oma väärtused;
4. pärast protseduuri lõppu antakse programmi täitmise
järg tagasi
protseduuri väljakutsunud programmiosale, täpsemalt protseduuri
väljakutsele järgnevale käsule.
Kui selleks käsuks on näiteks
Writeln( X:4, Y:4 );
siis väljundina ekraanil näeksime järgmist arvupaari:
20 10
Globaalsed ja lokaalsed muutujad
Alamprogrammide kasutamisega kaasneb teisigi olulisi mõisteid. Nendeks
uuteks mõisteteks on MUUTUJATE TEGEVUSPIIRKOND, GLOBAALNE ja
LOKAALNE MUUTUJA.
Muutuja tegevuspiirkonna määratleb ära tema deklareerimise koht. Tavaliselt
on nii, et globaalsed muutujad deklareeritakse väljaspool kõiki programmi
käsuridasid sisaldavaid osi, enne alamprogramme ja põhiprogrammi. Lokaalsed
muutujad deklareeritakse alamprogrammi alguses.
Globaalse muutuja tegevuspiirkond ulatub alates tema deklareerimise kohast
üle kogu ülejäänud programmi. See tähendab, et kõik sellesse piirkonda jäävad
alamprogrammid ja põhiprogramm saavad seda muutujat kasutada.
Lokaalse muutuja tegevuspiirkonnaks on see alamprogramm, milles ta on
deklareeritud. Seda muutujat saab kasutada ainult selle alamprogrammi sees
ning teiste alamprogrammide ja põhiprogrammi jaoks seda muutujat ei
eksisteeri. Tihti on tõsi ka see, et lokaalne muutuja eksisteerib ainult selle
alamprogrammi tööaja jooksul, kuhu ta ka ise kuulub. Selles mõttes on
alamprogrammide
formaalsed parameetrid samuti lokaalsed muutujad, mille
initsialiseerimine toimub alamprogrammi töö alguses vastavate tegelike
parameetrite väärtustega.
Üks arusaamatust tekitav situatsioon globaalsete ja lokaalsete muutujate
kasutamisel sisaldub järgmises näites: <
Program N9_2;
95 / 115
Var A, B, N : Integer; { need siin on globaalsed muutujad }
Function AritmSumma(X, Y, Z : Integer) : Integer;
Var I, D, N : Integer; { need on lokaalsed muutujad }
begin
N := X;
D := Y - N;
I := 1;
While I begin
N := N + X + I * D;
I := I + 1;
end;
AritmSumma := N
end;
begin
Write('Palun sisesta aritmeetilise jada esimene liige :');
ReadLn(A);
Write('Palun sisesta aritmeetilise jada teine liige :');
ReadLn(B);
Write('Palun sisesta aritmeetilise jada liikmete arv :');
ReadLn(N);
Writeln('Selle aritmeetilise jada ', N, ' liikme summa on ',
AritmSumma(A,B,N));
readln;
end.<
Sama programm keeles C :
/* P r o g r a m m i a l g u s */
/* N9_2 */
#include
int a, b, n; /* need siin on globaalsed muutujad */
int aritmSumma(int x, int y, int z){
/* need on lokaalsed muutujad */
int n = x; /* n? Aga kumb - lokaalne või globaalne? */
int d = y - n;
int i = 1;
while (i
n += x + i * d; /* leidmiseks halb algoritm */
i++;
}
return n; /* aga see töötab siiski! */
int main(){
printf("Palun sisesta aritmeetilise jada esimene liige : ");
scanf("%d", &a);
printf("Palun sisesta aritmeetilise jada teine liige : ");
scanf("%d", &b);
printf("Palun sisesta aritmeetilise jada liikmete arv : ");
scanf("%d", &n);
printf("Selle aritmeetilise jada %d liikme summa on %d\n", n,
aritmSumma(a, b, n));
scanf("%d", &n);
/* P r o g r a m m i l õ p p */
Tuleb endale meelde jätta, et lokaalne muutuja on alati
kõrgema
prioriteediga ehk kui eksisteerib lokaalse muutujaga samanimeline globaalne
muutuja, siis seda ei ole
'näha'! Piltilikut väljendudes on lokaalne muutuja
96 / 115
lähemal ja kui juhtub nii, et toimub tegevuspiirkondade kattumine, siis käib
lähemal olija võim üle.
Ülevaade standardprotseduuridest ja -funktsioonidest
Meie poolt vaadeldavate keelte translaatoritega käivad harilikult kaasas
alamprogrammide teegid, milles
sisalduvaid protseduure ja funktsioone
nimetatakse
standardprotseduurideks ja -
funktsioonideks. Sisestamise ja
väljastamisega seotud standardprotseduure me juba
tunneme . Järgnevalt teen
ma väikese valiku enam vajaminevatest alamprogrammidest, kusjuures ma
ainult loetlen üles nende nimed ja otstarve. Põhjalikumalt saab lugeda
vastavate translaatorite raamatutest või abifailidest.
Pascal
Aritmeetilised funktsioonid
Abs (function) absoluutväärtuse leidmine
ArcTan (function) arkustangensi arvutamine
Cos (function) koosinuse arvutamine
Exp (function) eksponendi arvutamine
Frac (function) reaalarvu fraktsiooni leidmine
Int (function) reaalarvu täisosa leidmine
Ln (function) naturaallogaritmi leidmine
Pi (function) tagastab Pii väärtuse
Sin (function) siinuse arvutamine
Sqr (function) parameetri ruudu leidmine
Sqrt (function) ruutjuure leidmine
Mälu
dünaamiline haldamine Dispose (procedure) vabastab hõivatud mälu
FreeMem (procedure) vabastab hõivatud mälu
GetMem (procedure) hõivab mälu
New (procedure) hõivab mälu
MaxAvail (function) suurima hõivatava mälubloki suurus
MemAvail (function) kogu vaba mälu suurus
Programmi täitmise kontrolliprotseduurid
Exit (procedure) lõpetab antud taseme alamprogrammi täitmise
Halt (procedure) lõpetab programmi täitmise
RunError (procedure) genereerib etteantud
veaolukorra Failide haldamise protseduurid ja funktsioonid
Assign (procedure) initsialiseerib failimuutuja
Assigned (function) kontrollib pointeri väärtustatust
ChDir (procedure)
vahetab aktiivset
kataloogi Close (procedure) suleb avatud faili
Eof (function) kontrollib faililõpu sümboli
esinemist Erase (procedure)
kustutab välise faili
FilePos (function)
teatab positsiooni failis
FileSize (function) teatab faili suuruse
97 / 115
GetDir (procedure) teatab aktiivse kataloogi
IOResult (function) teatab viimase operatsiooni tulemuse
MkDir (procedure) tekitab uue kataloogi
Rename (procedure) nimetab faili ümber
Reset (procedure) avab faili lugemiseks
Rewrite (procedure) avab faili kirjutamiseks
RmDir (procedure) kustutab kataloogi
Seek (procedure) seab uue positsiooni failis
Truncate (procedure)
defineerib momendi positsiooni faili lõpuks
Mitmesugust
Exclude (procedure) eemaldab elemendi hulgast
FillChar (procedure) täidab etteantud ala etteantud sümboliga
Hi (function) tagastab argumendi vanema baidi
High (function) tagastab vastava kõrgeima väärtuse
Include (procedure) lisab elemendi hulgale
Lo (function) tagastab argumendi noorema baidi
Low (function) tagastab vastava madalaima väärtuse
Move (procedure) kopeerib mälus baite
ParamCount (function) tagastab käsurea parameetrite arvu
ParamStr (function) tagastab vastava käsurea parameetri
Random (function) tagastab juhusliku arvu
Randomize (procedure) käivitab juhuslike arvude generaatori
SizeOf (function) tagastab argumendi suuruse
Swap (function) tagastab 'tagurpidipööratud' baidi
UpCase (function) tagastab suure tähe
Ordinaalsed protseduurid ja funktsioonid
Dec (procedure) vähendab parameetrit ühe võrra
Inc (procedure) suurendab parameetrit ühe võrra
Odd (function) teatab, kas argument on paaritu arv
Pred (function) tagastab ühe võrra väiksema väärtuse
Succ (function) tagastab ühe võrra suurema väärtuse
Viitade ja
aadresside funktsioonid
Addr (function) teatab parameetri aadressi
CSeg (function) tagastab koodisegmendi väärtuse
DSeg (function) tagastab andmesegmendi väärtuse
Ofs (function) tagastab aadressi alamosa
Ptr (function) tagastab moodustatud aadressi viidana
Seg (function) tagastab aadressi segmendi
SPtr (function) tagastab pinumäluviida väärtuse
SSeg (function) tagastab pinusegmendi väärtuse
Stringitöötlemise protseduurid ja funktsioonid
Concat (function) liidab
stringid kokku
Copy (function) tagastab osa stringist
Delete (procedure) kustutab osa stringist
Insert (procedure) lisab ühe stringi teise sisse
Length (function) tagastab stringi pikkuse
Pos (function) tagastab otsitava stringi asukoha teises
Str (procedure) konverteerib numbri stringiks
Val (procedure) konverteerib stringi numbriks
Tekstifaili protseduurid ja funktsioonid
Append (procedure) avab faili lisamiseks
98 / 115
Eoln (function) kontrollib realõpu sümboli esinemist
Flush (procedure) tühjendab puhvri
Read (procedure) loeb failist
Readln (procedure) loeb failist ühe rea
SeekEof (function) seab positsiooni faili lõppu
SeekEoln (function) seab positsiooni rea lõppu
SetTextBuf (procedure) puhvri initsialiseerimine
Write (procedure) kirjutab faili
Writeln (procedure) kirjutab faili ühe rea
Teisendamisfunktsioonid
Chr (function) teisendab numbri märgiks
Ord (function) tagastab ordinaartüüpi väärtuse järjenumbri
Round (function) ümardab reaalarvu täisarvuks
Trunc (function) leiab reaalarvu täisarvulise täisosa
C
Keele C teekidest on võimalik leida samasuguseid funktsioone, kui Pascali
teekidest. Veelgi enam, seal on funktsioonide valik märksa laiem. Selle näiteks
on väljavõte aritmeetilistest funktsioonidest:
acos, acosl arvutab arkuskoosinust
asin, asinl arvutab arkussiinust
atan, atanl arvutab arkustangensit
atan2, atan2l arvutab arkustangensit
Bessel arvutab Besseli funktsiooni
_cabs, _cabsl leiab kompleksarvu absoluutväärtuse
ceil, ceill leiab ümardatud täisarvu
cos, cosl arvutab koosinuse
cosh, coshl arvutab
koosinus hüperbolicuse
div
jagab täisarve ning tagastab tulemuse ja jäägi
exp, expl arvutab eksponenti
fabs, fabsl leiab absoluutväärtuse
fmod, fmodl leiab reaalarvulise jäägi
frexp, frexpl arvutab eksponenti
log, logl arvutab naturaallogaritmi
log10, log10l arvutab 10-nendlogaritmi
_matherr, _matherrl käsitleb veasituatsioone
__max, __min tagastab maksimaalse (minimaalse) vääruse
modf, modfl jagab argumendi täis- ja murdosaks
pow, powl arvutab argumendi astme
rand tagastab pseudojuhusliku arvu
sin, sinl arvutab siinuse
sinh, sinhl arvutab
siinus hüperbolicuse
sqrt, sqrtl leiab ruutjuure
srand initsialiseerib juhuslike arvude generaatori
tan, tanl arvutab
tangensi tanh, tanhl arvutab
tangens hüperbolicuse
Qbasic
Aritmeetilised funktsioonid
99 / 115
ABS arvutab absoluutväärtuse
ATN arvutab arkustangensi
CDBL teisendab väärtuse topelttäpsusega reaalarvuks
CINT ümardab täisarvuks
CLNG ümardab pikaks täisarvuks
COS arvutab koosinuse
CSNG teisendab ühekordse täpsusega reaalarvuks
CVDMBF teisendab reaalarvu
formaati CVSMBF teisendab reaalarvu formaati
EXP arvutab eksponenti
INT leiab täisosa
LOG arvutab naturaallogaritmi
RANDOMIZE initsialiseerib juhuslike arvude generaatori
RND tagastab juhusliku arvu
SGN tagastab argumendi märgi
SIN arvutab siinust
SQR arvutab ruutjuure
TAN arvutab tangensi
TIME$ tagastab (seab) süsteemse aja
DOS failisüsteemi protseduurid
CHDIR vahetab kataloogi
KILL kustutab faili
MKDIR tekitab uue kataloogi
NAME nimetab faili ümber
RMDIR kustutab kataloogi
Faili käsitlemise protseduurid ja funktsioonid
CLOSE sulgeb faili
EOF kontrollib faililõpu sümboli esinemist
FILEATTR tagastab faili
atribuudid FREEFILE tagastab vaba failinumbri
GET (File I/O) loeb failist
INPUT loeb klaviatuurilt või failist
INPUT$ loeb failist stringi
LINE INPUT loeb klaviatuurilt või failist rea
LOC tagastab positsiooni failis
LOCK lukustab faili
LOF tagastab faili pikkuse
OPEN avab faili
PUT (File I/O) kirjutab faili
SEEK seab positsiooni failis
UNLOCK vabastab faili lukust
WRITE kirjutab faili
Mälu haldamise funktsioonid
CLEAR vabastab ja initsialiseerib süsteemse mälu
FREE tagastab vaba mälu suuruse
PEEK loeb mälupesast väärtuse
POKE kirjutab mälupessa väärtuse
Stringitöötluse protseduuri ja funktsioonid
ASC tagastab stringi esimese märgi ASCII koodi
CHR$ teisendab arvu märgiks
HEX$ tagastab arvu kuueteistkümnendkuju
INSTR tagastab stringi positsiooni teises stringis
LCASE$ teisendab väikesteks tähtedeks
100 / 115
LEFT $ tagastab esimese märgi stringist
LEN tagastab stringi pikkuse
LSET vahetab andmeid failipuhvriga
LTRIM$ eemaldab tühikud stringi eest
MID$ loeb stringist alamstringi
OCT$ tagastab arvu kaheksandkuju
RIGHT$ tagastab viimase märgi stringist
RSET vahetab andmeid failipuhvriga
RTRIM$ eemaldab tühikud stringi lõpust
SPACE$ tagastab stringi etteantud hulga tühikutega
STR$ teisendab arvu stringiks
STRING$ tagastab stringi etteantud arvu märkidega
UCASE$ teisendab suurteks tähtedeks
VAL teisendab stringi arvuks
Selle peatüki materjalide peale on "Kodutöö nr. 9"
101 / 115
KÜMNES TEEMA: Programmide
vormistamine. 1. Milleks on vaja programme hästi vormistada?
Kas Te olete kunagi proovinud lugeda teise inimese poolt kirjutatud pro-
grammi või otsinud sellest vigu? Kui ei ole, siis kunagi kindlasti tuleb
esimene kord. Ja kui see on Teie enda kolm kuud või enam aega tagasi
kirjutatud programm, siis on see peaaegu samaväärne võõra
tekstiga , sest
pea pole prügikast ja kõik ununeb.
Sellisel juhul sõltub programmist arusaamine otseselt programmi vormis-
tamisest. Hästi
vormistatud programm on loetav ja ülevaatlik, halva vor-
mistuse korral kulub programmiga tutvumisele mitu korda rohkem aega ja
lugeja peab olema VÄGA kannatlik, et saada aru programmi tööpõhimõttest.
Puudulik
vormistus muidugi ei tähenda, et programm töötaks halvasti,
sest arvuti ei
pööra programmi sellele aspektile üldse tähelepanu (kui
seda ei nõua keele süntaks).
Toon siinkohal ühe näite spetsiaalselt halvasti vormistatud programmist,
mis sellegipoolest on täiesti töökõlblik.
/* P r o g r a m m N10.1 - World.c */
main(l
,a,n,d)char**a;{
for(d=atoi(a[1])/10*80-
atoi(a[2])/5-596;n="@NKA\
CLCCGZAAQBEAADAFaISADJABBA^\
SNLGAQABDAXIMBAACTBATAHDBAN\
ZcEMMCCCCAAhEIJFAEAAABAfHJE\
TBdFLDAANEfDNBPHdBcBBBEA_AL\
H E L L O, W O R L D! "
[l++-3];)for(;n-->64;)
putchar(!d+++33^
l&1);}
See programm tahab töötamiseks kahte arvulist parameetrit, näiteks:
> world 58 26
Mida see programm küll teha võiks? ;-)
Korraliku vormistamise eesmärgiks on keele enda vahenditega kirjutada
hästi loetav programm. Kui on vaja selgitada kasutatava algoritmi sisu-
lisi nüansse, siis selleks kasutatakse kommentaare. Paljusid lihtsaid
algoritme võib protseduuriks või funktsiooniks vormida ilma sõnagi
kommentaariks lisamata.<
Type
Arvujada = Array[1..100] of Integer;
Function ArvujadaSumma
( Jada : Arvujada;
LiikmeteArv : Integer )
102 / 115
: LongInt;
Var
Summa : Longint;
Indeks : Integer;
Begin
If LiikmeteArv > 100 Then
LiikmeteArv = 100;
Summa := 0;
For Indeks := 1 To LiikmeteArv Do
Summa := Summa + Jada[Indeks];
ArvujadaSumma := Summa;
End;
Mis teeb ühe programmi hästi
loetavaks ? Selle kohta võib leida mitmeid
soovitusi:
1) Kirjutage programm nii lihtsalt ja arusaadavalt kui võimalik, hoiduge
kavalatest nippidest. Seda nimetatakse
KISS -printsiibiks (inglise kee-
lest 'Keep It
Simple , Stupid').
2)
Kasutage iseennast selgitavaid identifikaatoreid.
3) Struktrueerige oma programmi, kasutades tühje ridu, taandeid ja tabu-
laatoreid.
4) Kasutage mõistlikult kommentaare.
Igal programmeerijal kujuneb aja jooksul välja oma 'käekiri', millest
suur osa
kajastub programmi vormistamise harjumustes - programmeerija
STIILIS. Hea vormistus on hea stiili tunnuseks.
Kommentaaride kasutamisest teen ma juttu järgmises teemas, seekord vaat-
leme lähemalt identifikaatoreid ja taanete kasutamist.
2. Identifikaatorite süstematiseerimine. Iga identifikaatori kohustuslikuks osaks peaks olema string, mis viitab
identifikaatori SISULISELE tähendusele - see on ennastselgitavuse alu-
seks. Kui meil on vaja valida nimi muutujale, milles hoitakse väärtust
pikkuse kohta, siis peaks
valima mõne järgmistest nimedest: Pikkus,
Length, Pikk, Len, P, L. Esimesed on paremad, viimaseid võib kasutada
mõningate mööndustega. Võib kasutada ka võõrkeelseid nimetusi ja nendest
tuletatud lühendeid. On hea, kui sisuliselt erinevate muutujate nimed ei
ole väga sarnased.
Suurte programmide korral, kus kasutuses on sadu ja tuhandeid identifi-
kaatoreid, tahetakse neid lisaks
sisule süstematiseerida ka tegevuspiir-
konna ja tüübi järgi.
Näiteks tegevuspiirkonna määratlemiseks kasutatakse eesliiteid 'l', 'g'
ja 'a' vastavalt sellele, kas tegemist on lokaalse või globaalse muutu-
jaga või parameetriga:
'lTabel' - lokaalne muutuja;
'gTabel' - globaalne muutuja;
'aTabel' - parameeter.
Defineeritud konstantide eesliitena on kasutatav täht 'k' või 'c':
'cMaxValue' - konstant.
Kui on tahtmine näidata muutuja nimega ka muutuja tüüpi, siis võib keh-
testada vastava 'kooditabeli'. Näiteks
Microsoft järgib oma toodetes
103 / 115
'Ungari notatsiooni', mille koostas firma programmeerija Charles Simonyi
(kes on rahvuselt ungarlane). Mõned näited:
nPikkus : Integer;
sNimi : String;
wMask : Word;
Pole tähtis, kuidas Teie süstematiseerite oma identifikaatoreid, tähtis
on vaid see, et kogu programmi ulatuses on tähistus ühesugune.
3. Taanete kasutamine.Kui vaadelda programmi üldises mõttes, siis see koosneb käskude jadast,
milles mõned
käsud (nagu valikud ja kordused) võivad sisaldada omakorda
käsujadasid. Programmi
lugedes tunneme me harilikult huvi selliste suu-
remate struktuuride algus- ja lõpp-punktide vastu.
Kujutage nüüd endale
ette sadu ridasid programmi, mille kõik read algavad esimesest positsi-
oonist. See on siis midagi sellist:<
For i := 1 To N-1 Do
For j := i To N Do
If A[i]
begin
V := A[i];
A[i] := A[j];
A[j] := V
end;
Sellisest ühtlasest jadast on väga raske leida mingisuguse struktuuri
algust ja lõppu. Kui nüüd sellise programmi kompileerimisel ilmneb, et
kuskil on üks 'end' puudu, siis ei jäägi muud üle, kui asuda kõiki
võt -
mesõnu 'begin' ja 'end' omavahel 'paari
panema '. Ja
selliseks struktuuri
esiletõstmiseks kasutatakse TAANDEID.
Üldine reegel seisneb selles, et STRUKTUURI SISSE JÄÄVATE LAUSETE
ALGU -
SED NIHUTATAKSE VÄHEMALT ÜHE KOHA VÕRRA PAREMALE. Tavaliselt on nihke
suuruseks 2 kuni 4 kohta.
Vahel
tekkib küsimus, et kuhu kirjutada need võtmesõnad 'begin' ja
'end'? See on mõningas mõttes maitse asi ja siin on kolm võimalust -
mitte nihutada, nihutada poolikult ja nihutada täielikult. Vaatame neid
variante:<
For i := 1 To N-1 Do
For j := i To N Do
If A[i]
begin
V := A[i];
A[i] := A[j];
A[j] := V
end;<
For i := 1 To N-1 Do
104 / 115
For j := i To N Do
If A[i] begin
V := A[i];
A[i] := A[j];
A[j] := V
end;<
For i := 1 To N-1 Do
For j := i To N Do
If A[i]
begin
V := A[i];
A[i] := A[j];
A[j] := V
end;
Märksa tähtsam on see, et üksteises sisalduvad
struktuurid on selgelt
eristatud : esimene määratud kordus sisaldab teist määratud kordust ja
see omakorda valikuliselt täidetavat käsujada.
Siinkohal tahaksin
soovitada ühte programmi kirjutamise võtet, mis tagab
selle, et ükski 'end' ära ei unune. Nimelt, alati, kui
kirjutate 'begin', kirjutage kohe järgmisele reale temaga paaris olev 'end' ja
alles seejärel kirjutage nende kahe vahele vajaminevad laused. Pisiasi,
kuid oluline.
105 / 115
ÜHETEISTKÜMNES TEEMA: programmi
dokumenteerimine. kommentaaridPROGRAMMI PROJEKTEERIMINE JA TESTIMINE1. Kellele ja milleks on vaja dokumentatsiooni?
Iga programmiga, mis on mõeldud laiemaks levitamiseks, peab kaasnema
dokumentatsioon selle programmi kohta. Veel mõned aastad tagasi oli
loomulik, et see dokumentatsioon oli trükitud kujul. Tänapäeval on
paljud programmipaketid varustatud ka elektroonilisel kujul oleva
dokumentatsiooniga - niinimetatud 'abifailidega'.
Dokumentatsioon jaotub mitmesse ossa sõltuvalt sellest, kellele ja
milleks see on kokku pandud:
1) Kasutajajuhendid. Siia hulka kuuluvad materjalid, mis tutvustavad
programmi omadusi ja aitavad läbi viia väikese proovi ning põhjalikumad
kasutajatele orienteeritud käsiraamatud, niinimetatud 'manuaalid'.
Kasutajajuhendites on kõike püütud seletada kasutaja vaatevinklist
lähtudes ja üldiseks eesmärgiks on aidata kaasa programmi efektiivsele
kasutamisele.
2) Administraatori juhendid. Siia kuulub programmi installeerimise
juhend ja käsiraamatud programmi hooldamiseks. Ühe kasutaja programmidel
on installeerimine tehtud sageli väga lihtsaks ja see erilist probleemi
ei tekita, kuid suurte süsteemide tööle panemiseks on tihti vajalik
spetsialisti kohalolek ja siis on vaja kuidagi edasi anda programmi
koostaja näpunäited - selleks siis ka installeerimise juhend. Programmi
hooldamise juhendid sisaldavad endas harilikult näpunäiteid mõningate
tegevuste, nagu näiteks andmete
arhiveerimine , läbiviimiseks ja
lihtsamate veasituatsioonide lahendamiseks.
3) Programmi tehniline dokumentatsioon. See sisaldab endas kogu projekt-
dokumentatsiooni, testimiste protokolle ja võimaluse korral ka programmi
lähtetekste. Need kõik on vajalikud, kui tahetakse
olemasolevat program-
mi parandada või
täiendada .
2. Programmi lähteteksti dokumenteerimine
Eelmises teemas lubasin, et seekord tuleb juttu kommenteerimisest. Kuna
programmi lähtetekst on mõeldud ka inimesele lugemiseks, siis vormista-
mise ühe
osana tuleb seda ka täiendada ka selgitava tekstiga.
KOMMENTAAR on programmis selgituse või täpsustusena kasutatav teksti-
lõik, mis ei mõjuta programmi tööd. Kuigi ei ole
kindlaid reegleid selle
kohta, kuidas kasutada kommentaare, on siingi mõned
printsiibid , mida
võiks järgida:
* kommenteerida tuleb nii palju kui vajalik ja nii vähe kui võimalik;
* kommenteerides püüdge ennetada lugeja küsimusi;
* kirjeldada tuleb põhilisi funktsioone ja tegevusi;
* andke piisav seletus kasutatavatele muutujatele;
* ärge kommenteerige niigi arusaadavaid lauseid.
Jätke endale meelde, et mõistlik kommenteerimine suurendab märgatavalt
106 / 115
programmi loetavust.
Lisaks sisulisele kommenteerimisele kasutavad professionaalsed
programmeerijad ka programmi lähteteksti dokumenteerimist, mis tähendab,
et iga programmimooduli ja alamprogrammi algusesse lisatakse
spetsiaal -
selt vormistatud kommentaar, mis sisaldab:
1) mooduli või funktsiooni täielikku nimetust;
2) otstarve lühikest kirjeldust;
3) sisendandmete kirjeldust;
4) väljundandmete kirjeldust;
5) autori(te) nime(sid) ja loomise kuupäeva;
6)
muudatuste põhjuseid ja kuupäevi koos
muudatuse tegijate nimedega.
Selline
lähenemine võimaldab saada programmi teksti lugedes kirjapandust
parema ülevaate ning hiljem jälgida arendustööde
käiku .
3. Mis on programmi projekteerimine?
Suurte programmide loomist on tihti võrreldud maja ehitamisega. Tõsi
küll, et mõned sellised tähelepanekud ei ole programmeerijatele auks.
Nagu näiteks üks Murphi
seadustest võetu:
"Kui
ehitajad ehitaksid maju samamoodi nagu programmeerijad loovad
programme, siis esimene kohalelennanud rähn hävitaks tsivilisatsiooni".
See tähendab, et paljud programmid kujutavad endast kaardimajakesi, mis
küll seisavad püsti, kuid ei pea vastu ühelegi juhuslikule tuulepuhan-
gule. Selliste programmide tunnuseks on see, et kasutajad peavad käima
mööda juba pikka aega sissetallatud
radu ja hoidku jumal neid selle
eest, et nad
sellelt rajalt kõrvale ei pööraks - halvemal juhul võib see
lõppeda totaalse kräshiga. Need on niinimetatud 'mittelollikindlad
programmid'. Mõni võib mõelda, et 'mis nad siin jamavad, parandagu vead
ära ja asi korras', aga kui minna neid vigu parandama, siis selgub, et
ei eksisteeri mitte mingisugust dokumentatsiooni, programmi tekst on
halvasti vormistatud jne. Parandades sellises programmis ühte viga, võid
suure tõenäosusega teha mitu uut - lihtsalt puudub ülevaade.
Eelneva jutu moraaliks on see, et TULEB ÕPPIDA EHITAJATELT. Tänapäeval
ei ehitata enam niimoodi, et kõigepealt tuuakse kohale koormatäis tel-
liskive ja hakatakse laduma. Kõigepealt vaadatakse, kuhu ehitada ja
millist maja
tulevane elanik soovib. Seejärel tehakse
majale PROJEKT
(see on juba arhitektide asi, kui nad uut projekti ei joonista vaid
võtavad kapist mõne vana). Kui kõik funktsionaalsus, kasutatavad mater-
jalid ja töömahud on läbi mõeldud, alles siis hakatakse kive laduma. Ja
suurem enamus majadest seisab püsti ja on elanikke täis - ju siis sai
ehitatud head majad. Seesama jutt käib ka programmide loomise kohta.
Nii nagu uut tüüpi majade puhul ehitatakse makette ehk väikeseid mude-
leid, nii luuakse ka keeruliste programmide jaoks kõigepealt mudelid
ning nende peal 'mängitakse läbi' programmi kasutamine ja üldine funkt-
sionaalsus. Programmi projektdokumentatsioon koosnebki harilikult mudeli
kirjeldusest, milles on esitatud kasutatavad andmestruktuurid, funkt-
sioonid ja nende
omavahelised suhted, andmete liikumise suund ja ajaline
järjekord, kasutajaliides ja veel palju muud. Selliste programmi mudeli-
te loomiseks kasutatakse CASE-vahendeid - programme, mis võimaldavad
projekteerijal koostada mitmeid spetsiaalseid diagramme ning mis on suu-
telised kontrollima koostatud mudeli korrektsust ja genereerima program-
mi tooriku, mida siis programmeerija saab oma töös otseselt kasutada.
4. Putukate ärastamine ja trablite
laskmine 107 / 115
4.1 Vead
Inglise keeles on programmis leiduvate vigade jaoks kasutusel sõna 'bug'
ja tegevust vigade eemaldamiseks programmist nimetatakse sõnaga
'debugging'. Et 'bug' tähendab ka putukat, siis sõna 'debugging' võib
tõlkida ka kui 'putukate eemaldamine'. Ja kui keegi räägib programmi
silumisest, siis on samuti tegemist vigade otsimise ja parandamisega.
Tõsiseks probleemiks ei ole tihti mitte vea eemaldamine vaid selle LEID-
MINE. Seetõttu tutvume kõigepealt tüüpiliste vigadega, mida programmide
koostajad teevad. Järgnev loetelu on ülevaade situatsioonidest, kus
üldiselt tehakse 99% vigadest. Kui programmeerija suudab kõiki neid
"putukaid" vältida, siis töötavad tema programmid
stabiilselt ja hästi.
VEAD ANDMETE KASUTAMISEL
* Muutuja on jäänud initsialiseerimata. Siinkohal tuleb alati kaaluda:
kas muutuja vajab algväärtustamist ja kui vajab, siis kus (programmi
alguses, tsükli alguses)?
* Massiivi indeks ületab lubatud piiri.
VEAD ARVUTAMISEL
* Muutuja ületäitumine.
* Avaldise vahetulemuse ületäitumine.
* Jagamine nulliga.
* Funktsiooni kasutamine väljaspool määramispiirkonda (
ruutjuur negatiivsest arvust).
* Täpsuse kadu täisarvulisel jagamisel.
* Täpsuse kadu tehetel reaalarvudega.
VEAD VÕRDLEMISEL
* Vale võrdlusmärgi kasutamine (range võrratuse asemel mitterange
võrratus).
* Võrreldavate konstantide +-1 võrra vale väärtus.
VEAD JUHTKONSTRUKTSIOONIDES
* Tsükli lõpetamiseks vajalik tingimus ei osutu kunagi täidetuks.
* Tsükli alustamiseks vajalik tingimus ei osutu kunagi täidetuks.
* Tingimuslause (if tingimus then ...) on jäänud ilma alternatiivita
(else ...).
* Valikulause (case ...) ei käsitle kõiki võimalikke väärtusi või ei
informeeri vigaste väärtuste esinemisest.
VEAD ALAMPROGRAMMIDE KASUTAMISEL
*
Tegelikud parameetrid on esitatud
vales järjekorras.
4.2 Testimine
Programmi testimisel on oluline, et
toimuks psühholoogiline häälestumine
eesseisvale tegevusele. Nimelt, TESTIMINE on programmi täitmise protsess
EESMÄRGIGA
AVASTADA VIGU, mitte aga programmi täitmine eesmärgiga
näidata, et programm töötab õigesti.
TESTIMISE PROTSESS koosneb järgmistest tegevustest:
1) Paneme eelnevalt kirja vajaliku komplekti algandmeid, mis valitakse
lähtuvalt testimise meetodist. Ka testid lubamatute algandmetega tuleb
hoolikalt välja töötada.
2) Koostame testimise protokolli järgmise tabeli kujul
+----------------------------------------------+
| Testandmed | Oodatav vastus | Tegelik vastus |
+------------+----------------+----------------+
108 / 115
| | | |
3) Leiame
oodatavad vastused ENNE testimist.
4) Uurime hoolikalt iga testi tulemust.
5) Kontrollime, kas programm ei tee seda, mida ta ei pea tegema (ehk ei
tohi teha).
NB! Pärast programmi parandamist tuleb
teste alustada otsast peale.
TESTIDE KOOSTAMISEL püütakse saavutada testide võimalikult väike arv ja
käsitsi lahendamise lihtsus.
TESTIDE KOOSTAMISE MEETODID jagatakse üldiselt kaheks - MUSTA KASTI
MEETODID ja VALGE KASTI MEETODID.
MUSTA KASTI MEETODID käsitlevad programmi kui "musta kasti", s.t. uuri-
vad selle käitumist lähtudes püstitatud ülesandest,
sealjuures teadmata,
kuidas programm seda ülesannet lahendab. Musta kasti meetoditeks on:
EKVIVALENTSIKLASSIDE MEETOD. Võimalikud sisendandmed jagatakse niimoodi
klassideks, et programm töötab iga klassiga
ühtemoodi .
Klassid tekita-
takse ülesande põhjal sisendtingimuste ja muude aspektide ülevaatamise
teel. Näiteks:
+---------------------------+----------------------+-------------------+
| Tingimus või aspekt | Õiged klassid | Valed klassid |
+---------------------------+----------------------+-------------------+
| sisendsümbol kuulub hulka | | |
| | sisendsümbol õige | sisendsümbol vale |
+---------------------------+----------------------+-------------------+
| | | |
Iga vale klassi jaoks konstrueeritakse oma test, õigeid
klasse tuleb
katta ühe testiga nii palju kui võimalik.
PIIRMISTE VÄÄRTUSTE ANALÜÜSI MEETOD. Kontrollitakse programmi tööd
lubatud väärtustega ja vahemike otsmiste elementidega ning nende
naabritega. Samuti koostatakse testid, mis kontrollivad võrratuste
rangust.
OLETUSED VIGADE KOHTA. Kogemustega programmeerijad ja testijad oskavad
ülesandega tutvununa oletada võimalikku lahendusalgoritmi ja teavad
selle juures vigade tegemise võimalusi.
VALGE KASTI MEETODID lähtuvad sellest, et on täpselt teada, kuidas
programm on kirjutatud. Üheks selliseks on TINGIMUSTE JA
OTSUSTUSTE MEETOD, mille korral testid koostatakse põhimõtete kohaselt, et
1) iga programmi lõik peab testimise ajal töötama
2) iga tingimus peab olema täidetud mõlemas suunas.
Selle teema lõpetuseks toon Teile ühe näite programmiga kaasas olevast
lühikesest kasutajajuhendist:
Monty Pyton's
Complete Waste of Time
See ketas mahuga 676 Mb värskendab Teie igava
Windows 'i ikoonikestega,
skriin-seiveritega, tapeetidega (nii
elavate kui ka surnutega), helidega
... vähendab ärritust, depressiooni, närve ... üldiselt, kui Te kõhkle-
te, kas omada seda
ketast või mitte, siis tuletame meelde: Igasugune
Teie Otsus On Viga.
109 / 115
Täielik aja raiskamine tühja, uisapäisa ja ilmaaegu nõuab:
- 386 või greiter IBM kompatiiblit arvutit koos vähemalt 4 Mb RAM'iga
- 256 kolor või better televiisorit
- MS-
hiirt või teist devaisi
- WIN 3.1 või haier
- DOS 3.3 või haier
- MPC kompatiiblit helikaardi ja amplified spiikers või hedfones
haili soovitatavad
- CD-ROM olemasolu tööd ei sega
Trablite laskmine (troubleshooting)
- Veenduge enda vastavuses eeltooduga
- Kui Teie monitor ei näita 600*480 või 800*600 punkti 256 värviga:
veenduge
monitori olemasolus
- Kui Teil on probleeme soundiga, veenduge, kas seda soundi üldse oli
- Kui on probleeme mäluga: treenige mälu.
Tapke maha kõik QEMM-id,
EMM-id ja muud MMM-id. Ei aita: asjata tapsite.
- Heli tugev/nõrk:
ostke helitugevuse
regulaator . Kui ei aita: pange
sisse
helikaart .
- Ei
jätku ruumi kettal: kustutage kõik
mittevajalik . Ikka ei aita:
kustutage ka vajalik. Või ostke uus vintsester.
- Programm ei tööta kõigest hoolimata: Teil, paistab, on Dendy. Seda
trablit niisama lihtsalt lasta ei saa.
Edukat putukatejahti ja trablite laskmist! ;-)
110 / 115
KAHETEISTKÜMNES TEEMA: Struktuur-
ja objektorienteeritud programmeerimise
põhimõtted Sissejuhatus
Programmide koostamisele tuleb läheneda märksa laiemalt, kui ainult
tegevusele, mis seisneb käskude rittapanemises. Sellest on olnud juttu ka
eelmistes teemades. Mida tähendab "
läheneda laiemalt"?
Nimelt on maailma tarkvaratootmises kaks
põhilist lähenemisviisi -
struktuurne ja
objektorienteeritud (lühendatult OO).
Lähenemisviis ei kehti
ainult programmi kirjutamise kohta, vaid ka probleemi analüüsimise ja
programmi projekteerimise kohta. Räägitakse ka erinevatest
paradigmadest
(
paradigma on komplekt mõisteid ja tõekspidamisi). Nende olemusest seekord
juttu teemegi.
Struktuurprogrammeerimine
Selle lähenemise
sünniaastaks loetakse 1968, mil väljapaistev hollandi
programmeerimisteoreetik
E. W. Dijkstra avaldas artikli "
GO TO lausest",
milles ta nõudis, et programm oleks lausete esinemisjärjekorras vabalt loetav,
see tähendab, et programmis ei oleks GO TO-st tingitud tagasihüppeid.
Isiklikust kogemusest võin väita, et on võimalik kirjutada tuhandeid ridu
pikki programme nii, et ei ole
kordagi vaja kasutada GO TO suunamislauset. See on
ka tõestatud, et programmi saab kirja panna ainult kolme konstruktsiooni -
käskudejada,
valikut ja
kordust - kasutades.
Struktuurprogrammeerimine taotleb, et igal programmikonstruktsioonil oleks
üks sisend- ja
üks väljundpunkt, aga GO TO lause võib tekitada mitu sisend-
ja/või väljundpunkti.
Põhiliseks meetodiks struktuurprogrammeerimises on
ülalt-alla meetod. Selle
põhiideeks on lähenemine probleemile kui tervikule ja seejärel probleemi
tükeldamine väiksemateks osadeks. Siis toimub probleemide lahendamine
sellisel viisil, et vaadeldakse ainult käesoleval tasemel esilekerkinud ülesandeid
ja alamülesannete juurde pöördutakse alles pärast seda, kui käesoleval
tasemel on kõik tehtud. Sama printsiipi rakendatakse ka programmi
kirjutamisel ja testimisel.
Struktuurset lähenemist kasutades keskendame me
esmalt tähelepanu
tegevustele ja
protsessidele, struktuurprogrammeerimise käigus vaatleme
esmajoones
funktsioone ja
protseduure. Kui on välja selgitatud vajalikud
tegevused ja
algoritmid , siis teises järjekorras vaatleme nende tegevuste
teostamiseks vajaminevaid
andmestruktuure. Kogu
tarkvara arenguprotsessi
käigus ei püstitata nõuet, et andmed ja tegevused nendega oleksid
üksüheselt seotud. Piltlikult eksisteerib piir funktsioonide ja protseduuride ning
andmestruktuuride vahel, tihti on andmestruktuurid globaalsed ja kõikide
111 / 115
alamprogrammide poolt kasutatavad.
Struktuurne lähenemine on selle kontseptsioonide defineerimise ajast olnud
valitsev kogu maailma tarkvaratööstuses ja isegi uute ideede võidukäigu ajal
on leidnud oma kasutusala. Kuigi traditsioonilised struktuursed
programmeerimiskeeled on täienenud selleks, et võimaldada OO lähenemist, ei
kao sellega veel struktuurprogrammeerimise stiil. See jääb objektide poolt
moodustatud eesriide taha kindlalt püsima.
Eesti keeles on struktuurprogrammeerimisest kirjutanud Rein
Jürgenson oma
raamatus "
Programmeerimine Pascal-keeles".
Objektorienteeritud programmeerimine
Peaaegu sama vana, kui on struktuurne programmeerimine, on ka OO
programmeerimine. Esimene OO programmeerimiskeel -
Simula - loodi juba
1967-l aastal. Tõsisema läbimurde tõi aga keele
C++ loomine Bjarne
Stroustrup'i poolt aastal 1983.
OO lähenemine probleemidele ja programmeerimisele on üldjoontes täiesti
erinev struktuursest lähenemisest. Keele C++ tugevaks küljeks on osutunud
see, et C++ on täielikult kokkusobiv keelega C ning OO lähenemine ja
struktuurprogrammeerimine on
mugavalt kokku sulatatud.
Erinevalt struktuursest lähenemisest suunab OO lähenemise kasutamine
esmase tähelepanu andmetele ja alles seejärel tõstatatakse küsimus, mida
nende
andmetega teha saab. OO lähenemine püüab esitada programmis
esinevaid andmeid ja nendega teostatavaid tegevusi sarnastena meie
igapäevases elus ettetulevatele objektidele, kusjuures objekte kujutatakse
'
intelligentsetena'. Näiteks on meil objekt KALENDER. Küsides nüüd endalt,
mida KALENDER teha OSKAB, leiamegi selle objektiga seotud tegevused:
soovitud kalendrilehe näitamine ja lehekeeramine. Saite aru? Mitte kalendri
VAATAMINE vaid NÄITAMINE, sest kalender ise ei vaata. Ja lehekeeramise
laseme tal endal teha, seda võiks ta ju osata ;-)
Järgnevalt aga suundume objektide maailma ning tutvume selles esinevate
mõistete ja tõekspidamistega.
Objekt, atribuut, meetod
OO maailmas püütakse kõike, mille kohta kasutatakse
nimisõna , tituleerida
objektiks . Kui on tegemist asjaga, millel on mingisugused tunnused või
omadused ning millega saab midagi teha või mis oskab ise midagi teha, siis on
see kindlasti vaadeldav objektina. Objekti tunnuseid ja omadusi nimetatakse
atribuutideks, objekti tegevusi aga
meetoditeks. Vaatame näiteks autot.
Autol on hulk mitmesuguseid väliseid ja varjatud tunnuseid:
rataste arv,
värv,
mootori võimsus jne. Auto oskab
liikuda ,
muuta suunda,
kiirendada ja
pidurdada .
Valides püstitatud ülesande lahendamiseks vajalikud tunnused ja
tegevused, võime defineerida objekti AUTO ja seda oma programmis kasutada.
112 / 115
Klass
Kui tuletada meelde selle kursuse teist teemat, siis sai räägitud
andmeobjektidest ja sellest, et igal andmeobjektil on olemas
tüüp. Autot
kirjeldav objekt meie programmis on samal ajal ka andmeobjekt. Mis on sellise
andmeobjekti tüübiks?
OO lähenemine on selleks puhuks
toonud sisse mõiste KLASS. Kui me räägime
umbmäärasest
autost , siis tegelikult peame me silmas autode klassi. Kõigil
samasse klassi kuuluvatel objektidel on samasugused atribuudid ja meetodid,
objekte eristavad vaid atribuutide erinevad väärtused. Klass on objekti jaoks
sama mis tüüp.
Klass on piltlikult väljendudes justkui plastmassist liivavorm, millega saab
liivakooke teha - kõik liivakoogid on sarnase väljanägemisega. Objekt on üks
konkreetne liivakook teiste sarnaste hulgas.
Võtame näiteks klassi TASANDIPUNKT, millel on kaks atribuuti - koordinaadid X
ja Y. Igal klassil on vähemalt üks meetod, millega tekitatakse objekte. Seda
meetodit nimetatakse KONSTRUKTORIKS. Kui me defineerime TASANDIPUNKTI
konstruktorile ka kaks parameetrit, siis võime selle abil tekitada palju uusi
punkte konkreetsete X ja Y väärtustega:
+--------------------------+ Objektid
| Klass TASANDIPUNKT |
+--------------------------+ ==> A(1, 2)
| Atribuut X | B(7, 9)
| Atribuut Y | C(-17, 5)
+--------------------------+ ...
| Konstruktor Punkt(x, y) |
| Meetod Mine(x, y) |
| Meetod YtleX |
| Meetod YtleY |
+--------------------------+
Klassi juures defineeritud
meetodeid saavad kasutada kõik sellesse klassi
kuuluvad objektid. Seega saame igale konkreetsele punktile öelda, et ta läheks
uuele kohale, samuti võime iga punkti käest küsida, kus ta asub.
Kapseldumine
Klassi kirjelduses on harilikult esitatud nii atribuudid kui ka meetodid. Üheks OO
programmeerimise omapäraks on objekti atribuutide
peitmine teiste objektide
eest. Sellist teguviisi nimetatakse
kapseldumiseks.
Objekt - - - - - - - - - - - - - - - - -
Konstruktor Meetod1
| |
Meetod2 +============+
| | Atribuudid | Meetod3 |
Meetod4 +============+
| |
Meetod5 Meetod6
- - - - - - - - - - - - - - - - -
Teistele objektidele jäävad paistma vaid meetodid, vaadeldava objekti
113 / 115
atribuutidele otse ligi ei pääse. Objekti enda meetodid saavad aga
atribuutidega kõike teha. Kapseldumine tagab selle, et atribuutide väärtusi
kasutavad ja muudavad vaid objekti enda meetodid ning keegi väljaspoolt ei
saa objekti olekut ja käitumist atribuutide muutmise läbi ära rikkuda. Eespool
toodud TASANDIPUNKTI näite juures võib aru saada, et kui meil on kasutada
klassis defineeritud meetodid, siis ei teki meil vajadustki pöörduda otse
atribuutide X ja Y poole.
Sündmused ja teated
OO maailmas on tavaks rääkida, et
objektid suhtlevad omavahel, saates
üksteisele
teateid ja genereerides
sündmuseid. Mida see tähendab?
Mängime läbi ühe näite, kasutades selleks eespoolt tuttavaid objekte klassist
TASANDIPUNKT ja võttes juurde ka objekti TASAND, kes neid punkte haldab.
Lisaks on meil veel objekt nimega
HIIR , mis on Teie käele tuttava arvutihiire
vari arvuti mälus. Olgu meie programm koostatud selliselt, et
hiire vasaku nupu
vajutus tekitab tasandile uue punkti ja parema nupu vajutus kustutab lähima
punkti. Kuidas sellisel juhul elu programmis käib?
Hiire parema nupu vajutus genereerib sündmuse PNUPP_PUNKTIS(R,V). See
sündmus antakse tasandi kätte, mis kontrollib, kas koordinaadid R ja V
kuuluvad tema poolt kasutatavasse alasse. Kui jah, siis tekitab ta tasandipunkti
konstruktorit kasutades uue punkti: Punkt A(R,V). Tekitatud punkt paneb
saadud väärtused oma atribuutidele ja võtab tasandil koha sisse.
Hiire vasaku nupu vajutus genereerib sündmuse VNUPP_PUNKTIS(R,V). Ka see
sündmus jõuab tasandi objektini ja käivitab järgmise tegevuse: tasand
saadab igale punktile teate, et punkt ütleks talle oma koordinaadid (ehk kutsub välja
punkti meetodid YtleX ja YtleY). Iga punkti korral arvutab ta selle kauguse
punktist (R,V) ja jätab lähima meelde. Kui kõik punktid on üle küsitud, siis võtab
ta leitud lähima punkti ja hävitab selle ära.
Eks ole kena jutustus objektide elust? Tegelikult on sellisest poeetilisest
lähenemisest kasu, sest programmeerimisest kaugel seisvatel inimestel (ka
algajatel programmeerijatel) on sellise mõtlemisviisiga lihtsam harjuda ning
objektide omavaheline teadete vahetamine on märksa arusaadavam kui
funktsioonide ja andmestruktuuride rägastikust läbimurdmine.
Pärilikkus ja polümorfism
Üheks väga oluliseks omaduseks objektide juures on võime
pärandada klassi
informatsiooni teisele klassile. Mida see meile annab?
Olles kord defineerinud ja ära programmeerinud ühe üldise klassi, nagu näiteks
ISIK, ning tahtes luua uut spetsiifilist klassi, nagu näiteks ÕPILANE, on meil
võimalus pärandada kõik klassi ISIK omadused (atribuudid ja meetodid) klassile
ÕPILANE ning seejärel lisada sinna juurde uusi omadusi. Sest sisuliselt on ju
õpilane samal ajal ka
isik. Nii on võimalik korduvalt kasutada ühte ja sama
programmikoodi.
Objektide
polümorfism tähendab seda, et objektid võivad olla
mitmepalgelised. Näiteks on meil klass
KODULOOM ja sellest pärandatud
114 / 115
klassid KOER,
KASS , LEHM ja HOBUNE. Klassil KODULOOM on meetod
TeeHäält.
Igal pärandatud klassil on see meetod üle defineeritud nii, et ta
vastaks konkreetse klassi spetsiifikale. Kui nüüd kasutada erinevate koduloomade hulka
ja otseselt teadmata, mis klassi looma me oleme sellest hulgast välja valinud,
siis meetodi
TeeHäält tulemus vastab konkreetsele klassile - koer haugub,
kass näub jne. Programmeerija ei pea enam ennast vaevama sellise koodi
kirjutamisega, et "
kui on tegemist koeraga, siis kasuta haukumist muidu kui
tegemist on hobusega, siis kasuta hirnumist muidu ..." jne.
Mis on kasu objektorienteeritusest?
OO keeltes on objektide klassi kirjeldus harilikult eraldatud selle klassi
meetodite teostusest. Selline eraldatus on fundamentaalse tähtsusega, sest
see võimaldab korraldada klasside taaskasutamist ja vähendada seega
tarkvara loomiseks vajalikke jõupingutusi. Kasutajal on vaja vaid tutvuda
vaadeldava klassi objektide käitumisega, mis paistab harilikult välja klassi
kirjeldusest ning ta ei pea midagi teadma sellest, kuidas sellise klassi meetodid
on teostatud. Taaskasutamise mõttes võib klassi vaadelda kui "
musta kasti",
millel on konkreetsed omadused ja käitumine, aga mille sisemust näha ei ole.
Teiseks oluliseks omapäraks on programmi vigade
lokaliseerumine . Nii, nagu
klassi taaskasutaja "
ei näe" klassi teostust, nii ei mõjuta klassi meetodi
teostuse vead midagi väljastpool klassi
piire olevat. Lihtsalt selle klassi objekt
käitub "
imelikult". Kui struktuurprogrammeerimise nuhtluseks oli tihti vigade
ahelreaktsioon , mis tulenes sellest, et ühe vea parandamine võis tekitada uue
vea, siis OO programmeerimine on sellisest efektist vabanenud just tänu
vigade kapseldumisele meetodite sisse. See annab tohutu ajavõidu
programmide silumisel.
Objektorienteeritud maailm
Tänapäeva tarkvaratootmine on suurel määral objektorienteeritud. See on ju
moodne! Erinevalt riietumismoest on see mood tingitud praktilisest
lähenemisest - objektorienteeritud tarkvaratootmine on odavam. Te võite ju
küsida, et millised on siis tulemused?
MS Windows ja teised
graafilised kasutajaliidesed on sügavalt
objektorienteeritud, samuti suurem enamus nende all töötavatest
rakendustarkvara pakettidest. Üha enam arenevad OO andmebaasisüsteemid.
Juba seitsmekümnendatel aastatel saadi aru, et vajadus uute programmide
järele kasvab kiiremini kui võimalus neid vajadusi rahuldada. OO lähenemine
annab lootust, et programmeerimine tulevikus hakkab sarnanema valmis
objektide kokkuladumisega ülesandele nõutava lahenduse saamiseks. See on
siis nagu
LEGO klotsidega
mängimine - juba algusest peale on teada, et need
klotsid sobivad kokku, määravaks osutuvad klotside omadused ja nende
paiknemise kord. See kõik võimaldab vähendada programmide koostamisele
minevat aega ja kunagi ehk jõuda kõigi infotöötlemise vajaduste rahuldamiseni.
115 / 115
Document Outline
- KURSUSE TUTVUSTUS: Programmeerimise algkursus
- Kellele see algkursus on mõeldud?
- Mida sellel kursusel ei õpetata?
- Mida selle kursusel õpetatakse?
- Kuidas õppida?
- Mis on kompilaator?
- Milliseid kompilaatoreid kasutada ja kust neid saab?
- Millist keelt valida?
- ESIMENE TEEMA: sissejuhatav sõnavõtt ehk 'milleks on vaja programmeerimist?'
- Programmeerimise koht muude maailma asjade seas
- Masinad ja nende juhtimine
- Masin arvutamise jaoks - arvuti
- Kaudne juhtimine ehk programmeerimine
- Arvutite rakendusala laienemine
- Programmeerimine tänapäeval
- Programmeerimiskeelte üldine jaotus
- Imperatiivsed ehk käskivad keeled
- Funktsionaalsed keeled
- Loogilised keeled
- Esimese teema kokkuvõte
- TEINE TEEMA: PÕHIMÕISTED. OMISTAMISLAUSE.
- Sissejuhatus
- Programmeerimise mõisted
- Algoritm
- Programmeerimiskeel
- Lause
- Võtmesõna
- Andmeobjekt
- Identifikaator
- Andmetüüp
- Väärtus
- Konstant
- Muutuja
- Andmemudel
- Arvutiga seotud mõisted
- Omistamislause
- Omistamislause süntaks
- Omistamise olemus
- Omistamislause keeles Pascal
- Omistamislause keeles C
- Omistamislause keeles Basic
- KOLMAS TEEMA: aritmeetiline ja loogiline avaldis. Operand ja operaator.
- Sissejuhatus
- Avaldis
- Operand ja operaator
- Aritmeetiline avaldis
- Loogiline avaldis
- Ülevaade aritmeetilistest operaatoritest
- Aritmeetilised operaatorid keeles Pascal
- Aritmeetilised operaatorid keeles C
- Aritmeetilised operaatorid keeles QBasic
- Ülevaade loogilistest operaatoritest
- Loogilised operaatorid keeles Pascal
- Loogilised operaatorid keeles C
- Loogilised operaatorid keeles QBasic
- NELJAS TEEMA: standardprotseduurid andmete sisestamiseks ja väljastamiseks.
- Sissejuhatus
- Standardprotseduurid andmete väljastamiseks
- Andmete väljastamise olemus
- Andmete väljastamine keeles Pascal
- Andmete väljastamine keeles C
- Andmete väljastamine keeles Qbasic
- Standardprotseduurid andmete sisestamiseks
- Andmete sisestamise olemus
- Andmete sisestamine keeles Pascal
- Andmete sisestamine keeles C
- Andmete sisestamine keeles QBasic
- Väljundi vormistamine
- Mis on väljundi vormistamine?
- Väljundi vormistamise võimalused keeles Pascal
- Väljundi vormistamise võimalused keeles C
- Väljundi vormistamise võimalused keeles QBasic
- VIIES TEEMA: tingimuslause. suunamislause. valikulause.
- Sissejuhatus
- Tingimuslause
- Tingimuslause keeles Pascal
- Tingimuslause keeles C
- Tingimuslause keeles Qbasic
- Suunamislause
- Suunamislause keeles Pascal
- Suunamislause keeles C
- Suunamislause keeles Qbasic
- Valikulause
- Valikulause keeles Pascal
- Valikulause keeles C
- Valikulause keeles Qbasic
- KUUES TEEMA: struktuursed andmetüübid: jada, massiiv, kirje, fail.
- Sissejuhatus
- Jada. Massiiv. Massiivi mõõtmed
- Massiivi deklareerimine
- Massiivi deklareerimine keeles Pascal
- Massiivi deklareerimine keeles C
- Massiivi deklareerimine keeles Qbasic
- Massiivi kasutamine
- Kirje
- Kirje deklareerimine
- Kirje deklareerimine keeles Pascal
- Kirje deklareerimine keeles C
- Kirje deklareerimine keeles Qbasic
- Kirje kasutamine
- Fail
- Faili deklareerimine
- Faili kasutamine
- SEITSMES TEEMA: määratud kordus. eelkontrolliga kordus. järelkontrolliga kordus.
- Sissejuhatus
- Määratud kordus
- Eelkontrolliga kordus
- Järelkontrolliga kordus
- Korduslaused keeles Pascal
- Korduslaused keeles C
- Korduslaused keeles Qbasic
- Korduslausete kasutamine
- KAHEKSAS TEEMA: viitmuutuja. arvuti mälu paindlik kasutamine
- Sissejuhatus
- Viitmuutuja olemus
- Viitmuutuja kasutamine
- Viitmuutuja kasutamine keeles Pascal
- Viitmuutuja kasutamine keeles C
- Mälu paindlik kasutamine
- Mälu hõivamine
- Mälu vabastamine
- Tüüpilised komistuskivid
- Dünaamilised andmestruktuurid
- Ahel ja järjekord
- Pinumälu ehk magasinmälu
- ÜHEKSAS TEEMA: alamprogrammid. protseduur ja funktsioon
- Milleks on vaja alamprogramme?
- Protseduuri ja funktsiooni erinevused
- Alamprogrammide kasutamine
- Pascal
- C
- Qbasic
- Parameeter
- Globaalsed ja lokaalsed muutujad
- Ülevaade standardprotseduuridest ja -funktsioonidest
- Pascal
- C
- Qbasic
- KÜMNES TEEMA: Programmide vormistamine.
- 1. Milleks on vaja programme hästi vormistada?
- 2. Identifikaatorite süstematiseerimine.
- ÜHETEISTKÜMNES TEEMA: programmi dokumenteerimine. kommentaarid
- PROGRAMMI PROJEKTEERIMINE JA TESTIMINE
- 1. Kellele ja milleks on vaja dokumentatsiooni?
- KAHETEISTKÜMNES TEEMA: Struktuur- ja objektorienteeritud programmeerimise põhimõtted
- Sissejuhatus
- Struktuurprogrammeerimine
- Objektorienteeritud programmeerimine
- Objekt, atribuut, meetod
- Klass
- Kapseldumine
- Sündmused ja teated
- Pärilikkus ja polümorfism
- Mis on kasu objektorienteeritusest?
- Objektorienteeritud maailm
50 punkti
Autor soovib selle materjali allalaadimise eest saada 50 punkti.
~ 115 lehte
Lehekülgede arv dokumendis
2016-06-28
Kuupäev, millal dokument üles laeti
39 laadimist
Kokku alla laetud
0 arvamust
Teiste kasutajate poolt lisatud kommentaarid
ELVIS Takkis
Õppematerjali autor
annaabi.ee 
Kõik kommentaarid