programavimas paskaliu ir c i dalistomukas/knygos/prog_i.pdf5 pratarmĖ metodinė priemonė...
TRANSCRIPT
K R I S T I N A L A P I N
Programavimas Paskal iu i r C
I dalis
Matematikos ir statistikos studijų krypč ių
pirmo kurso studentams
2004
Š I A U V I L N I A U S U N I V E R S I T E T A S M A T E M A T I K O S I R I N F O R M A T I K O S F A K U L T E T A S
P R O G R A M Ų S I S T E M Ų K A T E D R A
2
Programavimas Paskaliu ir C: I dalis
1 KURSO MATEMATIKOS IR STATISTIKOS STUDIJŲ KRYPČIŲ STUDENTAMS
T U R I N Y S PRATARMĖ ................................................................................................................................................. 5
1. ĮVADAS ................................................................................................................................................ 6 1.1. PRISIJUNGIMAS .............................................................................................................................. 6
1.1.1. Linux ..................................................................................................................................... 6 1.1.2. Solaris .................................................................................................................................. 7
1.2. DARBAS SU KATALOGAIS IR FAILAIS .............................................................................................. 8 1.2.1. Linux ..................................................................................................................................... 8 Soliaris ................................................................................................................................................. 11
1.3. PASKALIO PROGRAMŲ VYKDYMAS .............................................................................................. 13 1.3.1. Linux aplinka ...................................................................................................................... 13 1.3.2. Soliaris ............................................................................................................................... 14
1.4. C PROGRAMŲ VYKDYMAS ............................................................................................................ 14 1.5. DARBO PABAIGA .......................................................................................................................... 14
2. PROGRAMOS STRUKTŪRA ......................................................................................................... 16 2.1. PASKALIO PROGRAMOS STRUKTŪRA ............................................................................................ 16
2.1.1. Programos antraštė ............................................................................................................ 16 2.1.2. Moduliai ............................................................................................................................. 16 2.1.3. Žymė ................................................................................................................................... 16 2.1.4. Komentarai ................................................................................................................................. 17
2.2. C PROGRAMOS STRUKTŪRA ......................................................................................................... 17 3. DUOMENŲ TIPAI ............................................................................................................................ 18
3.1. PASKALIO PAPRASTIEJI TIPAI ....................................................................................................... 18 3.1.1. Diskretieji tipai ................................................................................................................... 18 3.1.2. Tolydus duomenų tipas – realusis tipas .............................................................................. 21
3.2. C PAPRASTIEJI DUOMENŲ TIPAI .................................................................................................... 21 4. KINTAMIEJI ..................................................................................................................................... 24
4.1. PASKALIO .................................................................................................................................... 24 4.2. C .................................................................................................................................................. 24
5. OPERACIJOS IR REIŠKINIAI ...................................................................................................... 25 5.1. PASKALIS ..................................................................................................................................... 25
5.1.1. Aritmetinės operacijos ........................................................................................................ 25 5.1.2. Loginės operacijos ............................................................................................................. 25 5.1.3. Santykio operacijos ............................................................................................................ 25
5.2. C .................................................................................................................................................. 25 6. SAKINIAI ........................................................................................................................................... 27
6.1. PRISKYRIMAS ............................................................................................................................... 27 6.1.1. Paskalyje ............................................................................................................................ 27 6.1.2. C ......................................................................................................................................... 27
3
6.2. SUDĖTINIS SAKINYS ..................................................................................................................... 27 6.2.1. Paskalyje ............................................................................................................................ 28 6.2.2. C ......................................................................................................................................... 28
6.3. IŠSIŠAKOJIMAI ............................................................................................................................. 28 6.3.1. Sąlyginis sakinys ................................................................................................................ 28 6.3.2. Variantinis sakinys ............................................................................................................. 30
6.4. KARTOJIMAI ................................................................................................................................ 32 6.4.1. Ciklas while ........................................................................................................................ 32 6.4.2. Ciklas repeat – do while ..................................................................................................... 34 6.4.3. Ciklas for ............................................................................................................................ 36 6.4.4. Ciklo valdymas, naudojant break, continue, goto .............................................................. 37
7. STRUKTŪRINIAI TIPAI ................................................................................................................. 40 7.1. MASYVAS .................................................................................................................................... 40
7.1.1. Paskalyje ............................................................................................................................ 40 7.1.2. C ......................................................................................................................................... 41 7.1.3. Daugiamačiai masyvai ....................................................................................................... 46
7.2. ĮRAŠAI.......................................................................................................................................... 47 7.2.1. Paskalyje ............................................................................................................................ 47 7.2.2. C ......................................................................................................................................... 48
7.3. PASKALIO ĮRAŠAI SU VARIANTINE DALIMI ................................................................................... 49 7.4. SĄJUNGA (UNION) ........................................................................................................................ 50 7.5. AIBĖS ........................................................................................................................................... 51
7.5.1. Aprašas ............................................................................................................................... 51 7.5.2. operacijos ........................................................................................................................... 51
8. DUOMENŲ ĮVESTIS ......................................................... ERROR! BOOKMARK NOT DEFINED. 8.1. PASKALYJE .............................................................................ERROR! BOOKMARK NOT DEFINED. 8.2. C .............................................................................................ERROR! BOOKMARK NOT DEFINED.
9. FUNKCIJOS IR PROCEDŪROS .................................................................................................... 53 9.1. ĮVADAS ........................................................................................................................................ 53 9.2. STANDARTINĖS MATEMATINĖS FUNKCIJOS .................................................................................. 53
9.2.1. Paskalyje ............................................................................................................................ 53 9.2.2. C ......................................................................................................................................... 54
9.3. NAUDOTOJO PROCEDŪROS PASKALYJE ....................................................................................... 54 9.3.1. Procedūros aprašas ............................................................................................................ 54 9.3.2. Pagrinxdiniai parametrų tipai ............................................................................................ 55 9.3.3. Kreipinys į procedūrą ......................................................................................................... 56
9.4. NAUDOTOJO FUNKCIJOS ............................................................................................................... 56 9.4.1. Paskalyje ............................................................................................................................ 56 9.4.2. C ......................................................................................................................................... 57
9.5. MASYVŲ PERDAVIMAS FUNKCIJOMS AR PROCEDŪROMS .............................................................. 58 9.6. ATMINTIES KLASĖS ...................................................................................................................... 59
9.6.1. Vardų galiojimo srtitys Paskalyje ...................................................................................... 59 9.6.2. C ......................................................................................................................................... 60
9.7. C PARAMETRAI-KINTAMIEJI ......................................................................................................... 63 9.7.1. Kintamųjų perdavimas parametrais-kintamaisiais ............................................................ 63 9.7.2. Masyvų perdavimas funkcijoms ir procedūroms ................................................................ 64
9.8. PAVYZDŽIAI ................................................................................................................................. 64 10. FAILAI ........................................................................................................................................... 66
10.1. PASKALIO FAILAI ......................................................................................................................... 66 10.1.1. Tekstiniai failai ................................................................................................................... 66
4
10.1.2. Programų, apdorojančių tekstinius failus, pavyzdžiai ....................................................... 69 10.2. C FAILAI....................................................................................................................................... 70
10.2.1. atverti failą ......................................................................................................................... 70 10.2.2. Nuoseklios kreipties failo skaitymas ................................................................................... 70 10.2.3. Atsukti failo rodyklę į pradžią ............................................................................................ 70 10.2.4. Rašymas į nuoseklios kreipties failą ................................................................................... 71 10.2.5. Užverti failą ........................................................................................................................ 71
10.3. TIPIZUOTI FAILAI PASKALYJE ...................................................................................................... 73 10.4. NETIPIZUOTI FAILAI PASKALYJE .................................................................................................. 76 10.5. C LAISVOSIOS KREIPTIES FAILŲ SKAITYMAS IR RAŠYMAS ............................................................ 77 10.6. KITI PAVYZDŽIAI ......................................................................................................................... 79
LITERATŪRA ........................................................................................................................................... 82
5
PRATARMĖ
Metodinė priemonė „Programavimas Paskaliu ir C: I dalis“ yra skirta 1 kurso matematikos ir statistikos studijų krypčių studentams. Ji apima Informatikos dalyko rudens semestro programą, Ši priemonė papildo doc. dr. S. Ragaišio metodinę priemonę [2] programavimo aspektu. Šioje priemonėje yra pateikiami sąvokų realizavimo Paskaliu ir C pavyzdžiai.
Ši medžiaga yra skirta programavimo naujokams. Joje stengiamasi kuo paprasčiau, išdėstyti bazines programavimo sąvokas. Labiau pažengusiems programavime, siūlyčiau naudoti kitas, aukštesnį žinių lygį atitinkančias mokymo priemones, kaip antai [1], [3], [4].
Šioje mokymo priemonėje pradedantiesiems programuotojams yra siūloma tokia mokymosi metodika:
1) atspausdinti medžiagą ir paskaitos metu papildyti ją dėstytojo paaiškinimais;
2) nagrinėti pateiktą sąvokos apibūdinimą ir pateikiamus pavyzdžius, papildytus paskaitoje užrašytais komentarais;
3) ruošiant pratybuose gautą individualią užduotį, pradėti nuo pavyzdžio, pateikto šioje medžiagoje;
4) pertvarkyti pavyzdį, atsižvelgiant į gautos užduoties reikalavimus.
Dėstomos sąvokos iliustruojamos dviejų programavimo kalbų – Paskalio ir C – pavyzdžiais, paruoštais transliavimui. Atsižvelgiant į ribotas naujokų naujų žinių įgijimo galimybes, sąmoningai stengiamasi vengti visų kalbos galimybių ir subtilybių dėstymo. Kalbų detalės yra išsamiai dėstomos konkrečių kalbų aprašuose ir žinynuose ([1], [4]).
Ši priemonė leidžia pasiruošti skaityti ir suprasti programavimo literatūrą, skirtą skaitytojui, suprantančiam bazines programavimo sąvokas.
6
1 . ĮVADAS
Šiame skyriuje yra aiškinama programų redagavimo ir vykdymo aplinka, veikianti Vilniaus universiteto Matematikos ir informatikos fakulteto Informacinių technologijų centro (toliau MIF ITC) kompiuterinėse klasėse.
Savo naudotojo prisijungimo vardą (angl. login) studentas gali pažiūrėti sąrašuose, kuriuos turi ITC būdintis asmuo arba fakulteto tinklalapyje (http://kedras.mif.vu.lt/tinklas/?sarasai.html), kurį parodo pratybas vedantis dėstytojas, prisiregistravęs savo naudotojo vardu.
Laikiną slaptažodį, galiojantį pirmam prisijungimui, sudaro 8 skaitmeys:
● pirmi 4 skaitmenis – 4 skaitmenys iš naudotojo vardo,
● paskutiniai 4 skaitmenys – iš asmens kodo.
Pirmą kartą prisiregustravus, būtina pakeisti laikiną slaptažodį į pastovų. Prisijungimo skyrelyje yra paaiškinta, kaip tai atlikti įvairiose aplinkose, veikiančiose MIF ITC.
MIF ITC kompiuterinėse klasėse galima naudotis trimis darbo aplinkomis, būtent Linux, Solaris (Unix) ir MS Windows. Daugumoje klasių galima pasirinkti aplinką. Programavimo pratybuose rekomenduojama naudotis Linux arba Solaris. Toliau yra aprašoma, kaip jas pasirinkti ir minimalus jų naudojimo pradžiamokslis.
1.1. PRISIJUNGIMAS
MIF ITC 2, 3, 7, 8, 9 klasėse pirminė aplinka yra Linux, o 10, 11, 12, 13, 14 – Soliaris. Baltupių filiale 308, 309 klasėse pirminė aplinka yra Soliaris, tačiau galima prisijungti ir prie Linux bei MS Windows (2006 09 01. Prieiga yra nuolat tobulinama, todėl šis aprašas gali neatitikti realios situacijos. Jei Skaitytojas rastų neatitikimų, prašyčiau man pranešti adresu [email protected] , nes nėra kitokio būdo sužinoti apie pakeitimus.
1.1.1. LINUX
MIF ITC 2, 3, 8, klasėse pirminė aplinka yra Linux. Daugumoje klasių prisijungiama, įvedus prisijungimo vardą ir slaptažodį. MIF ITC 9 klasėje yra galimybė pasirinkti aplinką, tuomet pradžioje rodomas galimų aplinkų sąrašas, pavyzdžiui, linux2.mif, linux4.mif – reiškia Linux aplinkos modifikacijas, o sunray1.mif, sunray2.mif ir panašios – reiškia Soliario (Unix) aplinkų grupę.
MIF ITC 10, 11, 12, 13,14 ir Baltupių 308, 309 kompiuterinėse klasėse veikia SOLIARIS aplinka. Anksčiau galima buvo prieiti prie Linux aplinkos, atlikus keletą žingsnių. Tačiau 2006 09 01 dienai ši galimybė kol kas neveikia! Jei ji buv įjungta, tuomet buv pįasiekiama taip: Prisijungimo lange reikia spragtelėti mygtuką Options, pasirodžiusiame meniu pasirinkti Remote login, toliau pasirinkti Choose Host from List. Pasirenkant Linux aplinka, reikia spragtelėti užrašą, prasidedantį žodžiu linux. Rekomenduojama išbandyti kelias aplinkas ir pasirinkti labiausiai patikusią. Pasirinkus Linux aplinką, pasirodo prisijungimo langas, kuriame įvedamas prisijungimo vardas ir slaptažodis.
PASTABA. MIF kompiuterinėse klasėse, renkant slaptažodį, kursorius nejuda!
7
Toliau pasirodo XFCE darbalaukis (žr. 1-1 pav.).
1-1 pav. XFCE darbalauykio vaizdas
Prisijungus pirmą kartą MIF ITC tinklalapyje reikia pakeisti slaptažodį. Naršyklės langas
atveriamas, spragtėlint naršyklės piktogramą ekrano apačioje esančioje juostoje:
Atsivėrusiame lange surinkti adresą: http://kedras.mif.vu.lt/itc/?stud.html ir spragtelėti nuorodą Savo slaptažodžio pakeitimas ir įvykdyti ten esančius nurodymus.
1.1.2. SOLARIS
Soliario aplinka veikia MIF ITC 13, 14 klasėse, Baltupių 308, 309 klasėse ir kitose klasėse, kur galima rinktis darbo darbo aplinką. Soliario aplinkos vardai pasirinkimų sąraše prasideda sunray.
Įvedus prisijungimo vardą ir slaptažodį, pasirodo langas, leidžiantis pasirinkti vieną iš šių aplinkų: CDE, GNOME ir Windows. Pasirenkame CDE, tuomet atsiveria darbalaukis (žr. 1-2 pav.).
8
1-2 pav. Vienas iš Soliario darbalaukių
Pirmą kartą prisijungus reikia pakeisti laikiną slaptažodį į nuolatinį. Šiam tikslui reikia atverti interneto naršyklės langą, spragtėlint naršyklės piktogramą
Atsivėrusiame lange adreso lauke surinkti adresą http://kedras.mif.vu.lt/itc/?stud.html ir
spragtelėti nuorodą Savo slaptažodžio pakeitimas.
1.2. DARBAS SU KATALOGAIS IR FAILAIS
1.2.1. LINUX
Pirmas būdas – naudoti komandų langą
Spragtelėti pirmą iš kairės piktogramą ir atsiveria komandų (konsolės, angl. console) langas (žr. 1-3 pav.). Šiame lange rašomos komandos.
1-3 pav. Komandų langas
Minimalų darbui su katalogais komandų rinkinį sudaro šios komandos:
9
● Naujo katalogo kūrimo komanda mkdir. Pavyzdžiui, jei kuriame katalogą vardu Informatika, surenkame šią eilutę komandų lange: mkdir Informatika
● Pereiti į naujai sukurtą katalogą: cd Informatika ● Grįžti atgal į šakninį katalogą: cd .. ● Pasižiūrėti katalogo turinį: ls arba dir ● Panaikinti katalogą pavadintą Informatika: rmdir Informatika
Antras būdas – naudoti failų ir katalogų tvarkymo programą
Spragtelėti užduočių juostoje esančią antrą iš kairės piktogramą (atrodo kaip aplankas, žr. 1-4 pav.).
1-4 pav. Failų tvarkympo programos piktogramos pasirinkimas
Darbas atsivėrusiame lange yra labai panašus į įpratstą Windows Explorer aplinką (žr. 1-5 pav.).
1-5 pav. Failų ir katalogų tvarkymo programos langas
10
Trečias būdas – Midnight Commander
Pripatusiems prie failų tvarkymo aplinkų, panašių į Windows Commander ar Far, visose klasėse galima išsikviesti Midnight Commander programą komandų (konsolės) lange surinkę: mc –c (žr. 1-6 pav.)
1-6 pav. Midnight Commander programos kvietimas
Surinkus pastarąją komandą, atsivėria langas, parodytas 1-7 pav.
1-7 pav. Midnight Commander failų tvarkuymo aplinka
11
SOLIARIS
Šioje aplinkoje taip pat galime naudotis tais pačiais katalogų ir failų tvarkymo būdais, kaip ir Linux aplinkoje.
Pirmas būdas – naudoti komandų langą
Tik komandų (konsolės) langas yra aktyvuojamas šiuo būdu (žr. 1-8 pav.): spragtelėti VIRŠ užduočių juostoje esančios trečios iš dešinės piktogramos (vieta pažymėta pirma rodykle). Atsivėrusiame meniu pasirinkti CONSOLE (antra rodykle). Šiame lange bus rašomos komandos. Darbui su katalogais komandų rinkinys nesiskiria nuo Linux aplinkoje naudojamų komandų.
1-8 pav. Komandų lango atvėrimas
Antras būdas – naudoti failų ir katalogų tvarkymo programą
Spragtelėti piktogramų juostoje esančią ketvirtą iš kairės piktogramą (atrodo kaip aplankas, žr. 1-9 pav.).
1-9 pav.Grafinės katalogų ir failų tvarkymo programos kvietimas
Tuomet atsivers langas, kuriame įprastu būdu tvarkomi katalogai ir failai (žr. 1-10 pav.).
12
1-10 pav. Grafinės katalogų ir failų tvarkymo programos langas
Trečias būdas – Midnight Commander
Šiuo atveju reikia atverti komandų langą (aprasšyta pirmame būde, ir surinkti jame komandą mc –c (žr. 1-6 pav.). Atsivers Midnught Commander programos langas (žr. 1-11 pav.).
1-11 pav. Midnight Commander Soliario aplinkolje
13
1.3. PASKALIO PROGRAMŲ VYKDYMAS
1.3.1. LINUX APLINKA
Darbalaukyje spragtelėti dešinį pelės klavišą. Pasirodys darbalaukio kontekstinis meniu, jame pasirinkti Apps / Editors / Gedit. Pradžiai rekomenduojamas Gedit redaktorius, toliau galima pasirinkti patinkantį.
Atsivėrusiame lange įvedame programos tekstą. Redagavimo langą padėti šalia komandų (konsolės) lango (žr. 1-12 pav.). Programos tekstą išsaugome sukurtame kataloge vardu, pavyzdžiui, pirmas.pas.
1-12 pav. Siūlomas darbo organizavimas darbalaukyje
Pereiname į konsolės langą, spaudžiant klavišų kombinaciją ALT+TAB. Konsolės lange transliuojame pirmas.pas failą: fpc pirmas.pas
Jei nėra klaidų galime vykdyti ./pirmas
Pasitaikius klaidai klavišų kombinacija ALT+TAB grįžtame į redaktoriaus lange esantį failą ir taisome klaidas. Redagavimo, transliavimo ir vykdymo veiksmus kartojame tol, kol gaunamas teisingas rezultatas.
14
1.3.2. SOLIARIS
Teksto redaktorias kviečiamas spragtelint penktą piktograma iš kairės, kurioje pavaizduotas popieriaus lapas ir rašiklis. (žr. 1-13 pav.).
1-13 pav. Teksto redaktoriaus lango atvėrimas
Atsivėrusiame lange įvedame programos tekstą. Redagavimo langą padėti šalia konsolės lango, panašiai, kai ri Linux aplinkoje (žr. 1-12 pav.). Programos tekstą išsaugome sukurtame kataloge vardu, pavyzdžiui, pirmas.pas. Konsolės lange transliuoti Paskalio programas šiek tiek sudėtingiau nei Linux klasėse, nes reikia prisijungti prie kito serverio: ssh uosis
Toliau reikia atsakyti yes ir dar vieną arba du kartus (kiek paprašo) prisiregistruoti. Toliau darbas panašus kaip Linux sistemoje: fpc pirmas.pas
Jei nėra klaidų, galime vykdyti ./pirmas
Jei darbą su Paskalio programa baigėme, iš uosio reikia išregistruoti, tai yra surinkti komandą exit
1.4. C PROGRAMŲ VYKDYMAS
C programų kompiliavimas ir vykdymas Linux ir Soliaris aplinkose nesiskiria. Kompiliuoti C programų tekstus galime dviem būdais
1 būdas: transliuojant, nurodomas vykdomojo modulio vardas, būtent gcc –o vardas1 vardas2.c
Tuomet programa vykdoma taip: ./vardas1
2 būdas: naudojant standartinį vykdomojo modulio pavadinimą a.out: gcc vardas.c
Tuomet programa yra vykdoma šitaip: ./a.out
1.5. DARBO PABAIGA
Darbo pabaigoje būtina išsiregistruoti!
Soliaryje reikia spragetelėti piktogramą EXIT (žr. 1-14 pav.).
15
1-14 pav. Išsiregistravimas Soliario aplinkoje
Linux aplinkoje reikia spragtelėti piktogramą šalia laikrodžio (žr. 1-15 pav.).
1-15 pav. Išsiregistravimas Linux aplinkoje
Abiejose aplinkose atsivėrusiame lange patvirtiname ketinimą išsiregistruoti.
16
2 . PROGRAMOS STRUKTŪRA
Šiem skyriuje yra pateikiama Paskalio ir C programų struktūra.
2.1. PASKALIO PROGRAMOS STRUKTŪRA
+ programos antraštė: + programos vardas - programos parametrai
Program vardas (p1, p2);
+ programos blokas: – aprašų dalis: – žymių aprašų skyrius, – konstantų aprašų skyrius, – tipų aprašų skyrius, – kintamųjų aprašų skyrius, – procedūrų ir funkcijų aprašų
skyrius ; + veiksmų dalis: + sakinių dalis; + programos pabaigos simbolis – taškas.
label 12, 15; const c1 = 100; c2 = 2; type t1= …; t2=…; var v1, v2:…; v3:…; function f1…; procedure p…; function f2; begin … end.
Visi programoje naudojami vardai, išskyrus standartinius, turi būti aprašyti. Aprašų skyriai turi būti išdėstyti taip, kaip nurodyta. Tame pačiame blokas turi būti aprašytas tik vieną kartą.
2.1.1. PROGRAMOS ANTRAŠTĖ
Po žodžio program rašomas programos vardas, kuris programos viduje neturi jokios prasmės ir negali būti naudojamas. Programos parametrai žymi kuriuos nors programos išorės objektus (kintamuosius); jų paskirtis — susieti programą su išorės pasauliu. Šie objektai (paprastai failai) vadinami išoriniais ir turi būti aprašyti programos bloke.
2.1.2. MODULIAI Paskalio programa yra vientisas tekstas, sudarytas iš programos antraštės ir programos bloko. Turbo Paskalyje programą galima suskaidyti į dalis – modulius. Moduliai yra savarankiškos programos dalys, jie kompiliuojami atskirai. Moduliai neįtraukiami į programą automatiškai, taigi juos reikia nurodyti: uses Dos, Crt;
2.1.3. ŽYMĖ
Bet kurį programos sakinį galima įvardyti, prieš jį parašius žymę ir dvitaškį. Žymė nuo vardo skiriasi tuo, kad ji sudaroma vien iš skaitmenų ir gali turėti jų ne daugiau keturis: 5: a:=5; {žymė skiriasi nuo skaičiaus 5}. Naudojant žymes atsiranda galimybė naudoti nukreipimo sakinį goto. Turbo Paskalyje žymė gali būti ir vardas:
17
Pirmas: i:=1; Žymių aprašų skyrius prasideda baziniu žodžiu label; jame išvardijamos visos žymės, kuriomis pažymėti sakiniai sakinių dalyje: label 5, 10, 9999; Turbo Paskalyje galima naudoti ir simbolines žymes: label ciklas, 11,10;
2.1.4. KOMENTARAI
Programos komentarai yra apskliaudžiami: {komentarai}
2.2. C PROGRAMOS STRUKTŪRA
C programą sudaro: • Preprocesoriaus komandos: #include <stdio.h> • Tipų apibrėžtys • Funkcijų prototipai • Globalūs kintamieji • Funkcijos. Bent viena funkcija turi būti int main()
C programose komentuoti galima vieną eilutė, tuomet ji turi prasidėti simboliais // Komentarai kitose programos vietose yra rašomi taip: /* komentaras */
18
3. DUOMENŲ TIPAI
3.1. PASKALIO PAPRASTIEJI TIPAI
Bet kuris duomenų tipas apibrėžia tam tikrą reikšmių aibę ir operacijų, kurias galima atlikti su tomis reikšmėmis, aibę. Paprastieji tipai yra diskretieji ir tolydieji (žr. 3-1 pav. ). Tolydus yra vienas, realiųjų skaičių tipas real. Kiti yra diskretieji.
3.1.1. DISKRETIEJI TIPAI
3.1.1.1. Savybės 1. Visos galimos reikšmės sudaro sutvarkytą aibę, ir kiekviena reikšmė yra susieta
su eilės numeriu. 2. Standartinė funkcija ord, pritaikyta bet kuriai diskrečiojo tipo reikšmei, pateikia
šios reikšmės eilės numerį. 3. Standartinė funkcija pred, pritaikyta bet kuriai tipo reikšmei, išskyrus pirmąją,
pateikia prieš ją einančią reikšmę. 4. Standartinė funkcija succ, pritaikyta bet kuriai tipo reikšmei, išskyrus
paskutiniąją, pateikia po jos einančią reikšmę.
3.1.1.2. VARDINIS TIPAS Jame išvardijami vardai, žymintys tas reikšmes.
type savd = (pirm, antr, treč, ketv, penkt, šešt, sekm); spalva = (mėlyna, geltona, raudona);
Operacijos
Be pred, succ, ord yra dar santykio operacijos. 3-1 lentelė pavaizduoja santykio operacijų pavyzdžius su rezultatais.
3-1 lentelė. Operacijos su vardinio ttipo reikšmėmis
Operacija Rezultatas pirm < treč true pred ( trec ) antr succ ( penkt ) sest ord ( antr ) 2
3.1.1.3. ATKARPOS TIPAS Atkarpos tipą galima aprašyti, apribojant jau aprašytą kurį nors diskretųjį tipą. type darb = pirm..penkt; skaitmuo = 0 .. 9;
klaidingi aprašai: x = 1.0 .. 1.5; klaida, nes nediskretus tipas
19
3-1 pav. Paskalio duomenų tipai
n = 5 .. 1; atbulai netinka
s tring tipas
P apras tas is tipas
S truktū rin is tipas
R odyklės tipas
P rocedū ros tipas
D iskre tus is tipas
V ard in is tipas
A tka rpos tipas
S ve ikas is tipas
Log in is tipas
S im bo lin is tipas
R ea lus is tipas
M asyvo tipas
Įrašo tipas
O bjekto tipas
A ibės tipas
F a ilo tipas
D uom enų tipa i
20
3.1.1.4. LOGINIS TIPAS
Loginio tipo aprašyti nereikia, kadangi jis yra standartinis. type boolean = (false, true);
Operacijos And , or, not. Odd(x) — true – x nelyginis, false – x lyginis.
3.1.1.5. SVEIKASIS TIPAS
Žymimas reikšminiu žodžiu integer. Reikšmių aibę sudaro reikšmės nuo –maxint-1 iki maxint, maxint = 215 – 1.
Operacijos: • aritmetinės (+, - , *, /, div, mod), • palyginimo (=, <>, <=, >=, >), • standartinės funkcijos (succ, pred, ord, abs, sqr, sqrt, arctan,
cos, exp, ln, sin). Turbo Paskalyje yra sveikų skaičių tipų rinkinys. 3-2 lentelė išvardina juos kartu su jų
reikšmių aibėmis. 3-2 lentelė. Sveikųjų tipų reikšmių aibės
Tipo pavadinimas Reikšmių aibė Integer -32768 .. 32767 Longint -232 .. 232-1 Byte 0 .. 255 Word 0 .. 65535
3-3 lentelė pateikia sveikųjų skaičių dalybos operacijos pįavyzdžius. 3-3 lentelė. Operacijų su sveikojo tipo reikšmėmis pavyzdžiai
Operacija Rezultatas Operacija Rezultatas Operacija Rezultatas 6 div 2 3 0 div 5 0 7 div 2 3 6 / 2 3.0 0 mod 5 0 7 mod 2 1
3.1.1.6. SIMBOLINIS TIPAS
Šis tipas žymimas reikšminiu žodžiu char, pavyzdžiui ‘a’, ‘2’, ‘%’. Galimos operacijos, galiojančios visiems diskretiems tipams ir palyginimo operacijos. 3-4 lentelė pavaizduoja operacijų pavyzdžius.
3-4 lentelė. Operacijų su simbolinio tipo reikšmėmis pavyzdžiai
21
Operacija Rezultatas Operacija Rezultatas pred(‘c’) ’b’ ord( c ) simbolio kodas kodų lentelėje pred(‘5’) ’4’ chr( i ) simbolis, kurio eilės numeris lygus i
3.1.2. TOLYDUS DUOMENŲ TIPAS – REALUSIS TIPAS
Realusis tipas yra žymimas reikšminiu žodžiu real. Galimos operacijos: • aritmetinės(+, -, *, /), • palyginimo (=, <>, <=, >=, >), • standartinės funkcijos, kurias galima pasižiūrėti bet kurio Turbo Paskalio
vadovėlio matematinių funkcijų priede. Paminėsime kelias dažniau naudojamas funkcijas pavyzdžiui,
o abs(x) – absoliuti reikšmė, o sqr(x) – kelia x kvadratu (x2), o sqrt(x) – traukia šaknį ( x ), o round(x) – apvalina reikšmę, o trunc(x) – atmeta trupmeninę dalį, o kitos, kaip antai sin, cos, exp, ln.
3-5 lentelė pateikia apvalinimo ir trupmeninės dalies funkcijų naudojimo pavyzdžius.
3-5 lentelė. Apvalinimo ir trupmeninės dalies operacijų pavyzdžiai
Operacija Rezultatas Operacija Rezultatas round(4.1) 4 round(-4.1) -4 round(4.7) 5 round(-4.7) -5 trunc(1.2) 1 trunc(-1.2) -1 trunc(5.8) 5 trunc(-5.8) -5
Plačiau standartinės matematinės funkcijos yra nagirnėjamos 8.2.1 skyriuje.
3.2. C PAPRASTIEJI DUOMENŲ TIPAI
3-6 lentelėje yra išvardijami C paprastieji duomenų tipai kartu su reikšmių aibėmis. 3-6 lentelė. C paprastųjų tipų suvestinė
Tipas Ilgis baitais Reikšmės nuo iki char 1 - - unsigned char 1 0 255 short int 2 -32768 32767 unsigned short int
2 0 65536
(long) int 4 -231 +231-1float 4 -3,2*10±38 +3,2*10±38 Double 8 -1,7*10±308 +1,7*10±308
22
3-7 lentelėje sugretinami Paskalio ir C kalbų paprastieji tipai. 3-7 lentelė C ir Pascalio kalbų paprastųjų tipų atitikmenys
C tipas Paskalio tipas char Char unsigned char Byte Short int Integer unsigned short int
Word
long int Longint Float Real Double Extended
Spausdinant reikšmes, reikia nurodyti jų formatus:
%d – sveikieji skaičiai, %f – slankaus kablelio skaičiai, %c – simboliai, %s – simbolių eilutės.
C kalboje nėra loginio tipo, todėl rekomenduojama naudoti unsigned char. Vardinio tipo reikšmes C kalboje galime naudoti, jei aprašysime jį šiuo būdu: Enum savd {pirm, antr, trec, ketv, pentk, sest, sekm};
Vardinio tipo naudojimo pavyzdį iliustruoja žemiau pateikiama programėlė, įvedanti mėnesio numerį ir spausdinanti atitinkamą metų laiką: #include <stdio.h> enum months {JAN=1, FEB, MAR, APR, MAY, JUN, JUL, AUG,SEP, OCT, NOV, DEC}; int main() { enum months month; int i; printf("Iveskite skaiciu nuo 1 iki 12 \n"); scanf("%d", &i); switch (i) { case JAN: case FEB: case DEC: printf("ZIEMA \n"); break; case MAR: case APR: case MAY: printf("PAVASARIS \n"); break; case JUN: case JUL: case AUG: printf("VASARA \n"); break; case SEP:
23
case OCT: case NOV: printf("RUDUO \n"); break; default: printf("netinkamas skaicius \n"); } return 0; }
24
4. KINTAMIEJI
4.1. PASKALIO
Paskalio programos kintamieji aprašome šiuo būdu: var x1, x2: real; i, j, skaitiklis : integer; p : boolean; c: char; raide: ‚a‘ .. ‚z‘; n:1..100;
4.2. C
Kintamuosius C kalboje aprašome, pradžioje nurodydami tipo vardą ir kintamųjų vardus, pavyzdžiui, int i,j,k; float x,y,z; char c;
Pradines reikšmes galima suteikti (inicializuoti) jau aprašant kintamuosius: float sum = 0.0; int bigsum = 0; char letter = ‘a‘;
25
5. OPERACIJOS IR REIŠKINIAI
Operacija – tai veiksmas, suformuojantis reikšmę, vadinamą operacijos rezultatu.
Operacijos pradiniai duomenys – operandai – viena arba dvi reikšmės. Atitinkamai operacija yra vadinama unariąją arba binariąja.
Reiškiniai – tai konstrukcijos naujoms reikšmėms formuoti, atliekant tam tikras operacijas.
5.1. PASKALIS
Reiškinių sudarymo taisyklės nustato operacijų prioritetą: not * / div mod and shl shr + - or xor = <> < > <= >= in
5.1.1. ARITMETINĖS OPERACIJOS
+ - * jei operandų tipas sveikas, tai ir rezultatas sveikas. div, mod sveikųjų skaičių dalyba / dalyba, rezultato tipas – realus.
5.1.2. LOGINĖS OPERACIJOS
not, and or operandų tipas – loginis, rezultatas – loginis (turbo versijoje) xor rezultatas true, jei operandų reikšmės skirtingos, jei vienodos – false Shl Shr bitiniai postūmiai
5.1.3. SANTYKIO OPERACIJOS = <> (nelygu) < > <= >= in
Operandų tipai gali būti visi paprastieji tipai, simbolių eilutės. in antras operandas yra aibės tipo.
Pavyzdys. Kaip patikrinti, ar duotas sveikas skaičius yra tam tikojo sveikojo skaičiaus kvardatas? Pasinaudokime ankščiau minėta funkcija trunc, atmetančią realiojo skaičiaus trupmeninę dalį ir funkcija sqrt, traukiančią šaknį. Jei skaičius yra tam tikro sveikojo skaičiaus kvadratas, tuomet ištraukus šaknį, atmetus rrezultato trupmeninę dalį ir atgal pakėlus kvadratu, turėtų gautis tas pats skaičius. Reiškinys, tikrinantis šią sąlygą yra toks: sqr( trunc (sqrt (skaic) ) ) = skaic
5.2. C
Pagrindinių operacijų prioritetų lentelė: ! ++ -- + - (unarinės) * / %
26
+ - (binarinės) < <= >= > == != && || ?: (Sąlyginis operatorius) = += -=
Paskutinė eilutė iliustruoja įdomų C kalbos aspektą: kitaip nei Paskalyje, priskyrimas C kalboje yra operacija, kuri gamina rezultatą. Tai reiškia, kad ją galima naudoti visur ten, kur gali būti formuojama reikšmė.
Dar vienas aspektas reikalauja atkreipti dėmisį į dalybos ypatumus. Dviejų sveikų skaičių dalybos rezultatas yra sveikas skaičius, tai yra veikia kaip Paskalio div operacija. Jei reikalingas realus rezultatą, reikia atlikti tipo pertvarkymo operaciją: (float) 7/4
5.2-1 pavyzdys Skaičių dalybos operacijos ypatumai C kalboje.
#include <stdio.h> int main() { float x; x=7/4; printf(" 7 / 4 = %.2f \n", x); x=(float)7/4; printf("(float) 7 / 4 = %.2f \n",x ); return 0; } Šios programos rezultatas yra toks: 7 / 4 = 1.00 (float) 7 / 4 = 1.75
Atliekant pirmąsias užduotis dažnai prireikia kėlimo laipsniu funkcijos. Jei reikia skaic pakelti kvadratu, užrašome pow(skaic, 2), o traukti šaknį – pow(skaic,0.5). Kitas standartines panagrinėsime vėliau, 8.2.2 skyriuje.
Pavyzdys. Kaip C kalba patikrinti, ar skaičius yra sveikojo skaičiaus kvadratas? Šis reiškinys užsirašo šiek tiek kitaip nei Paskalio kalboje: trupmeninę dalį atmestime, realaus tipo reikšmę pertvarkydami į sveikojo tipo reikšmę: pow ( (int) pow ( skaic, 0.5) , 2) == skaic
27
6 . SAKINIAI
Programos tikslas – nurodyti veiksmus, kuriuos turi atlikti kompiuteris. Veiksmai Paskalio kalba užrašomi sakiniais. Vienas sakinys nuo kito skiriamas kabliataškiu. Prieš bet kurį sakinį galima rašyti žymę – tada galime nurodyti, kad toliau turi būti atliekamas su žyme nurodytas sakinys.
6.1. PRISKYRIMAS
6.1.1. PASKALYJE
kintamasis := reiškinys;
Pavyzdžiai: x := y + 2;
Tipų suderinamumas: jei tipai tapatūs – problemų nekyla. Iš kairės pusės kintamojo tipo reikšmių aibė turi pilnai apimti dešinės pusės reiškinio tipo reikšmių aibę.
6.1.2. C Kintamasis = išraiška; kintamasis operacija = išraiška;
C kalba leidžia sutrumpinti kai kurių išraiškų užrašą, pvz. C = C + 3; galima užrašyti C += 3;
+= operacija reiškia, kad prie reiškinio kairiosios pusės yra pridedama dešinioji pusė ir rezultatas priskiriamas kairiajai pusei, pavyzdžiui, int c=3, d=5, e=4, f=6, g=12; += c += 3; c = c + 3; c bus 10 -= d -= 7; d = d + 3; d bus 1 *= e *= 5; e = e * 5; e bus 20 /= f /= 3; f = f / 3; f bus 2 %= g %= 9; g = g % 9; g bus 3 c = c + 1; c+=1; c++; ++c; c = c - 1; c-=1; c--; --c; ++a (--a)padidina (sumažina) a vienetu, o toliau naują reikšmę panaudoja išraiškoje, kurioje yra a.
a++ (a--)panaudoja a einamąją reikšmę išraiškoje, o toliau padidina (sumažina) a vienetu.
6.2. SUDĖTINIS SAKINYS
Keli sakiniai jungiami į vieną sakinį ten, kur taisyklės leidžia parašyti vieną sakinį, o reikia daugiau.
28
6.2.1. PASKALYJE
Po vieną sakinį galima rašyti po žodžių then, else, do. Jei sakinių reikia daugiau, tai apskliaudžiame juos žodžiais begin ... end: Begin Sakinys;
Sakinys; Sakinys
End;
6.2.2. C
C kalboje, panašiai kaip ir Paskalyje, sudėtinis sakinys naudojamas sąlyginiame sakinyje po sąlygos (<sąlyga>) ir po else, do, jei reikia panaudoti daugiau nei vieną sakinį apskliaudžiame: { sakiniai; }
6.3. IŠSIŠAKOJIMAI
6.3.1. SĄLYGINIS SAKINYS
6.3.1.1. Paskalyje Pilnas sąlygos sakinys if sąlyga then sakinys else sakinys;
Trumpesnis sakinys: if sąlyga then sakinys;
Pavyzdys: if (taskai >= 20) and (kolokviumas >= 30) then writeln(‘Iskaityta’) else writeln(‘Neiskaityta’);
6.3-1 pavyzdys Įvesti tris sveikus skaičius a,b,c. Išvesti ⎧ -b, jei a+b+c < 0 y= ⎨ 0, jei a+b+c = 0 ⎩ b, jei a+b+a > 0 program pirmas_pavyzdys; var a,b,c: integer; begin write(‘Iveskite tris sveikus skaicius:‘); readln (a,b,c); write(‘Atsakymas yra ‘); if a+b+c < 0 then writeln(-b) else if a+b+c = 0 then writeln(‘O‘) else writeln(b) end.
29
6.3-2 pavyzdys Įvesti 2 sveikus skaičius. Apskaičiuoti ir išvesti reikšmę, nenaudojant standartinių funkcijų:
⎧ max ( |a|, |b|) , jei a lyginis y= ⎨ min (|a|, |b|), jei a nelyginis ⎩ program sąlyga; var a,b,am, bm, y:integer; begin write('Iveskite du sveikus skaicius:'); readln(a,b); if a < 0 then am:=-a else am:=a; if b < 0 then bm:=-b else bm:=b; if a mod 2 = 0 then if am > bm then y := am else y:= bm else if am < bm then y := am else y := bm; writeln('Y=',y ) end.
6.3.1.2. C if (sąlyga) sakinys; else sakinys;
Aukščiau minėtame pavyzdyje, kuriame buvo skaičiuojami įskaitos taškai, sąlygos sakinys galėtų būti užrašomas taip: if (taskai >= 30 && kolokviumas >= 30) printf( ˝Iskaityta \n˝ ); else printf( ˝Neįskaityta \n˝ );
C kalboje yra sąlygos operacija ?: Naujantis ja, pastarąją sąlygą galime perrašyti taip: printf("%s \n", taskai >= 30 && kolokviumas >=30 ? "Iskaityta" : "Neiskaityta");
6.3-3 pavyzdys. Įvesti tris sveikus skaičius a,b,c. Išvesti: ⎧ -b, jei a+b+c < 0 y= ⎨ 0, jei a+b+c = 0 ⎩ b, jei a+b+a > 0 #include <stdio.h> /* Cissisak.c */ int main() { int a,b,c; printf( "Iveskite tris skaicius: "); scanf( "%d %d %d", &a, &b, &c); if ( a + b + c < 0 )
30
printf("Atsakymas yra %d \n", -b); else if (a+b+c==0) printf("Atsakymas yra 0\n"); else printf("Atsakymas yra %d \n", b); }
6.3-4 pavyzdys. Įvesti du sveikus skaičius. Apskaičiuoti ir išvesti reikšmę, nenaudojant standartinių funkcijų:
⎧max ( |a|, |b|) , jei a lyginis, y= ⎨ ⎩min (|a|, |b|), jei a nelyginis #include <stdio.h> int main() { int a,b,am, bm, y; printf("Iveskite du sveikus skaicius "); scanf("%d %d",&a, &b ); if ( a < 0 ) am = -a; else am = a; if ( b < 0 ) bm = -b; else bm = b; if ( a % 2 == 0 ) if ( am > bm ) y = am; else y = bm; else if ( am < bm ) y = am; else y = bm; printf("y= %d\n", y); }
6.3.2. VARIANTINIS SAKINYS
6.3.2.1. Paskalyje case varianto_indeksas of Konstanta : sakinys; Konstanta .. konstanta : sakinys; Konstanta, konstanta, konstanta: sakinys; else sakinys; sakinys; … end
Atliekamas variantinio sakinio sakinys, prieš kurį yra konstanta, lygi varianto indekso reikšmei arba konstantų atkarpa, kuriai priklauso indekso reikšmė. Jei tokių konstantų nėra, tai atliekama else dalis, pavyzdžiui: Case i of 0,2,4,6,8 : writeln(‘Lyginis skaitmuo.’); 1,3,5,7,9 : writeln(‘nelyginis skaitmuo.’); 10 .. 99 : writeln(‘Dvizenklis skaicius.’); else
31
writeln(‘Skaicius neigiamas arba didesnis nei 99’); end
Dar vienas variantinis sakinys: case i of 1: writeln(‘1 pranešimas’); 2: writeln(‘2 pranešimas’); 3: writeln(‘3 pranešimas’); else writeln(‘Neteisingas kodas’); end
6.3.2.2. C
Varinatinis sakinys C kalboje: switch (sveikojo tipo išraiška) { case reiksme_1: Operatoriu_seka_1; Break; case reiksme_2: Operatoriu_seka_2; Break; … case reiksme_n: Operatoriu_seka_n; Break; default: Operatoriu_seka_n_1; }
Šakos default galima neaprašyti. Ši šaka yra vykdoma, jei netenkinama nei viena iš ankstesnių sąlygų. Štai keletas variantinių sakinių: switch (i) { case 0: case 2: case 4: case 6: case 8: printf(“Lyginis skaitmuo \n”); break; case 1: case 3: case 5: case 7: case 9: printf(“\n Nelyginis skaitmuo \n”); break; default: printf(“Kiti skaiciai \n”); } arba Switch (klaidos_nr) { case 1: printf(“\n 1 pranešimas \n”); break; case 2: printf(“\n 2 pranešimas \n”); break; case 3: printf(“\n 3 pranešimas \n”); break; default: printf(“\n Neteisingas klaidos kodas \n”); }
32
6.4. KARTOJIMAI
Veiksmų kartojimas programose yra realizuojamas ciklo sakiniais.
6.4.1. CIKLAS WHILE
6.4.1.1. Paskalyje
while sąlyga do sakinys; sandauga := 2; while sandauga <= 100 do sandauga := sandauga * 2; (6 kartojimai)
6.4-1 pavyzdys. Įvesti sveikus skaičius, pabaigos požymis – 999. Išvesti jų vidurkį bei skaičių, kurie dalinasi iš 5, sumą.
program skaiciu_vidurkis; const PAB=999; var skaitliukas, skaicius, suma, dalus_is_5 : integer; vidurkis:real; begin suma :=0; skaitliukas:= 0; dalu s_is_5 := 0; writeln('Iveskite skaicius. Noredami baigti, iveskite ', PAB); readln(skaicius); while (skaicius <> PAB) do begin inc (skaitliukas); suma := suma + skaicius; if skaicius mod 5 = 0 then dalus_is_5 := dalus_is_5 + skaicius; readln(skaicius) end; vidurkis := suma / skaitliukas; writeln('Skaiciu vidurkis yra ', vidurkis:7:2); writeln(‘Skaiciu, kurie dalinasi is 5, suma yra ‘, dalus_is_5); end.
6.4-2 pavyzdys. Įvesti sveikų teigiamų skaičių seką, kurios pabaiga žymima 0. Išvesti įvestų skaičių skaitmenų sumą..
program skaitmenu_suma;
33
const PAB=0; var skaicius, sk_suma : word; begin writeln(‘Iveskite sveikus skaicius.’); writeln(‘Noredami baigti, iveskite ’, PAB); readln(skaicius); sk_suma := 0; while skaicius <> PAB do begin while skaicius > 0 do begin sk_suma := sk_suma + skaicius mod 10; skaicius := skaicius div 10 end; readln(skaicius) end; writeln(‘Skaitmenu suma yra ’, sk_suma) end.
6.4.1.2. C
Kartojimai C kalba užsirašo panašiai, kaip ir Paskalyje. while (sąlyga) operacija;
sandauga= 2; while (sandauga <= 100) sandauga *=2;
6.4-3 pavyzdys. Įvesti sveikus skaičius, pabaigos požymis – 999. Išvesti jų vidurkį ir dalių iš 5 skaičių sumą. .
#include <stdio.h> #define PAB 999 int main() { int skaitliukas, skaicius, suma, dalus_is_5; float vidurkis; suma = skaitliukas = dalus_is_5 = 0; printf("\n Iveskite skaicius. Noredami baigti, iveskite %d \n", PAB); scanf("%d", &skaicius); while (skaicius != PAB ) { skaitliukas++; suma += skaicius; if (skaicius % 5 == 0) dalus_is_5 += skaicius; scanf("%d", &skaicius); } vidurkis = (float) suma/skaitliukas; printf("Skaiciu vidurkis yra %.2f\n", vidurkis); printf("Skaiciu, kurie dalinasi is 5, suma yra %d\n", dalus_is_5); }
Jei reikia paskaičiuoti, kiek yra skaičių, tuomet skaičiuojame, kaip skaitliuką, kiek++;
34
6.4-4 pavyzdys. Įvesti sveikų teigiamų skaičių seką, kurios pabaiga žymima 0. Išvesti įvestų skaičių skaitmenų sumą.
#include <stdio.h> int main() { short const PAB=0; int skaicius, sk_suma; sk_suma=0; puts("Iveskite sveikus skaicius."); printf("Noredami baigti, iveskite %d\n", PAB); scanf("%d", &skaicius); skaicius=skaicius<0 ? -skaicius : skaicius; while ( skaicius != PAB ) { while (skaicius>0) { sk_suma += skaicius % 10; skaicius /= 10; } scanf("%d", &skaicius); } printf("Skaitmenu suma yra %d \n", sk_suma); }
6.4.2. CIKLAS REPEAT – DO WHILE
6.4.2.1. Paskalyje
Repeat Sakinys; Sakiniai vykdomi tol, kol sąluga yra Sakinys; netenkinama (false) … until sąlyga;
BDD algoritme: repeat liekana := A mod B; A := B; B := liekana; until B = 0;
Pastaba. Iš sakinio apibrėžties išplaukia, kad repeat cikle begin end nenaudojami.
6.4-5 pavyzdys Simbolių įvestis ir išvestis, naudojant kartojimus Paskalyje.
program simboliai; {repeat.pas} var c:char; begin writeln(‚Iveskite simbolius. ‚); writeln(‚ Noredami baigti, spauskite
Program simboliai; {while3.pas} var c:char; begin writeln('Iveskite simbolius. Noredami baigti, spauskite ENTER')
35
ENTER‘) repeat read(c); write(c); until eoln end.
read(c); while not eoln do begin write(c); read(c); end end
6.4-6 pavyzdys. Ivesti skaicių seką. Paskaičiuoti, kiek iš jų dalinasi iš 3.
program kiek_dalinasi_is_3; var skaic, dal_is_3:integer; begin dal_is_3 := 0; writeln('Iveskite skaiciu seka. Noredami baigti, iveskite 0'); repeat read(skaic); if skaic mod 3 = 0 then inc(dal_is_3); until skaic=0; writeln(dal_is_3, ' skaiciai dalinasi is 3'); end.
6.4.2.2. Kartojimai C kalboje
do Operatorius while (sąlyginė išraiška);
BDD pavyzdys: do { liekana = A % B; A = B; B = liekana; } while (B != 0);
Ciklas baigia darbą, kai sąlyga yra netenkinama. Pavyzdys, įvesti simbolių eilutę, pabaigos požymis – klavišo Enter paspaudimas. Toliau ją išvesti.
6.4-7 pavyzdys. Simbolių įvedimas, naudojant kartojimus C kalboje
/* dowhile1.c */ #include <stdio.h> int main() { char ats; do { scanf("%c", &ats); printf("%c", ats); } while (ats != '\n'); }
#include <stdio.h> /* cwhile3.c */ int main() { char ats; printf("Iveskite simboliu seka. Noredami baigti, spauskite ENTER\n"); scanf("%c", &ats); while (ats != '\n') { printf("%c", ats); scanf("%c", &ats); } }
Iš šio pavyzdžio matome, kad ciklų while ir do while naudojimas šiek tiek skiriasi.. Pirmam prieš tikrinant sąlygą, reikia priskirti ciklo sąlygos kintamajam reikšmę. Lyginant su do
36
while, turime panaudoti papildomą įvesties sakinį. Vadinasi, jei kartojamą sakinį reikia atlikti bent vieną kartą, prasmingiau naudoti do while.
Antrasis skirtumas atsiranda perskaičius simbolį „nauja eilutė“. Ciklas while spausdina visus simbolius, kol pasirodo naujos eilutės simbolis. Ciklas do while spausdina visus simbolius, įjungdamas ir „naujos eilutės“ simbolį. Tik atspausdinus šį simbolį yra lyginama, ar lygus „naujos eilutės simboliui“. Cikle while ši sąlyga tikrinama prieš vykdant ciklo kūną.
6.4-8 pavyzdys. Įvesti skaičių seką. Paskaičiuoti, kiek iš jų dalinasi iš 3.
#include <stdio.h> int main() { int sk, kiek=0; printf("Iveskite skaiciu seka. Noredami baigti, iveskite 0\n"); do{ scanf("%c", &sk); if ( sk % 10 == 3 ) kiek++; } while (sk != 0) printf("Skaiciu, daliu is 3 yra %d\n", kiek); }
6.4.2.3. C ir Paskalio kartojimų palyginimas
1. While sakinys kartojamas tol, kol sąlyga tenkinama (true). Repeat sakinys atliekamas tol, kol sąlyga yra netenkinama (false). Taigi, while cikle sąlyga nurodo ciklo tęsimo sąlygą, o repeat cikle – ciklo pabaigos sąlygą.
2. While cikle kartojamas vienas sakinys, o repeat cikle – sakinių grupė. Todėl jei while cikle reikia atlikti daugiau sakinių apskliaudžiame juos begin end, o repeat – nereikia.
3. While sakinye iš karto yra tikrinama sąlyga, o po to atliekamas arba neatliekamas po do einantis sakinys, Repeat sakinyje iš karto yra atliekama sakinių seka, o po to tik tikrinama sąlyga. Vadinasi, šiuo atveju, sakinių seka yra atliekama bent vieną kartą.
6.4.3. CIKLAS FOR
6.4.3.1. Paskalyje
Šis ciklas yra naudojamas, kai rašydamas programą , programuotojas gali nusakyti, kiek kartų kartosis tam tikras veiksmas.
Galimos dvi šio sakinio versijos. Kai ciklo kintamasis prabėga nuo mažesnes iki didesnės reikšmes, naudojamas šis aprašas: For <ciklo kintamasis> := <pradine reiksme> to <galutine reiksme> do <sakinys>;
Jei atvirkščiai, ciklo kintamasis prabėga nuo didesnės iki mažesnes reikšmes, naudojamas šis aprašas: For <ciklo kintamasis> := <pradine reiksme> downto <galutine reiksme>
37
do <sakinys>;
Toliau pateikiami keli šio sakinio naudojimo pavyzdžiai:
for i:= 1 to 10 do suma := suma + i; for savd:= pirma to penkt do darbas:= darbas +8;
6.4-9 pavyzdys. For ciklo naudojimo pavyzdėliai. {Atspausdinti lotyniškas raides nuo a iki z.} {Forsimb.pas} program for_simb; var r:char; begin for r:='a' to 'z' do write (r, ' '); end.
{Atspausdinti kvadratų lentelę} {KVADRLEN.PAS} program kvadr_lentele; var i : integer; begin for i:=1 to 100 do write(i:4, i*i:5); writeln end.
6.4.3.2. C
Dažniausiai naudojama bendra ciklo forma, kai nustatoma ciklo kintamojo pradinė reikšmė, ciklo pabaigos sąlygos tikrinimas, ciklo kintamojo keitimas:
For (nebūtina_išraiška1; nebūtina_išraiška2; nebūtina_išraiška3) operatorius;
Kievieną iš trijų išraiškų galime praleisti, bet kabliataškius padėti būtina. Pirmoji išraiška paprastai naudojama nustatyti pradinei reikšmei, antroji – tikrinti ciklo pabaigos sąlygai, trečioji – padidinti indeksui. // Kvadratų lentelė. FORKVADR.C #include <stdio.h> int main() { int i; for(i=1; i<100; i++) printf("%4d %5d", i, i*i); printf("\n"); }
// Raidės nuo a iki z FORSIMB.C#include <stdio.h> int main() { int r; for(r='a'; r<='z'; r++) printf("%c ", r); printf("\n"); }
6.4.4. CIKLO VALDYMAS, NAUDOJANT BREAK, CONTINUE, GOTO
Ciklo ir sąlyginiai operatoriai yra pagrindinės programos veiksmų sekos valdymo priemonės. Jos yra taikomos bendrai programos struktūrai realizuoti. Toliau nagrinėjami operatoriai yra naudojami žymiai rečiau, nes jie apsunkina programos skaitomumą ir modifikavimą. Jie yra naudojami išimtiniais atvejais.
Svarbiausias yra break. Jau matėme, kad break yra naudojamas operatoriuje switch. Jei, vykdant programą, yra susiduriame su operatoriumi break, tai išeinama iš duotos konstrukcijos ir
38
pereinama į kitą programos operatorių. Jeigu šis operatorius yra viename iš ciklų, įterpti į kitą ciklą, tai jis veikia tik tam ciklui, kuriame jis yra. Būna atveju, kai break taikomas ciklo darbui nutraukti, jei nurodytos dvi skirtingos ciklo pabaigos sąlygos.
6.4.4.1. Paskalyje
{Atspausdinti 20 ivestų skaičių. Jei anksčiau buvo 0 – nutraukti ciklą} program ciklas_su_break; var i,k:integer; begin write(' Iveskite... galas-0'); for i:=1 to 20 do begin read(k); if k = 0 then break; if i = 1 then write('Rezultatas:', k, ' ') else write(k, ' ') end; writeln end.
{Atspausdinti kvadratų lentelę} program ciklas_su_goto; label v; var i,k:integer; begin for i:=1 to 20 do begin write(' Iveskite... galas-0'); read(k); if k = 0 then goto v; if i = 1 then write('Rezultatas:', k, ' ') else write(k, ' ') end; v: writeln end.
Pastaba. Programėlė su goto ir label veikia tik Turbo Pascal aplinkoje, Linux‘o FreePascal reikalauja papildomų kompiliatoriaus komandų. (Break.pas, goto.pas, continue.pas) break.pas. Iveskite 20 sveiku skaiciu. Norite baigti anksciau, iveskite 0. Ivesta: 1 2 0 3 0 4 0 5 0 5 0 7 0 8 0 9 0 10 0 11 0 12 0 13 0 14 0 Rezultatas: 1 2
6.4-10 pavyzdys. Programėlė, nespausdinanti nulius skaičių sekoje.
program ciklas_su_continue; {continue.pas} var i,k:integer; begin writeln('Continue.pas. Iveskite 20 sveiku skaiciu.'); write('Ivesta: '); for i:=1 to 20 do begin read(k); if k = 0 then continue; if i = 1 then write('Rezultatas:', k, ' ') else write(k, ' ') end; writeln end.
Programos vykdymas: Continue.pas. Iveskite 20 sveiku skaiciu. Įvesta: 1 2 0 3 0 4 0 5 0 5 0 7 0 8 0 9 0 10 0 11 0 12 0 13 0 14 0
39
Rezultatas: 1 2 3 4 5 5 7 8 9 10 11
6.4.4.2. C
C kalboje break, continue ir goto operatorių prasmė ir veikimas analogiškas. Todėl šiame skyrelyje C kalba pįerrašyti Paskalio skyrelyje naudoti pavyzdžiai.
//Su valdymo operatoriais CBREAK.C #include <stdio.h> int main() { int i, ch; printf("\n Iveskite iki 20 skaiciu, 0 - pabaiga.\n Ivesta: "); for ( i = 1; i<=20; i++) { scanf("%d", &ch); if ( ch == 0 ) break; printf("%d ", ch); } printf("\n"); } Šios programos rezultatas: Iveskite iki 20 skaiciu, 0 - pabaiga. Įvesta: 1 2 0 3 0 4 0 5 0 5 0 7 0 8 0 9 0 10 0 11 0 12 0 13 0 14 0 1 2
Operatorius continue gali būti naudojamas visuose ciklo operatoriuose, bet ne operatoriuje switch. Jei pasitaiko ciklo operatoriuje, tai likusieji ciklo operatoriai praleidžiami ir pereinama prie naujos ciklo iteracijos. (goto : failas cgoto.c, continue: Ccontinue.c)
40
7. STRUKTŪRINIAI TIPAI
7.1. MASYVAS
Paskalis C M[1] -45 M[0] M[2] 6 M[1] M[3] 0 M[2] M[4] 25 M[3] M[5] 1543 M[4]
Masyvas – tai vieno tipo reikšmių rinkinys, pavadintas vardu. Aprašant masyvą yra nurodoma, kiek maksimaliai jame yra elementų. Kreipiantis į masyvo elementą, nurodome masyvo vardą ir elemento eilės numerį, kitaip vadinamą masyvo indeksu.
Aukščiau pavaizduotame masyve M yra 5 elementai. Indeksas yra diskreti reikšmė. Vieno indekso masyvas vadinamas vienmačiu, dviejų – dvimačiu, jei n indeksų – n-mačiu.
Pagrindiniai veiksmai, dirbant su masyvu: 1) didžiausios arba mažiausios reikšmės paieška, 2) skaičiavimai (sumos, sandaugos kiekio, vidurkis), 3) atpažinimas (ar yra rinkinyje tam tikra reikšmė), 4) rikiavimas (didėjimo arba mažėjimo tvarka), 5) elementų šalinimas iš masyvo elementų, kurio indeksas yra k, toliau už jo esančios,
elementus reikia pastumti per vieną poziciją link pradžios.
7.1.1. PASKALYJE
Type m = array[1..100] of integer; Puslapis = array [1..66,1..120] of char;
Kiekvienas masyvo elementas nurodomas vardu ir laužtiniuose skliaustose rašomi vienas ar keli indeksai, pavyzdžiui, Var a: array [1..2, 1..3] of integer;
Šio masyvo elementai yra a[1,1], a[1,2], a[1,3], a[2,1], a[2,2], a[2,3].
Operacijos. Su masyvais galima tik priskyrimo operacija, jei tie tipai yra tapatūs.
7.1-1 pavyzdys. Masyvo priskyrimo pavyzdys
Program priskyrimas; type kryptis = (x, y, z); vektorius = array [ kryptis ] of real; var u, v : vektorius’ i : kryptis; begin writeln(‘Iveskite tris skaicius’); for i := x to z do read ( v[i] ); writeln(); u:=v;
41
end.
Toliau yra pateikiami dažniausių veiksmų su masyvais šablonai: Didžiausia masyvo reikšmė max := m[1]; for i:=2 to N do if max < m[i] then max = m[i];
Sumos skaičiavimas suma := 0; for i:= 1 to N do suma := suma + m[i];
Atpažinimas yra := false; for i:=1 to N do if ieskoma_reiksme = m[i] then yra := true;
{Pašalinti k-tąjį elementą} for i:= k to N-1 do m[i] := m[i+1]; {Įterpti reikšmę į k-tąją vietą, kai N<NUM} for i:= N downto k do m[i+1] := m[i]; m[k] := iterpiama_reiksme;
Pastaba. Reikšmės įterpimo fragmente N-toji reikšmė yra perkeliama į N+1 vietą. Kadangi elementų skaičius negali viršyti atmintyje išskirtų elementų kiekio, vadinasi prieš įterpiant reikia isitikinti, kad įterpinėti dar galima. Kitaip tariant, jei N = NUM (atmintyje išskirtam elementų skaičiui), tai įterpimas neturi būti vykdomas.
7.1-2 pavyzdys. Masyvo elementų įvestis ir išvestis. Įvesti masyvo
reikšmes ir atspasdinti po 5 eilutėje. program ivestis; const NUM = 50; type masyvas = array [1..NUM] of integer; var i, N : integer; mas : masyvas; ch : char; begin writeln( 'Kiek bus skaiciu?' ); readln( N ); writeln( 'Iveskite ', N, ' skaiciu: ' ); for i := 1 to n do read( mas[i] ); writeln('Ivesta:'); for i := 1 to n do begin write( mas[i],' '); if i mod 5 = 0 then writeln; end; writeln; end.
7.1.2. C
Masyvas C kalboje aprašomas taip: Duomenų_tipas masyvo_vardas [masyvo_dydis]
Į masyvo elementus kreipiamasi, nurodant masyvo vardą ir indeksą: masyvo_vardas [indeksas]
42
Indekso reikšmės turi būti nuo 0 iki reikšmės, vienetu mažesnės už masyvo dydį, nurodytą masyvo aprašyme. Keletas pavyzdžių:
char vardas[20]; int reiksmes[12] float dydis[30];
Pirmasis iš masyvų turi 20 simbolių. Kreipiniai į šio masyvo elementus yra šie: vardas[0], vardas[1], … vardas[19]. Toliau pateikiami svarbiausių operacijų su masyvais šablonai: Didžiausia masyvo reikšmė: max = m[0]; for (I = 0; i < n; i++) if ( max < m[i] ) max = m[i];
Sumos skaičiavimas suma = 0; for ( i = 0; i < n; i++ ) suma += m[i];
Atpažinimas: yra = 0; for ( i = 0; i < N; i++) if ( ieskoma_reiksme == m[i] ) yra = 1;
Pašalinti k-tąjį elementą for (i = --k; i < N-1; i++) mas[i] = mas[i+1];
Įterpti reikšmę į k-tąją vietą k--; for (i = N; i >= k; i-- ) mas[i+1] = mas[i]; mas[k] = iterpiama_reiksme;
Pastaba. Reikšmės įterpimo fragmente N-toji reikšmė yra perkeliama į N+1 vietą. Kadangi elementų skaičius negali viršyti atmintyje išskirtų elementų kiekio, vadinasi prieš įterpiant reikia isitikinti, kad įterpinėti dar galima. Kitaip tariant, jei N = NUM (atmintyje išskirtam elementų skaičiui), tai įterpimas neturi būti vykdomas.
7.1-3 pavyzdys Įvesti masyvo reikšmes ir jį atspausdinti po 5 eilutėje.
#include <stdio.h> #define NUM 50 int main() { int i, N, mas[NUM]; printf("Kiek bus elementu? \n"); scanf("%d", &N); printf("Iveskite %d elementu\n", N); for ( i = 0; i < N; i++) scanf( "%d", &mas[i] ); printf( "Ivesta:\n" ); for ( i = 0; i < n; i++ ) { printf( "%d ", mas[i] ); if ( (i+1) % 5 == 0 ) printf("\n"); } printf("\n"); return(0); }
43
7.1-4 pavyzdys. Skaičių masyvo apdorojimo programėlė.
/* Ivesti skaiciu N, kuris reiškia, kiek skaicių bus rinkinyje. Toliau įvesti N skaicių. Parašyti programą, kuri ekrane parodytą skaičius, kurie dalijasi be liekanos iš sveikojo skaičiaus. Analizė yra tęsiama, kol naudotojas įveda daliklius. */ program pvz_7_1_4; const ILGIS = 100; type rinkinys = array [1..ILGIS] of integer; var N,i,p : integer; mas : rinkinys; baigti: char; begin writeln('Kiek ivesite skaiciu (iki '‚ ILGIS, ' ): '); readln(N); writeln('Iveskite ', N, ' skaiciu:'); for i:=1 to N do read( mas[i] ); readln; repeat write( 'Iveskite dalumo pozymi: ' ); readln( p ); if p = 0 then begin writeln( 'Is 0 dalinti negalima' ); continue; end; writeln('Skaiciai, kurie dalinasi is ', p, ':' ); for i:= 1 to N do if mas[i] mod p = 0 then write( mas[i]:6 ); writeln; write('Jei norite baigti, spauskite T arba t: '); readln(baigti) until (baigti = 'T' ) or (baigti = 't' ); end.
7.1-5 pavyzdys. 7.1-4 pavyzdys perrašytas C kalba.
#include <stdio.h> #define ILGIS 100 int main() { int kiek,i,p, mas[ILGIS]; char baigti; printf("Kiek ivesite skaiciu? "); scanf("%d", &N); printf("Iveskite %d skaiciu:\n ", N ); for ( i = 0; i<N; i++) scanf("%d", &mas[i] ); do { printf("Iveskite dalumo pozymi: "); scanf("%d", &p); while ( getchar() != ’\n’ );
44
if (p==0) { printf("Is 0 dalinti negalima\n"); continue; } printf("Skaiciai, kurie dalinasi is %d:", p); for (i=0; i < N; i++) if (mas[i] % p == 0) printf("%7d", mas[i]); printf("\n"); printf("Jei norite baigti, spauskite T arba t."); baigti = getchar(); /* scanf("%c", &baigti);*/ } while (baigti !='t'&& baigti !='T'); return(0); }
7.1-6 pavyzdys. Realiųjų skaičių masyvo apdorojimo programėlė. Klaviatūra įvedami n skritulių spinduliai. Išvesti spindulius, kurių plotas yra didesnis už p. program spinduliai; { skritul.pas } const ILG = 100; PI = 3.14159; type mas = array [1..ilg] of real; var n, {skrituliu kiekis} i : integer; spind : mas; p, pl : real; {skrituliu plotai} begin write('Iveskite skrituliu kieki: '); readln( n ); write('Iveskite plota P:'); readln( p ); { Ivedame spindulius } for i:=1 to n do begin write('Iveskite ', i:3, ' - ji spinduli: '); readln( spind[i] ); end; writeln('Spinduliai, kuriu plotas yra didesnis uz', p:5:2,':'); for i:= 1 to n do begin pl := PI * sqr ( spind[i] ); if pl > p then write( spind[i]:7:2 ); end; writeln; end.
7.1-7 pavyzdys. Šioje programėlėje 7.1-6 pavyzdys perrašytas C kalba. #include <stdio.h> int main()
45
{ const short ILG = 100; const float PI = 3.14159; float p, pl, spind[100]; short n, /* skrituliu kiekis */ i; printf( "Iveskite skrituliu kieki: "); scanf( "%d", &n ); printf( "Iveskite plota P: " ); scanf( "%f", &p ); for ( i = 1; i <= n; i++ ) /* Ivedame spindulius */ { printf( "Iveskite %3d - ji spinduli: ", i ); scanf ( "%f", &spind[i] ); } printf("Spinduliai, kuriu plotas yra didesnis uz %.2f:\n", p); for ( i = 1; i <= n; i++) { pl = PI * spind[i] + spind[i]; if ( pl > p ) printf(" %.2f", spind[i] ); } }
7.1-8 pavyzdys. Įvesti tekstą su tarpais. Paskaičiuoti, kiek jame yra žodžių.
program zodziai; const L = 80; type mas = array[0..L] of char; var a : mas; zd, n, i : integer; begin zd := 0; n :=0; repeat inc(n); read(a[n]); until eoln or ( n = L ); a[0] := ' '; for i := 1 to n do if ( a[i-1] = ' ' ) and ( a[i] <> ' ' ) then inc(zd); writeln( 'Zodziu tekste yra ', zd ); end.
7.1-9 pavyzdys. Šioje programėlėje 7.1-8 pavyzdys perrašytas C kalba. #include <stdio.h> #define L 80 int main() { int i, n, zd; char a[L+1];
46
zd = n = 0; printf("Iveskite teksta:\n"); do a[ ++n ] = getchar(); while( a[n] != '\n' && n < L ); a[0]=' '; for ( i = 1; i < n; i++ ) if (a [i-1] == ' ' && a[i] != ' ') zd++; printf("Zodziu tekste yra %d \n", zd); return(0); }
7.1.3. DAUGIAMAČIAI MASYVAI
Paskalyje pradines reikšmes galima priskirti tik masyvo tipo konstantoms.
7.1-10 pavyzdys iliustruoja šį inicializacijos būdą.
7.1-10 pavyzdys. Dvimačio masyvo inicializacija, įvestis ir išvestis.
program dvimatis_masyvas; {dvimatis.pas} const N = 2; M = 3; mas1 : array[1..N, 1..M] of integer=((1,2,3),(4,5,6)); var mas2 : array [1..N, 1..N] of integer; i, j : integer; begin writeln('Inicializuotas masyvas'); for i:= 1 to N do for j := 1 to M do write ( mas1[i,j], ' '); writeln; writeln( 'Iveskite 4 skaicius:' ); for i := 1 to N do for j := 1 to N do read (mas2[i,j]); writeln( 'Ivestas masyvas:' ); for i := 1 to N do begin for j := 1 to N do write ( mas2[i,j], ' ' ); writeln end end.
C kalboje masyvui pradines reikšmes galima priskirti taip, kaip ir kitiems kintamiesiems.
7.1-11 pavyzdys. Dvimačio masyvo inicializacija, įverstis ir išvestis C kalboje.
#include <stdio.h> #define N 2 #define M 3
47
int main() { int mas1[ N ][ M ] = { { 1, 2, 3 }, { 4, 5, 6 } }, mas2[N][N], i,j; puts("Inicializuotas masyvas:" ); for ( i = 0; i < N; i++ ) { for ( j = 0; j < M; j++ ) printf( "%d ", mas1[ i ][ j ] ); printf( "\n" ); } puts("Iveskite 4 reiksmes:"); for ( i = 0; i < N; i++ ) for ( j = 0; j < N; j++ ) scanf( "%d", &mas2[ i ][ j ] ); puts("Ivestas masyvas"); for ( i = 0; i < N; i++ ){ for ( j = 0; j < N; j++ ) printf( "%d ", mas2[ i ][ j ] ); printf("\n"); } return 0; }
Šių pavyzdžių veikimo rezultatas: Inicializuotas masyvas: 1 2 3 4 5 6 Iveskite 4 reiksmes: 1 2 3 4 Ivestas masyvas 1 2 3 4
7.2. ĮRAŠAI
Jau angrinėjome struktūrinį duomenų tipą – masyvus. Masyvo elementai yra vieno tipo. Įrašo tipas yra sudaromas iš įvairios struktūros duomenų. Įrašas yra sudaromas iš skirtingų tipų komponentų, kurie yra vadinami laukais. Kiekvienas įrašo laukas nusakomas tipu ir vardu, kuriuo jis yra žymimas. Vardas naudojamas nurodant lauką. To paties įrašo laukai gali būti skirtingų tipų. Tuo įrašai skiriasi nuo masyvo – šio visi elementai turi būti to paties tipo.
7.2.1. PASKALYJE
Type data=record metai : integer; menuo : 1..12; diena : 1..31; end; alfa=array [1..20] of char; asmuo=record
48
vardas, pavarde : alfa; gmdata : data end;
Laukai yra skiriami kabliataškiu. Sintaksė leidžia ir po paskutiniojo lauko aprašo rašyti kabliataškį. Įrašo tipo kintamasis ytra aprašomas taip: var a:asmuo; d:data;
Įrašų laukai nurodomi selektoriais: a.vardas a.pavarde a.gmdata.metai
Kadangi laukas gimimodata taip pat yra įrašas, todėl jo dalys metai, menuo ir diena nurodomos, dar kartą panaudojus selektorių.
7.2-1 pavyzdys. Asmens vardas, pavardė ir gimimo metai yra saugomi įraše. Reikia juos įvesti ir atspausdinti.
program asmens_irasai; type asmuo = record vardas, pavarde : array [1..20] of char; gmmetai : word; end; var a : asmuo; i : byte; begin write( 'Iveskite varda ' ); i := 0; while not eoln do begin inc( i ); read( a.vardas[i]) end; readln; write( 'Iveskite pavarde ' ); i := 0; while not eoln do begin inc( i ); read( a.pavarde[i] ) end; readln; write( 'Iveskite gimimo metus: ' ); readln( a.gmmetai ); writeln( 'Vardas: ', a.vardas ); writeln( 'Pavarde: ', a.pavarde ); writeln( 'Gimimo metai: ', a.gmmetai ); end.
7.2.2. C
C kalboje įrašai uyra aprašomi, naudojant reikšminį žodį struct. Todėl kai kada jie yra vadinami struktūromis. Struct strukturos_vardas { tipas_1 laukas_1;
49
tipas_2 laukas_2; … tipas_n laukas_n; }; /* dažna klaida – pamirštama ; */ Datos įrašo aprašas atrodo taip: struct data { int metai, menuo, diena; };
7.2-2 pavyzdys. Įrašų naudojimą C kalba iliustruoja Ca kalba perrašytas 7.2-1 pavyzdys.
#include <stdio.h> struct asmuo { char vardas[20], pavarde[20]; short gmmetai; }; int main() { struct asmuo a; printf( "\n Iveskite varda: " ); scanf( "%s", a.vardas ); printf( "Iveskite pavarde: " ); scanf( "%s", a.pavarde ); printf( "Iveskite gimimo metus: " ); scanf( "%d", &a.gmmetai ); printf( "\n Vardas: %s \n Pavarde: %s \n ", a.vardas, a.pavarde ); printf( "Gimimo metai: %d\n", a.gmmetai ); return(0); }
7.3. PASKALIO ĮRAŠAI SU VARIANTINE DALIMI
Įrašo sintaksė leidžia įtraukti į įrašą ir vadinamąją variantinę dalį. Tai reiškia, kad galima įtraukti kelis struktūros variantus. Case varianto_selektorius of <konstanta> : (laukų aprašas); <konstanta>, <konstanta> : (laukų aprašas); Pavyzdys. Pateiksime įrašo su variantine dalimi pavyzdį. Tarkime, norime aprašyti tipą asmuo, kuriame yra tokia informacija apie asmenį: a) vardas, pavardė b) paso numeris c) lytis d) gimimo data (metai, mėnuo, data) e) šeimyninė padėtis (vedęs, našlys, išsiskyręs, viengungis)
i. jei yra vedęs arba našlys, tuomet yra saugoma paskutinių vedybų data. ii. Jei išsiskyręs, tai paskutinių skyrybų data
ar pirmosios skyrybos (true, false) iii. Jei viengungis, tai nepriklausomumo statusas (true, false).
50
Matome, kad tipas asmuo yra natūraliai aprašomas įrašu su variantine dalimi.
Type lytis = (vyras, moteris); alfa = array [1..20] of char; šeimpadėtis = (vedęs, našlys, išsiskyręs, viengungis); asmuo = record vardas, pavardė: array [1..20] of char; paso_numeris : word; lytis : l; gimdata : data; case statusas : šeimpadėtis of vedęs, našlys:( vdata:data ); išsiskyręs( sdata:data; pirmosios : boolean ); viengungis( neprikl : boolean ); end;
Jonas Petras Jonaitis Petraitis 38888888888 3123456123 Vyras Vyras 1975 10 12 1935 3 15 3 1 Viengungis Išsiskyręs True 1972 2 23 false Pastabos. 1. Visų laukų vardai turi būti skirtingi, netgi jeigu jie priklauso skirtingiems variantams. 2. Jei variantinėje dalyje yra tuščias laukas, tai turi būti rašomas taip: L( ); 3. Bet kuris įrašas gali turėti tik vieną variantinę dalį ir ji turi eiti po pastovios dalies. Reikšmių variantinių įrašų laukams suteikimas: p.vardas : = ‘Jonas’; p.pavardė : = ‘Jonaitis’; p.paso_numeris : = 2333333333; p.lytis=vyras; p.gimdata.metai:=1975; p.gimdata.mėnuo:=10; p.gimdata.diena:=20; p.islaikytiniai:=3; p.statusas:=viengungis; p.neprikl:=true;
Įrašo variantinė dalis yra apibrėžta, kai yra apibrėžta, jeigu apibrėžtas kuris nors jos variantas.
7.4. SĄJUNGA (UNION)
Sąjunga – tai priemonė, kurią naudojant galima įsiminti skirtingų tipų duomenis toje pačioje vietoje. Sąjungos aprašas:
51
Union sąjunga { int sk; double ilgis; char sb; };
Sajungos tipo kintamųjų aprašai: union sąjunga vienas; union sąjunga mas[10]; /* sąjungos elementų masyvas */
Pirmasis aprašymas sukuria vieną kintamąjį vienas. Kompiliatorius išsikiria tiek atminties, kad tilptų didžiausias iš sąjungos kintamųjų. Šiuo atveju didžiausias yra double tipo kintamasis. Jam reikia 8 baitų. Masyvas mas[10] turi 10 elementų. Kiekvieno elemento plotis yra 8 baitai.
Reikšmių priskirimas: Vienas.sk=2; Vienas.ilgis=20.0; Vienas.sb=’a’;
Sąjungoje yra saugoma tik paskutinė pristkirta reikšmė. Programuotojas pats turi sekti, kad būtų įrašyta reikiamo tipo reikšmė. Klaidingi veiksmai: Vienas.sb = ’a’; Skaic = 55.4 * vienas.ilgis; /* klaida, nes paskutinis priskyrimas įrašė simbolį,
o čia tikimasi double tipo reikšmės*/ 7.5. AIBĖS
Aibės tipo reikšmė Paskalyje yra suprantama kaip bet kurio tipo, vadinamo baziniu, reikšmių poaibis.
7.5.1. APRAŠAS
Type atspalvis = set of (mėlyna, geltona, balta); skaitm = set of 0..9; raidės = set of ΄a΄..΄z΄; login = set of boolena;
Aibės reikšmės yra apskliaudžiamos laužtiniuose skliaustuose. Visų reiškinių tipai yturi būti ekvivalentūs baziniam tipui. [ ] žymi tuščią aibę. [x..y] žymi reikšmių atkarpos aibę, jei x>y, tuomet aibė yra tuščia.
Pavyzdžiui, aibės atspalvis visos galimos reikšmės yra šios: [], [mėlyna], [geltona], [raudona], [mėlyna, geltona], [mėlyna raudona], [raudona, geltona], [mėlyna, geltona, raudona].
Aibės tipo kintamieji yra aprašomi taip: var s : set of 1..5; sp : atspalvis;
7.5.2. OPERACIJOS
Priskirti reikšmę: s:=[1,3,5]
52
sp:=[raudona];
Aibių negalima nei skaityti, nei rašyti. Su jomis atliekamos sąjungos ∪ (+), skirtumo \(-), sankirtos ∩(*) ir santykio (=, <>, <, <=, >, >=) operacijos. Operacijų apibrėžtys sutampa su matematikos atitinkamų operacijų apibrėžtimis: [mėlyna, raudona] + [geltona, raudona ] → [mėlyna, geltona, raudona] [mėlyna, geltona] - [geltona, raudona ] → [mėlyna] [mėlyna, geltona] * [geltona, raudona ] → [geltona] [mėlyna, geltona] ≤ [geltona, raudona ] → false (A apima B) [0..7] + [0..7] → [0..7] [0..5] + [10..15] → [0..5,10..15] [0..5] - [0..7] → [] [0..7] - [0..5] → [6,7] [0..7] - [1..5] → [0,6,7] [0..5] * [0..7] → [0..5] [0..5] ≤ [0..7] → true
Operacija x in a yra true, jei x priklauso aibei a ir false – priešingu atveju. raudona in [raudona, mėlyna] → true geltona in []→ false
Veiksmai su aibėmis yra atliekami gana sparčiai, todėl juos patogu naudoti vietoje kelių santykio operacijų, pavyzdžiui, vietoje if (ch = ‘a‘) or (ch = ‘b‘) or (ch = ‘c‘) or (ch=‘d‘) or (ch=‘z‘) then ...
galima naudoti if ch in [‘a‘..‘d‘,‘z‘] then ...
Aibės bazinis tipas gali turėti daugiausia 256 reikšmes, kurios yra numeruojamos nuo 0 iki 255.
include (s,e) – į aibę s yra įtraukiamas elementas e, s = s + [e]
exclude (s,e) –elementas e yra šalinamas iš aibės s, s = s - [e]
53
8. FUNKCIJOS IR PROCEDŪROS
8.1. ĮVADAS
Didesnį uždavinį lengviau yra programuoti dalimis. Kuo savarankiškesnės dalys ir kuo mažiau ryšių yra tarp tų dalių, tuo lengviau sudaryti ir nagrinėti programą. Pageidautina, kad programoje aiškiai matytųsi dalių ribos ir būtų nurodyti jų ryšiai. Šios atskiros dalys gauna pradinius duomenis ir grąžina rezultatus.
Funkcija – programos dalis, kurianti vieną rezultatą. Funkcija turi atlikti vieną užduotį, o jos vardas turi atitikti šios užduoties esmę.
Procedūra – gali turėti 0 ir daugiau rezultatų. Programos aiškumui yra siekiama labiau naudoti funkcijas, nes tuomet viena dalis „gamina“ vieną rezultatą.
Į vieną kartą parašytą procedūrą ar funkciją galima kreiptis daug kartų ir atlikti jose aprašytus veiksmus. Tai užtikrina pakartotiną kodo naudojimą, kad pagreitina programuotojo darbo našumą.
Informacija tarp funkcijų ir procedūrų yra keičiamasi keliais būdais: a) parametrais (kintamųjų reikšmės ir vardai), b) funkcijų vardais (rezultatų reikšmės); c) globaliais vardais (konstantų, tipų, kintamųjų, funkcijų ir procedūrų vardai).
Toliau šie būdai bus nagrinėjami detaliau. 8.2. STANDARTINĖS MATEMATINĖS FUNKCIJOS
Dažniau atliekamiems veiksmams yra sukurtos standartinės funckijos.
8.2.1. PASKALYJE
8-1 lentelė Dažniau naudojamos standartinės Paskaloio funkcijos.
Funkcija Tikslas Pavyzdžiai sqrt(x) Kvadratinė šaknis iš x sqrt(900.0) yra 30.0 exp(x) ex exp(1.0) yras 2.718282 ln(x) ln x , x turi būti teigiamas ln(2.718282) yra 1.0 sqr(x) Kelia kvadratu, rezultato reikšmė sutampa su
x tipu. sqr(5) yra 25 log10(10.0) yra 1.0
abs(x) Absoliuti reikšmė, rezultato reikšmė sutampa su x tipu.
abs(-10) yra 10
trunc(x) Atmetama trupmeninė realiosios x reikšmės dalis, neapvalinant. Rezultato tipas – sveikasis.
trunc(1.2) yra 1 trunc(-1.2) yra -1 trunc(5.8) yra 5 trunc(-5.8) yra =-5
round(x) Apvalina x reikšmę iki sveikojo skaičiaus round(4.1) yra 4
54
round(-4.1) yra -4 round(4.7) yra 5 round(-4.7) yra -5
8.2.2. C
Standartinių funkcijų biblioteka vadinasi ANSI C. Jai priklauso jau žinomos funkcijos printf, scanf ir pan. Naudojant matematinės bibliotekos funkcijas reikia įtraukti šių funkcijų aprašų failą, naudojant preprocesoriaus komandą #include <math.h> Funkcija Tikslas Pavyzdžiai sqrt(x) Kvadratinė šaknis iš x sqrt(900.0) yra 30.0 exp(x) ex exp(1.0) yras 2.718282 log(x) ln x log(2.718282) yra 1.0 log10(x) lg x log10(1.0) yra 0.0
log10(10.0) yra 1.0 abs(m) Absoliuti reikšmė abs(-10) yra 10 fabs(x) Absoliuti reikšmė Jei x>0, tai fabs(x) yra x
Jei x=0, tai fabs(x) yra 0.0 Jei x<0, tai fabs(x) yra –x
ceil(x) Apvalina iki artimiausio nemažesnio sveikojo skaičiaus
ceil(9.2) yra 10.0 ceil(-9.8) yra –9.0
floor(x) Apvalina iki artimiausio nedidesnio sveikojo skaičiaus
floor(9.2) yra 9.0 floor(-9.8) yra –10.0
pow(x,y) xy pow(2,7) yra 128.0 pow(9,0.5) yra 3.0
sin(x), cos(x), tan(x)
Trigonometrinės funkcijos, x – radianuose sin(0.0) yra 0.0 Cos(0.0) yra 1.0 Tan (0.0) yra 0.0
Programos su standartinėmis matematinėmis funkcijomis yra transliuojamos, papildomai nurodant raktą –lm: gcc –o fvardas fvardas.c -lm
8.3. NAUDOTOJO PROCEDŪROS PASKALYJE
8.3.1. PROCEDŪROS APRAŠAS
Procedūra – tai logiškai susietų veiksmų grupė, grąžinanti 0 ir daugiau reikšmių. Procedūrą, kaip ir programą, sudaro antraštė, aprašų ir veiksmų skyriai: procedure <vardas> (<parametrų sąrašas>); label …; const …; type …; var ; procedure …; function ; begin <sakiniai>
55
end;
<vardas> - raidžių ir skaitmenų rinkinys. Rekomenduojama procedūros vardą pradėti didele raide, kad ji skirtųsi nuo kintamųjų vardų. Jei programos vardą sudaro keli žodžiai, tai juos galima sujungti pabraukimo simboliu (Keli_zodziai) arba kiekvieną žodį pradedant didele raide (KeliZodziai).
<parametrų sąrašas> – tai vardų sąrašas, skirtas perduoti duomenis procedūrai ir grąžinti jos rezultatus. Tai formalūs parametrai, naudojami procedūros veiksmams aprašyti. Kiekvienam parametrui aprašomas jo duomenų tipas. Parametrų vardai skiriami kabliataškiais. Parametrai gali būti grupuojami pagal tipus, kaip antai procedure Skaito (x1, x2: real; k,l:integer; c1, c2: char);
8.3.2. PAGRINDINIAI PARAMETRŲ TIPAI
Parametrai-reikšmės yra naudojami duomenims į procedūrą perduoti. Šiame apraše visi parametrai yra perduodami procedūrai reikšmėmis:
procedure Raso (x1, x2: real; k,l:integer; c1, c2: char); Parametrai–kintamieji skirti tiek duomenims perduoti į procedūrą, tiek juos grąžinti.
Pastarieji parametrai yra žymimi požymiu var. Šiame apraše parametrai x1, x2 yra parametrai-kintamieji, o parametrai k, l – parametrai-reikšmės:
procedure Raso (var x1, x2: real; k,l:integer);
Parametrai–masyvai gali būti siunčiami funkcijoms ir procedūroms parametrais–reiškmėmis ir parametrais–kintamaisiais. Šiuo atveju masyvų rėžiai turi būti pastovūs (konstantos), o masyvų tipai turi būti aprašyti bloke, gaubiančiame procedūrą ar funkciją bei kreipinius į ją. Tai dažnai yra nelabai patogu. Norint lansčiau operuoti masyvų rėžiais, galima naudoti tiktai masyvams taikytina parametrų persiuntimo būdą – parametrais–masyvais. var <vardų sąrašas> : array [(rėžio vardas>..<rėžio vardas>:<diskrečiojo tipo vardas>] of <tipo vardas>;
Pavyzdžiai: var rn : array [m..n:integer] of real; kn : array [ma..na : integer] of spalva;
Klaidingi aprašai: n : array [1..15: integer] of real; klaida: rėžiai turi būti vardai. N : array [a..b:1..100] of real; klaida: tipas taip pat turi būti nurodomas vardu.
Faktinio parametro–masyvo tipas turi būti suderintas su formaliojo parametro–masyvo tipu. type masyvas = array [1..10 ] of integer; var mazas : masyvas; didelis : array [-100..100] of integer; procedure Tvarka (var m:array[x..y : integer] of integer);
Kreipiniai į šią procedūrą galėtų atrodyti taip: Tvarka (mazas); Tvarka (didelis);
56
8.3.3. KREIPINYS Į PROCEDŪRĄ
Kreipiniai į procedūrą yra pradedami procedūros vardu ir skliaustuose, nurodomi faktiniai parametrai, kitaip vadinami argumentais: <vardas> (<argumentai>);
<argumentai> – perduodamų duomenų ir gaunamų rezultatų sąrašas. Kiekvienas argumento eilės tvarka turi atitikti formalių parametrų eilės tvarką, tai yra argumentai (faktiniai parametrai) turi atitikti formaliuosius parametrus.
8.3-1 pavyzdys. Procedūra, randanti didesnę ir mažesnę reikšmės. procedure Max_min (a,b: real; {parametrai-reikšmės} var max, min: real); {parametrai-kintamieji} begin if a < b then begin max := a; min := b; end else begin max := b; min := a; end end;
Tuomet kreipinys į šią procedūrą atrodo taip:
var a,b,didz,maz: real; I,j,k,l: integer; begin a:=10; b:=20; i:=15; j:=25; Max_min(a,b, didz, maz); Max_min(i,j,k,l); {klaida!!!}
Pastarasis sakinys yra klaidingas, nes nesuderinti parametrų tipai. Parametrų tipai yra derinami panašiai, kaip ir priskirimo sakinyje: „gavėjo“ tipas turi apimti „siuntėjo“ tipą.
8.4. NAUDOTOJO FUNKCIJOS
8.4.1. PASKALYJE
Funkcija yra atskiras procedūrų atvejis, nes ji grąžina vieną reikšmę. Funkciją, kaip ir programą bei procedūrą, sudaro antraštė, aprašų ir veksmų skyriai: function <vardas> (<parametrų sąrašas>):<grąžinamos reikšmės tipas> label …; Const …; type …; var ; procedure …; function ; begin
57
<sakiniai>; <vardas>:=…; end;
Funkcijos grąžinama reikšmė yra priskiriama funkcijos vardui. Tuo funkcijos blokas skiriasi nuo procedūros bloko, pavyzdžiui: function Sudeti(a,b:integer):integer; begin Sudeti := a + b end;
Kreipinys į funkciją yra rašomas išraiškoje, pavyzdžiui, Suma := Sudeti(5,10)+Sudeti(k,l);
Funkcijos rezultatas ne įsimenamas, o tiesiog panaudojamas kreipinio vietoje.
8.4.2. C
Programa dalinama į funkcijas. C kalboje funkcijos negali būti įdėtos viena į kitą. Kiekviena funkcija turi atlikti vieną užduotį, o jos vardas turi atitikti šios užduoties esmę. Jei sunku parinkti vardą, vadinasi funkcijoje yra per daug veiksmų. Juos reikia dar suskaidyti į paprastesnius.
C programą sudaro funkcijos, kurių viena privalo būti main(). Paprastai pagrindinė funkcija yra pirma, joje yra kviečiamos kitos funkcijos. Kiekvienas vardas turi būti aprašytas, taigi, ir funkcijos vardas taip pat. Aprašant funkciją, prieš funkcijos vardą yra nurodomas grąžinamos reikšmės tipas. Jei funkcija nieko negrąžina, tai nurodomas tipas void. Skliaustuose už funkcijos vardo nurodomi parametrų tipai ir vardai. Jei nieko neperduodama, rašoma void.
Po preprocesoriaus komandų yra talpinami tipų ir finkcijų aprašai (prototipai, pirmavaizdžiai). Prototipą (pirmavaizdį) sudaro <grąžinamos reikšmės tipas> <funkcijos vardas> (<parametrų tipai>);
pavyzdžiui, int maximum (int, int, int); Šis užrašas reiškia, kad į funkciją maximum ateina tris sveiki skaičiai, o funkcija
grąžina taip sveikąją reikšmę. Parametrų vardai prototipe nereikalingi.
8.4-1 pavyzdys. Programos su funkcija pavyzdys. #include <stdio.h> int main() { extern int square(int a); /* prototipas */ int x; for (x=1; x<=10; x++) printf("%d ", square(x)); printf("\n"); return 0; } int square (int y) {
58
return y*y; }
Šios programėlės išvestis: 1 4 9 16 25 36 49 64 81 100
8.5. MASYVŲ PERDAVIMAS FUNKCIJOMS AR PROCEDŪROMS
Paprasčiausias būdas perduoti masyvą kaip parametrą yra jo vardo ir apimties nurodymas. Masyvo reikšmės yra generuojami atsitiktiniai skaičiai. pavyzdžiai 8.5-1 pavyzdys ir 8.5-2 pavyzdysiliustruoja masyvo perdavimą funkcijai pasklaio ir C kalbose.
8.5-1 pavyzdys Funkcijoje ieškamas masyvo mažiausios reikšmė
program masyvo_minimumas; const ILG = 15; type rinkinys = array [1 .. ILG] of integer; function minimumas ( list : rinkinys; size : integer ) : integer; var min, i, minindex: integer; begin minindex := 0; min := list[ minindex]; for i:= 1 to size do if list[i] < min then begin min := list[i]; minindex := i; end; minimumas := minindex end; var i:integer; mas : rinkinys; begin randomize; for i:=1 to ILG do begin mas[i] := random(ILG*10); writeln('mas[', i:2, ']=', mas[i]:6); end; i := minimumas (mas, ILG); writeln('min: mas[',i:2, ']=', mas[i]:6 ); end.
8.5-2 pavyzdys. Šioje programėlėje 8.5-1 pavyzdys perašytas c kalba. Kadangi masyvo vardas – tai jo pradžios adresas, todėl perduodamas adresu. o ne reikšme.
#include <stdio.h> /* min_func.c */ #include <stdlib.h> #include <time.h> #define ILG 15 extern int Minimumas(int mas[], int apimtis);
59
int main() { int i, mas[ILG]; for (i=0; i<ILG; i++) { mas[i]=rand()%(ILG*10); printf("mas[%2d]=%6d\n", i,mas[i]); } i=Minimumas(mas, ILG); printf("min: mas[%2d]=%6d\n",i,mas[i]); return 0; } int Minimumas(int list[], int size) { int i,min, minindex=0; min=list[minindex]; for (i=1; i<size; i++) if (list[i]<min) { min=list[i]; minindex=i; } return minindex; }
Šios programos rezultatas: mas[ 0]= 90 mas[ 1]= 75 mas[ 2]= 34 mas[ 3]= 31 mas[ 4]= 124 mas[ 5]= 99 mas[ 6]= 2 mas[ 7]= 135 mas[ 8]= 86 mas[ 9]= 97 mas[10]= 8 mas[11]= 71 mas[12]= 16 mas[13]= 101 mas[14]= 38 min: mas[ 6]= 2
8.6. ATMINTIES KLASĖS
Bet koks kintamasis galioja tame bloke, kuriame yra aprašytas.
8.6.1. VARDŲ GALIOJIMO SRTITYS PASKALYJE
Paskalio programos struktūra yra blokinė. Į programos bloką gali įeiti funkcijų ir procedūrų blokai. Šių sudėtyje gali būti naujų, smulkesnių, funkcijų ir procedūrų blokai. Atsiranda blokų hierarchija. Programos blokas laikomas pirmojo lygio bloku, į jį įeinantys blokai – antrojo lygio.
60
Kiekviename bloke galima aprašinėti vardus, kurie galioja šio bloko viduje ir negalioja jo išorėje. Jei vardas yra aprašytas dar kartą žemesniame bloke, tai pastarajame bloke galioja paskutinis aprašas. Kai programos vykdymas yra grąžinamas į aukštesnį bloką, tuomet vėl galioja ankstesnis aprašas.
8.6-1 pavyzdys. Vardų galiojimo sritis iliustruojanti programėlė. program vardai; var a,b,c,d: integer; procedure r(a: integer; var e:integer); var b: integer; begin b:=3; c:=4; writeln('Procedura. a=',a,' b=', b,' c=',c,' d=',d, ' e=', e); e:=6; end; begin a:=22; b:=33; c:=44; d:=55; writeln('Programa pries proc. a=',a,' b=', b,' c=',c, ' d=',d ); r(b,d); writeln('Programa po proc. a=',a,' b=', b,' c=',c,' d=', d ); end.
Šios programos rezultatas yra :
Programa pries proc. a=22 b=33 c=44 d=55 Procedura. a=33 b=3 c=4 d=55 e=55 Programa po proc. a=22 b=33 c=4 d=6
8.6.2. C
Kiekvienas kintamasis ir funkcija C kalboje priklauso kokiai nors atminties klasei. Kintamojo atminties klasė nusako jo egzistavimo laiką ir matomumo sritį. Kintamojo atminties klasė nustatoma, atsižvelgiant į jo buvimo vietą arba raktinį žodį. Šis žodis yra dedamas prieš aprašą. Funkcijos klasė visada yra external, jei prieš funkcijos aprašymą nenurodytas žodis static. C kalboje yra galimos keturios atminties klasės: automatic, register, extern ir static.
8.6.2.1. Vietiniai kintamieji
Bet koks kintamasis, aprašytas funkcijoje ar bloke ir neturintis išreikšto atminties klasės nurodymo, laikomas vietiniu. Tokį kintamąjį galima aprašyti nurodant auto. Tačiau toks aprašymas yra retai taikomas. Vietinis kintamasis galioja nuo aprašo taško iki bloko pabaigos, kuriame jis yra aprašytas. Naudotis tokiu kintamuoju kitame bloke negalima. Šie kintamieji pavadinti „automatic“ todėl, kad atmintis jiems yra skiriama, kai įeinama į bloką, kuriame jis aprašytas. „Išeinant iš bloko“ atmintis, skirta vietiniams kintamiesiems yra atlaisvinama.
61
#include <stdio.h> int main() { auto int i; for (i=10; i>0; i--) printf("\n %d", i); printf("\n"); {return 0; Turbo sistemoms} }
Aprašyti automatiniai kintamieji automatiškai nulio reikšmės negauna, todėl tai reikia padaryti programuotojui.
8.6.2.2. Registriniai kintamieji
Bazinį žodį register galima naudoti tik automatiniams kintamiesiems arba formaliems funkcijos parametrams. Šis žodis reiškia, kad naudotojas pageidauja patalpinti duotą kintamąjį į vieną iš greitaeigių registrų. Kompiliatorius neprivalo įvykdyti šio reikalavimo. Šį aprašymą rekomenduojama naudoti kintamajam, dažnai naudojama funkcijoje. Atlikus šį veiksmą, gautas kodas yra kompaktiškas ir greičiau vykdomas.
Registrinių kintamųjų apribojimas – negalima kreiptis į jo adresą. Be to į registrus gali būti patalpinti tik short ir int tipo kintamieji bei artimos rodyklės.
8.6.2.3. Išoriniai kintamieji
Bet koks kintamasis, aprašytas faile prieš funkcijas ir neturintis atminties klasės apibrėžimo, yra laikomas išoriniu (dar vadinamas globaliu). Globalūs kintamieji galioja nuo aprašo vietos iki failo pabaigos. Jei bloke yra aprašytas vietinis kintamasis, kurio vardas sutampa su globaliojo kintamojo vardu, tai šiame bloke galioja vietinis kintamasis. Išėjus iš bloko, vėl galioja globalus kintamasis.
Išoriniams kintamiesiems kartą paskiriama atmintis yra saugoma iki programos vykdymo pabaigos. Globaliems kintamiesiems yra automatiškai priskiriama nulinė reikšmė. Išorinį kintamąjį galima aprašyti ir funkcijoje, kurioje jis yra naudojamas, naudojant raktinį žodį extern.
Jei programoje yra naudojami kintamieji, aprašyti kitame faile, yra būtina naudoti extern. Aprašius išorinius kintamuosius ir funkcijas viename faile, naudojant extern, juos galima naudoti ir kituose failuose.
8.6.2.4. Statiniai kintamieji
Statiniai kintamieji gali būti globalūs ir vietiniai. Vietinis statinis kintamasis yra aprašomas funkcijoje ir turi tokią pačią galiojimo sritį, kaip ir automatinis kintamasis. Jis įgyja pradinę reikšmę, pirmąkart aktyvuojant funkciją. Bet kintamasis neišnyksta. Kai turinti jį funkcija baigia darbą, statinio kintamojo reikšmė yra saugoma nuo vieno funkcijos kreipinio iki kito.
62
8.6-2 pavyzdys. Statinių paramterų veikimą iliustruojanti programėlė #include <stdio.h> int a=5; int main() { void skaic(void); int kiekis; printf("main: a=%d\n", a); for (kiekis=1; kiekis<=3; kiekis++) { printf("Iteracija %d\n", kiekis); a--; skaic(); } printf("\n"); return 0; } void skaic (void) { int fa=1; static int sta=1; printf("funkcija: fa=%d ir sta=%d a=%d\n", fa++, sta++, a++); }
Funkcija skaic() padidina kiekvieno kintamojo reikšmę atspausdinus. Perjungti
srautą galima taip: ./prog>rez.dat
Šios programos rezultatai tokie: main: a=5 Iteracija 1 fa=1 ir sta=1 a=4 Iteracija 2 fa=1 ir sta=2 a=4 Iteracija 3 fa=1 ir sta=3 a=4
Statinis kintamasis sta atsimena savo reikšmę, tuo tarpu kintamajam fa pradinė reikšmė yra suteikiama kiekvieną kartą iš naujo.
Globalūs statiniai kintamieji aprašomi failo pradžioje raktiniu žodžiu static. Šis žodis gali būti naudojamas ir funkcijoms aprašyti. Šios klasės kintamieji ir funkcijos matomi nuo aprašymo taško iki failo pabaigos. Juos galios panaudoti tik tame pačiame faile, nes iš kitų failų jie nematomi.
Susipažinus su kintamųjų klasėmis, kyla klausimas, kokius kintamuosius naudoti. Atsakymas paprastas – jei tik įmanoma, reikia naudoti vietinius (automatinius, lokalius) kintamuosius. Labai patraukliai atrodo išoriniai kintamieji. Tačiau jie pavojingi tuo, kad šių kintamųjų reikšmė gali būti pakeista bet kurioje funkcijoje. Funkcijos turi būti kiek galima labiau savarankiškesnės. Prieš naudojant kokią nors kitą kintamųjų klasę, reikia įsitikinti, ar tikrai ji yra būtina.
63
8.7. C PARAMETRAI-KINTAMIEJI
8.7.1. KINTAMŲJŲ PERDAVIMAS PARAMETRAIS-KINTAMAISIAIS
Funkcija grąžina vieną reikšmę. Tais atvejais, kai būtina grąžinti kelias reikšmes, parametrus galima perduoti ir parametrais-kintamaisiais.
8.7-1 pavyzdys. Sveikas skaičius perduodamas parametru-reikšme
#include <stdio.h> int kubas_par_reiksme( int ); int main() { int skaicius = 5; printf( "\n Pradine reiksme yra %d " , skaicius ); skaicius = kubas_par_reiksme ( skaicius ); printf( "\n Po funkcijos reiksme yra %d \n", skaicius); return 0; } int kubas_par_reiksme(int n) { return n * n * n; }
8.7-2 pavyzdys. Skaičius perduodamas parametru-kintamuoju
#include <stdio.h> void kubas_par_kint( int *); int main() { int skaicius = 5; printf("\n Pradine reiksme yra %d ", skaicius); kubas_par_kint ( &skaicius); printf("\n Po funkcijos reiksme yra %d \n", skaicius ); return 0; } void kubas_par_kint (int *n) { *n=*n * *n * *n; }
Abiem atvejais rezultatas yra toks pat.: Pradine reiksme yra 5 Po funkcijos reiksme yra 125
64
8.7.2. MASYVŲ PERDAVIMAS FUNKCIJOMS IR PROCEDŪROMS
Perduodant masyvą fiunkcijai, parametrų sąraše tiesiog rašome jo vardą. Masyvo vardas – tai pirmo jo elemento adresas. Šios funkcijos prototipo parametrų sąraše nurodome, kad bus perduodamas masyvas. masyvaS
8.7-3 pavyzdys. Masyvo perdavimas
#include <stdio.h> #define DYDIS 5 void KeistiMasyva (int[], int); int main() { int a[DYDIS] = { 0, 1, 2, 3, 4}, i; printf( "\n Masyvo perdavimas parametru-kintamuoju\n", " Pradinis masyvas yra:\n" ); for ( i = 0; i < DYDIS; i++ ) printf("%3d", a[i]); printf("\n"); KeistiMasyva( a, DYDIS); printf("\n Pakeistas masyvas:\n"); for ( i = 0; i < DYDIS; i++ ) printf("%3d", a[i] ); printf( "\n" ); return 0; } void KeistiMasyva (int b[], int size) { int j; for ( j = 0; j <= size - 1; j++ ) b[j] *= 2; } Šios programos rezultatas yra Masyvo perdavimas parametru-kintamuoju 0 1 2 3 4 Pakeistas masyvas: 0 2 4 6 8
8.8. PAVYZDŽIAI
8.8-1 pavyzdys Paskaičiuoti atstumą tarp dviejų dvimatės plokštumos taškų.
program atstumo_skaiciavimas; type taskas = record x,y:real end;
65
var v1, v2: taskas; ats : real; function atstumas( c1, c2 : taskas) : real; begin atstumas := sqrt (sqr(c2.x-c1.x)+sqr(c2.y-c1.y)) end; begin write( 'Iveskite pirmo tasko x ir y kordinates:' ); readln( v1.x , v1.y ); write( 'Iveskite antro tasko x ir y kordinates:' ); readln( v2.x , v2.y ); ats := atstumas( v1, v2 ); writeln( 'Atstumas yra ', ats:7:2 ) end.
8.8-2 pavyzdys. Ta pati programėlė perrašyta C kalba.
#include <stdio.h> #include <math.h> #define TASKAS struct taskas TASKAS { float x,y; }; double atstumas (TASKAS t1, TASKAS t2); int main() { TASKAS v1,v2; double ats; printf("Iveskite pirmo tasko koordinates:"); scanf("%f %f", &v1.x, &v1.y); printf("Iveskite antro tasko koordinates:"); scanf("%f %f", &v2.x, &v2.y); ats= atstumas(v1, v2); printf("Atstumas yra %.2f \n", ats); return 0; } double atstumas (TASKAS c1, TASKAS c2) { double atstum; atstum = sqrt(pow(c2.x-c1.x,2)+pow(c2.y-c1.y,2)); return atstum; }
66
9 . FAILAI
9.1. PASKALIO FAILAI
Pascal kalboje failai gali būti: • netipizuoti, • tipizuoti, • tekstiniai.
9.1.1. TEKSTINIAI FAILAI
Tekstiniame faile yra simboliai ir specialūs simboliai, būtent eilutės pabaigos simbolis ir failo pabaigos simbolis. Jis yra kuriamas, naudojant paprastus teksto redaktorius.
9.1.1.1. Aprašas
Pascal kalboje apibrėžtas tipas text ir du šio tipo kintamieji input ir output. var n : integer; var input, output : text;
Begin Assign(input,'');
reset(input); assign(output,''); reset(output);
readln(n); readln(input,n); writeln(n) writeln(output,n) end. Tekstinio tipo failo kintamojo apibrėžimas:
var vardas : text;
9.1.1.2. Susiejimas su išoriniu failu
procedure Assign (var f; s : string); kur f - failo tipo kintamasis, string - išorinio (operacinės sistemos) failo specifikacija.
Jei failas yra einamajame kataloge, tuomet galime susieti failo kintamąjį su konkrečiu failo vardu:
Assign(f,’Duom.txt’); Assign(f,’c:\Informatika\Duom.txt’);
67
9.1.1.3. Failo atverimas
Skaitymui procedure Reset (var f); čia f - failo tipo kintamasis. Atitinkamas išorinis failas turi egzistuoti. Failo rodyklė yra
perkeliama į failo pradžią.
Rašymui procedure Rewrite (var f);
kur f - failo tipo kintamasis. Failas yra išvalomas. papildymui
procedure Append (var f : text); Atitinkamas išorinis failas turi egzistuoti.
9.1.1.4. Skaitymas
procedure Read ( [ var f : text; ] V1 [, V2,...,Vn ] ); procedure Readln [ ( [ var f : text; ] V1 [, V2,...,Vn ] ) ];
kur Vi - paprasto arba simbolių eilutės tipo kintamasis. Jei pirmas parametras (f) nenurodytas, skaitoma iš failo input. Kiti parametrai gali būti tiek sveikojo ir realaus tipo skaiciai, tiek simboliai. Pavyzdys. Readln(f); praleidžiamas eilinės eilutės tekstas iki eilutės pabaigos ir perkeliamas ties pirmuoju kitos eilutės pirmuoju simboliu: Reset(f); A B C E F Readln(f); A B C E F Var s1:string[3]; Surinkus klaviatūroje ABCDE 1234567890 S2:string[5]; s1 taps ‘ABC’ ‘123’ Begin s2 taps ‘DE’ ‘45678’ ...
Read (f,s1); Read (f,s2); end
Skaitant read sakiniu string eilutę eilutės pabaigos simbolis nėra nuskaitomas. Jei nuskaitomi skaičiai, šis simbolis yra praleidžiamas. Todėl norint perskaityti kelių string tipo kintamuoju reikšmes geriau jas pateikti atskirose eilutėse ir skaityti, naudojant readln.
Jei įvedame simbolių eilutę, paprastai naudojame readln(). Tuomet eilutės įvestis yra baigiama ENTER klavišo paspaudimu.
Eilutės pabaiga Windows OS yra vaizduojama dviem ASCII simboliais, būtent #10 – naujos eilutės simbolis, #13 kursoriaus gražinimas į pradžią. Šie simboliai yra įstatomi
68
dokumente, kai naudotojas spaudžia ENTER klavišą. Failo pabaigos simbolis #26 yra įstatomas, kai naudotojas spaudžia klavišų kombinaciją CTRL+Z. Var i:integer; Įvedant 1.35 5 r:real; Begin Read (f,r); r yra 1.35 Read (f,i); I yra 5 end
9.1.1.5. Rašymas
procedure Write ( [ var f : text; ] V1 [, V2,...,Vn ] ); procedure Writeln [ ( [ var f : text; ] V1 [, V2,...,Vn ] ) ];
kur Vi - paprasto arba simbolių eilutės tipo išraiška. Jei pirmas parametras (f) nenurodytas, skaitoma iš failo output. Pavyzdys. Write(f,s1, s2); write(f,s1); Write(f,s2);
9.1.1.6. Uždarymas
Baigiant darbą su failais, juos būtina užverti: procedure Close (var f);
9.1.1.7. Klaidų kontrolė
Standartinškai transliuojant, yra įjungtas režimui "I/O checking" (pseudokomentaras {$I+}). Įvykus klaidai, šiame režime programos darbas nutraukiamas.
Jei naudotojas pageidauja valdyti veiksmus, įvykus klaidai, tuomet yra išjungiamas standartinis klaidų kontroės režimas „I/O checking“ (pseudokomentaras {$I-}) ir naudotojas pats valdo programos veiksmus.
Dirbant su failais, tikrinama paskutinės įvedimo-išvedimo operacijos sėkminga baigtis: function IOResult : integer;
Šios funkcijos rezutųatai yra tiokie: 0 - reiškia, operacija sėkminga, kiti rezultatai reiškia klaidas. Pastaba: kreipinys į funkciją numeta požymio reikšmę, todėl rezultatas turi būti tikrinamas iš karto po operacijos su failu.
9.1.1.8. Naudingos funkcijos, darbui su failais
function SeekEof [ (var F: Text) ]: Boolean;
Ši funkcija nustato failo pabaigos požymį. Ji naudojama tik su tekstiniais failais. Failas turi būti atvertas. function SeekEoln [ (var F: Text) ]: Boolean;
69
Grąžina eilutės pabaigos požymį. Ji naudojama tik su tekstiniais failais. Failas turi būti atvertas.
9.1.2. PROGRAMŲ, APDOROJANČIŲ TEKSTINIUS FAILUS, PAVYZDŽIAI
9.1-1 pavyzdys Įvesti iš failo simbolių eilutės ir įrašyti jas į kitą. Įvedimo ir išvedimo failų vardai yra įvedami iš klaviatūros. Programoje vykdoma klaidų kontrolė.
program failai; var inf, outf : text; duom, rez: string[12]; str:string; kiek : integer; begin kiek :=0; {$I-} repeat Writeln(' Iveskite duomenu failo varda: '); Readln(duom); Assign(inf, duom); Reset(inf); Inc(kiek); if kiek=3 then halt; until IOResult=0; kiek :=0; Writeln(' Iveskite rezultato failo varda: '); Readln(rez); Assign(outf, rez); Rewrite(outf); if IOResult<>0
then writeln('Negalima atverti faila:', rez) else begin {$I+} while not SeekEof(inf) do begin readln(inf, str); writeln(outf, str); end; close(outf) end; close(inf); end.
Įvesties failo ir sukurto rezultato failo turiniai yra identikši: aas bb bb bb asd ccc cc cc cccs sdfsdfsd sdfsd sdfsdf eee ffgfg dffdf gg dfdf fff dfdfd dfdfddddd
70
9.2. C FAILAI
C kalboje duomenų įvesčiai ir išvesčiai naudojami trys standartiniai failai: stdin – įvesties failas, skaitymui iš klaviatūros, stdout – išvesties failas, rašymui į monitorių, stderr – klaidos failas.
Į failą rodo nuoroda į struktūrą FILE: FILE *f;
C kalboje nėra užduota konkreti failo struktūra. Tai yra programuotojo rūpestis. C kalboje dirbti su failais galime nuoseklios ir tiesioginės kreipties režimu.
C kalboje duomenų įvedimui yra naudojama funkcija scanf(). Simbolio įvesčiai iš input galima naudoti specializuotą funkciją getchar().
Funkcijos scanf() argumentai – įvesties formatas ir kintamųjų adresai. Naudojant šią funkciją reikia atsiminti šias taisykles:
1. Jeigu įvedama vieno iš pagrindinių tipų reikšmės, tai prieš kintamojo vardą reikia rašyti ampersendo simbolį &.
2. Jeigu įvedama simbolių eilutės tipo reikšmė, simbolio & naudoti nereikia.
Įvedami duomenys vienas nuo kito skiriami tarpais. Tarpų kiekis neribotas. Norint duomenis skirti kableliais, valdančiojoje eilutėje tarp formatų specifikacijų reikia padėti kablelius
9.2.1. ATVERTI FAILĄ
Funkcija fopen atveria failą tam tikru režimu: f=fopen(“duom.dat”, režimas);
Režimai: “r” – skaitymui, failas turi egzistuoti “w” – rašymui, jei failas egzistuoja, tuomet jo turinys \yra išvalomas “a” – papildymui prie failo pabaigos.
Jei reikia skaityti ir rašyti, tuomet galimi tokie režimai: “r+” – skaitymui ir rašymui, “w+” – skaitymui ir rašymui, jei failas egzistuoja, tuoemt atvėriant jis yra išvalomas “a+” – skaitymui ir rašymui, o įrašai yra daromi failo pabaigoje.
Jei atveriant failą įvyksta klaida, fopen grąžina NULL.
9.2.2. NUOSEKLIOS KREIPTIES FAILO SKAITYMAS
fscanf (failo_nuoroda, formatas, įvedamų_kintamųjų_adresai);
9.2.3. ATSUKTI FAILO RODYKLĘ Į PRADŽIĄ
Nuosekliame faile skaitome duomenis nuo pradžios iki pabaigos. C kalboje yra galimybė “atsukti”
71
rewind ( failo_nuoroda );
9.2.4. RAŠYMAS Į NUOSEKLIOS KREIPTIES FAILĄ
fprintf(failo_nuoroda, formatas, išvedamų_kintamųjų_sąrašas);
pvz. Išvesti į failą sveiką skaičių fprintf(f, “%d”, number);
9.2.5. UŽVERTI FAILĄ
fclose( failo_nuoroda);
9.2-1 pavyzdys. Nuoseklios kreipties failo apdorojimas, remiantis C kalba.
#include <stdio.h> int main() { int account; char name[20], duom[12], rez[12]; double balance; FILE *f, *r; puts( "Iveskite ivesties failo varda:" ); scanf( "%s", duom); if ( ( f = fopen ( duom,"r" ) ) == NULL ) printf( "Negalime atverti failo \"%s\"\n ", duom ); else { puts( "Iveskite isvesties failo varda:" ); scanf( "%s", rez ); if ( ( r = fopen(rez,"w") ) == NULL ) printf ( "Negalime atverti failo \"%s\"\n ", rez ); else { fprintf( r,"%-13s%-13s%s \n", "Saskaitos nr", "Vardas", "Likutis"); fscanf ( f, "%d%s%lf", &account, name, &balance); while ( !feof( f ) ) { fprintf( r, "%-13d%-13s%7.2f\n", account, name, balance ); fscanf( f, "%d%s%lf", &account, name, &balance ); } fclose( f ); fclose( r ); } } return 0; }
Tarkime, duomenų faile turime šiuos duomenis: 45 Jonas 4545.2 215 Petras 2541.25
72
52 Ona 1114.5 541 Jurate 2525
Tuomet rezultato faile išvestins yra : Saskaitos nr Vardas Likutis 45 Jonas 4545.20 215 Petras 2541.25 52 Ona 1114.50 541 Jurate 2525.00
9.2-2 pavyzdys Nuoseklios kreipties failo apdorojimas (Paskaliu).
program failai; var f, r:text; duom, rez: string[15]; c:char; name: string[10]; account : integer; balance : real; begin write('Iveskite ivesties failo varda: '); readln(duom); Assign(f, duom); {$I-} Reset(f); {$I+} if Ioresult<> 0 then writeln('Negalime atverti failo: ', duom) else begin write('Iveskite isvesties failo varda: '); readln(rez); Assign(r,rez); {$I-} Rewrite(r); {$I+} if Ioresult<> 0 then writeln('Negalime atverti failo: ', rez) else begin writeln(r,'Saskaitos nr Vardas Likutis'); while not Eof(f) do if not eoln(f) then begin read(f,account); read(f,c); name:=''; while c=' ' do read(f,c); while (c<>' ') and not Eoln(f) do begin name:=name+c; read(f,c); end; readln(f,balance); writeln(r,account:12, name:12, balance:13:2);
73
end else readln(f) end; close(f); close(r) end end.
Įvesties failas yra tas pats, kaip ir aukščiau pateiktame pavyzdyje (9.1-1 pavyzdys), o rezultatai yra:
Saskaitos nr Vardas Likutis 45 Jonas 4545.20 215 Petras 2541.25 52 Ona 1114.50 541 sdfsdfsdf 2525.10
9.3. TIPIZUOTI FAILAI PASKALYJE
Tipizuoto tipo failo kintamojo apibrėžimas: var vardas : file of <tipas>;
čia <tipas> yra bet koks tipas, išskyrus failą Susiejimas su išoriniu failu: procedure Assign (var f; string);
(kaip ir text atveju) Atverti failą tik skaitymui:
((var) FileMode := 0 procedure Reset (var f);
čia f - failo tipo kintamasis. Atitinkamas išorinis failas turi egzistuoti.
Atverti failą rašymui (failas turi egzistuoti): (var) FileMode := 1; procedure Reset (var f);
arba procedure Rewrite (var f);
kur f - failo tipo kintamasis. Atverti failą skaitymui / rašymui
(var) FileMode := 2; (nutylima reikšmė) procedure Reset (var f);
FileMode gali turėti ir daugiau reikšmių, priklausomai nuo OS.
Skaityti if failo: procedure Read ( var f ; V1 [, V2,...,Vn ] );
74
kur Vi - failo komponento tipo kintamasis. Rašyti į failą:
procedure Write ( var f ; V1 [, V2,...,Vn ] );
kur Vi - failo komponento tipo kintamasis. Užverti failą:
procedure Close (var f);
Paskutinės įvesties ar išvesties operacijos klaidos kodas: function IOResult : integer;
Nustatyti einamąją failo rodyklės poziciją: function FilePos(var F): Longint;
failo pradžioje grąžinamas 0, gale tą patį kaip FileSize(F). Nukreipti failpo rodyklę į tam tikrą vietą: procedure Seek(var F; N: Longint);
Atsistojama į failo N-tąją komponentę (numeruojama nuo 0). Kad atsistoti į failo galą: Seek(F, FileSize(F))
Failo dydžio nustatymas function FileSize(var F): Longint;
Grąžina failo komponentų skaičių (0 tuščiam failui)
9.3-1 pavyzdys. Sukurti tipizuotą failą, įrašyti į jį tam tikrus komponentus ir atspausdinti įrašytus duomenis ekrane.
program saskaita; program saskaita; type klientoduom= record sasknr:integer; pavarde,vardas:string[13]; likutis : real end; klientu_failas=file of klientoduom; failo_vardas=string[12]; procedure Tuscias(var g:klientu_failas); var i:integer; kl:klientoduom; begin for i:=1 to 10 do begin with kl do begin sasknr :=i; pavarde:=''; vardas :=''; likutis:=0.0; end; write(g, kl);
75
end end; procedure Pildyti(var g:klientu_failas); var i:integer; kl:klientoduom; begin write('Iveskite saskaitos numeri, iki 10: '); readln(i); while i<>0 do begin writeln('Iveskite pavarde, varda, likuti:'); kl.sasknr:=i; readln(kl.pavarde); readln(kl.vardas); readln( kl.likutis); seek(g,i-1); write(g, kl); write('Iveskite saskaitos nr: (pabaiga-0) '); readln(i); end; end; var f:klientu_failas; i:integer; klientas:klientoduom; rf:failo_vardas; begin write('Iveskite saskaitu failo varda: '); readln(rf); Assign(f,rf); {$I-} Rewrite(f); if IOResult>0 then writeln('Negalime atverti failo "', rf, '"') else begin {$I+} Tuscias(f); Pildyti(f); Close(f); Reset(f); for i:=1 to 10 do begin seek(f,i-1); read(f, klientas); writeln('klientas:', klientas.sasknr:3, ' ', klientas.pavarde:13, ' ', klientas.vardas:13, ' ', klientas.likutis:7:2); end; Close(f); end; end.
76
9.4. NETIPIZUOTI FAILAI PASKALYJE
Netipizuoto tipo failo kintamojo apibrėžimas: var vardas : file;
Susiejimas su išoriniu failu: procedure Assign (var f; string);
Atverti netipizuotą failą galim apanašiai, kaip ir tipizuotą, tik prisideda dar vienas
parametras Recsize (pagal nutylėjimą 128) procedure Reset(var F [: File; Recsize: Word ] ); procedure Rewrite(var F: File [; Recsize: Word ] );
Skaityti iš netipizuoto failo: procedure BlockRead(var F: File; var Buf; Count: Word [; var Result: Word]);
Rašyti į failą:
procedure BlockWrite(var f: File; var Buf; Count: Word [; var Result: Word]);
9.4-1pavyzdys Nuskaityti bet kurios struktūros failą ir šiuos duomenis įrašyti į kitą failą (tai yra nukopijuoti bet kurios struktūros failą).
program kopijavimas; var senasf, naujasf:file; senasv, naujasv: string[14]; buf:array[1..2048] of byte; faktin, faktout:word; begin write('Iveskite duomenu failo varda: '); readln(senasv); assign(senasf, senasv); {$I-} reset(senasf,1); {$I+} if IOResult<>0 then begin writeln('neteisingas vardas: ', senasv); halt; end; write('Iveskite naujojo failo varda: '); readln(naujasv); assign(naujasf, naujasv); {$I-} rewrite(naujasf,1); {$I+} if IOResult<>0 then begin writeln('negalima atverti: ', naujasv);
77
halt; end; repeat blockread(senasf, buf, sizeof(buf), faktin); blockwrite(naujasf, buf, faktin, faktout); until (faktin=0) or (faktout<>faktin); close(senasf); close(naujasf); end.
9.5. C LAISVOSIOS KREIPTIES FAILŲ SKAITYMAS IR RAŠYMAS
Laisvosios kreipties failų duomenis skaito funkcija fread , pavyzdžiui fread(&klientas, sizeof(klientoduom), 1, f);
Funkcija fwrite 5ra6o tam tikrą blokų skaičių į tą failo vietą, į kurią rodo failo nuoroda fwrite(&klientas, sizeof(klientoduom), 1, f); /* iš pavyzdžio */ int i; fwrite(&number, sizeof(int), 1, f);
Funkcija fseek perkelia failo nuorodą per tiek blokų, kiek nurodo išraiška int fseek(FILE *file, long int per_kiek, int nuo_kurios_vietos);
Funkcijos pavyzdys: Fseek (f, kiek*sizeof(klientoduom), SEEK_SET);
Parametras nuo_kurios_vietos yra apibrėžiamas taip: SEEK_SET – nuo pradžios SEEK_CUR – nuo einamosios pozicijos SEEK_END – nuo faiko pabaigos
9.5-1 pavyzdys. Darbas su laisvosios kreipties failu. 9.3-1 pavyzdys yra šios programos, analogija Paskalio kalba.
#include <stdio.h> /* sask_fun.c */ #include <stdlib.h> #define KLIENTO_DUOM struct klientoduom struct klientoduom { int sasknr; char pavarde[13]; char vardas[13]; float likutis; }; void Pildyti(FILE *);
78
void Tuscias (FILE *); int main() { int i; KLIENTO_DUOM klientas; FILE *f; if ((f=fopen("sask.dat", "w"))==NULL) printf("Failas sask.dat negali buti atvertas\n"); else { Tuscias(f); fclose(f); if ( (f=fopen("sask.dat", "r+"))==NULL) printf("Failas sask.dat negali buti atvertas\n"); else { Pildyti(f); rewind(f); while ( !feof(f) ) { fread(&klientas, sizeof(KLIENTO_DUOM),1,f);
/* if (klientas.sasknr != 0) */ printf("%-8d%-13s%-13s%7.2f\n", klientas.sasknr, klientas.pavarde, klientas.vardas, klientas.likutis); } fclose(f); } } return 0; } void Tuscias(FILE *g) { int i; KLIENTO_DUOM kl={0,"", "", 0.0}; for (i=1; i<=10; i++) fwrite(&kl, sizeof(KLIENTO_DUOM), 1, g); } void Pildyti( FILE *g) { int i; KLIENTO_DUOM kl; /* duomenu ivedimas */ puts("Iveskite saskaitos numeri (nuo 1 iki 10)"); scanf("%d",&kl.sasknr ); while(kl.sasknr != 0) { printf("Iveskite pavarde, varda ir likutis\n"); fscanf(stdin, "%s%s%f", kl.pavarde, kl.vardas, &kl.likutis); fseek(g, (kl.sasknr-1)*sizeof(KLIENTO_DUOM), SEEK_SET); fwrite(&kl, sizeof(KLIENTO_DUOM),1,g);
79
puts("Iveskite saskaitos nr:"); scanf("%d", &kl.sasknr); } } }
9.6. KITI PAVYZDŽIAI
9.6-1 pavyzdys Failo atvėrimas funkcijoje arba procedūroje. #include <stdio.h> #include <stdlib.h> #include <string.h> int main() { int account; char name[20]; double balance; FILE *skait, *ras; extern FILE *atverti(char []); skait =atverti("r"); ras =atverti("w"); fprintf(ras,"%-13s%-13s%s \n", "Saskaitos nr", "Vardas", "Likutis"); fscanf (skait, "%d%s%lf", &account, name, &balance); while (!feof(skait)) { fprintf(ras,"%-13d%-13s%7.2f\n", account, name, balance); fscanf(skait,"%d%s%lf", &account, name, &balance); } fclose(skait); fclose(ras); return 0; } FILE *atverti(char rez[]) { FILE *file; char duom[12]; if (strcmp(rez,"r")==0) puts("Iveskite ivesties failo varda:"); else puts("Iveskite isvesties failo varda:"); scanf("%s", duom); if ((file=fopen(duom,rez))==NULL ) { printf("Negalime atverti failo \"%s\"\n ", duom); exit(0); } return file; }
9.6-2 pavyzdys. 9.6-1 pavyzdys perrašytas Paskalio kalba.
80
program failai; var skait, ras:text; c:char; name: string[10]; account : integer; balance : real; procedure ivesti (rez:string; var f:text); var duom: string[12]; begin if rez='ivesti' then begin write('Iveskite ivesties failo varda: '); readln(duom); Assign(f, duom); {$I-} Reset(f); if Ioresult<> 0 then begin writeln('Negalime atverti failo: ', duom); exit; end; {$I+} end else begin write('Iveskite isvesties failo varda: '); readln(duom); Assign(f, duom); {$I-} Rewrite(f); if Ioresult<> 0 then begin writeln('Negalime atverti failo: ', duom); exit; end; {$I+} end; end; begin ivesti('ivesti', skait); ivesti('isvesti', ras); writeln(ras,'Saskaitos nr Vardas Likutis'); while not Eof(skait) do if not eoln(skait) then begin read(skait,account); read(skait,c); name:=''; while c=' ' do read(skait,c); while (c<>' ') and not Eoln(skait) do begin name:=name+c; read(skait,c); end; readln(skait,balance);
81
writeln(ras,account:13, name:13, balance:13:2); end else readln(skait); close(skait); close(ras) end.
82
LITERATŪRA
1. Vladas Tumasonis. Paskalis ir Turbo Paskalis 7.0. Ūkas, Vilnius, 1993.
2. Saulius Ragaišis. Informatikos įvadas: metodinė priemonė. 2001. http://www.mif.vu.lt/~ragaisis/InfIvadas/index.html
3. Jonas Blonskis, Vytautas Bukšnaitis, Jonas Smolinskas, Antanas Vidžiūnas. Programavimo praktikumas: programavimas su Turbo Paskaliu. „Smaltijos“ leidykla, Kaunas, 2000.
4. H. M. Deitel, P. J. Deitel. C: how to program. Third edition. Prentice Hall, 2001.
5. С. А. Абрамов, Г.Г. Гнездилова, Е. Н. Капустина, М. И. Селюн. Задачи по программированию. Наука, Москиа, 19887