2. DUOMENYS IR VEIKSMAI SU JAIS

Programoje užrašomi veiksmai su duomenimis. Todėl pirmiausia aprašomi duomenys, po to veiksmai su tais duomenimis. Duomenų kaita vyksta kompiuterio atmintinėje. Su šiais dalykais susidūrėme ankstesniame skyriuje. Ten nagrinėjome jau parašytų programų pavyzdžius. Dabar visa tai pateiksime išsamiau, nes tai yra pačios pagrindinės sąvokos su kuriomis programuotojas susiduria kiekviename žingsnyje. Pateiktų žinių pakaks, kad galėtume ir patys parašyti bet kokių skaičiavimų pagal formules programas.

2.1. Konstantos ir kintamieji

Programose vartojami dviejų rūšių dydžiai: pastovūs ir kintami. Kaip ir matematikoje, pastovūs dydžiai vadinami konstantomis, o kintami – kintamaisiais dydžiais arba trumpiau – kintamaisiais.

Konstantos – tai į programą įrašyti skaičiai, loginės reikšmės, tekstai (simboliai, simbolių eilutės) ir kitos reikšmės. Konstantų pavyzdžiai:

Kiekvienas duomuo apibūdinamas duomenų tipu ir reikšme. Koks yra konstantos tipas, vienareikšmiškai galima pasakyti iš jos užrašo pavidalo, išskyrus vieną atveją: vieno simbolio ilgio eilutė nesiskiria nuo simbolio.

Eilutės tipo standartinis Paskalis neturi Tačiau jis yra beveik visuose Paskalio dialektuose. Kol kas eilutes naudosime tik rašymo sakiniuose. Daugiau apie jas kalbėsime 9 skyriuje.

Kintamieji gali įgyti įvairias reikšmes. Jų reikšmės keičiamos programos vykdymo metu. Iš vienų kintamųjų reikšmių apskaičiuojamos naujos reikšmės ir jos priskiriamos tiems patiems arba kitiems kintamiesiems. Visus skaičiavimus galima įsivaizduoti kaip kintamųjų reikšmių keitimus. Todėl kartais sakoma: kad kas suprato kintamuosius, tas suprato ir programavimo esmę.

Programos tekste kintamieji žymimi vardais. Kompiliatorius kiekvienam kintamajam paskiria vietą kompiuterio atmintinėje. Tose atmintinės vietose saugomos kintamųjų reikšmės. Tai duomenys (skaičiai, loginės reikšmės, tekstai). Yra patogiau, kai tas pats kintamasis gali įgyti tik vieno to paties tipo reikšmes. Tada aišku, kiek vietos toms reikšmėms reikės kompiuterio atmintinėje ir tą vietą iš anksto galima rezervuoti. Be to, aišku kokias operacijas bus galima atlikti su tomis reikšmėmis.

Kaip minėjome kintamieji žymimi vardais. Visi vardai sudaromai pagal tas pačias taisykles (žr. 1.5 skyr.), todėl iš vardo užrašo pavidalo negalima nustatyti, kokio tipo kintamąjį žymi tas ar kitas vardas. Dėl to kintamieji aprašomi. Apraše nurodomas kintamojo tipas. Aprašų pavyzdžiai:

var plotas: real;
      a, kiekis: integer;            { viename apraše gali būti keli kintamųjų vardai,}
                                           { jie skiriami kableliais }
      raidė: char;
      žodis: string[20]             { nurodomas didžiausias eilutės ilgis}
      sakinys, frazė: string;     { kai ilgis nenurodytas, laikoma,  }
                                           {kad jis yra didžiausias leistinas – 255 simboliai }

To paties aprašo kintamųjų vardai skiriami kableliais. Visas aprašas baigiamas kabliataškiu. Tam, kad aprašas būtų vaizdesnis, kiekviena grupė pradedama nauja eilute, o visų grupių aprašų pradžios lygiuojamos.

Kitas išdėstymo būdas, kai žodis var rašomas atskiroje eilutėje, pavyzdžiui,

var
   a, kiekis: integer;
   plotas: real;

Aprašai suteikia kintamajam duomenų tipą, kurio vėliau pakeisti nebegalima – jis išlieka tas pats visą kintamojo gyvavimo laiką. Taigi kintamojo duomens tipas yra pastovus, o reikšmė – kintama.

Aprašas nesuteikia kintamajam jokios reikšmės. Sakoma, kad tik ką aprašyto kintamojo reikšmė yra neapibrėžta. Kintamiesiems reikšmės priskiriamos vėliau, kai atliekami programoje užrašyti veiksmai. Jos gali būti daug kartų pakeistos.

Konstantų aprašai. Konstantas galima pažymėti ir vardais. Vardais pažymėtas konstantas reikia aprašyti. Konstantų aprašai pradedami žodžiu const, po to išvardijamos konstantos ir jų reikšmės, pavyzdžiui,

const pi = 3.1415626536;
         n = 2;
         alg = 'Algoritmai ir programos';

Šitaip aprašytas vardas pi tampa skaičiaus 3.1415626536 sinonimu, o vardas n – skaičiaus 2 sinonimu.

Kam reikalingos vardais pažymėtos konstantos, juk kur reikia programoje galima parašyti ir tikrus skaičius ar kitokias reikšmes?

Vardais patogu pažymėti konstantas, kurios programoje panaudojamos keletą kartų. Tada patogiau rašyti trumpą ir informatyvų vardą, pavyzdžiui, pi – vietoj ilgo skaičiaus (kurį rašant nesunku suklysti), alg – vietoj ilgos frazės. Šitaip išvengiama klaidų, kurios gali atsirasti kai programoje tą patį skaičių arba tą pačią eilutę reikia rašyti daugelį kartų. Prireikus programą su vardais pažymėtomis konstantomis lengviau pataisyti, kai reikia pakeisti konstantos reikšmė, nes ją pakanka pakeisti vieną kartą – konstantos apraše.

Pavyzdys. Programa ritinio pagrindo plotui, paviršiaus plotui ir tūriui skaičiuoti

program ritinys;
  const pi = 3.1415626536;
           n = 2;                     { kiek skaitmenų po kablelio }
  var h,                              { ritinio aukštis }
        d,                              { pagrindo skersmuo }
        p,                              { pagrindo plotas }
        pavp,                         { viso paviršiaus plotas }
        v: real;                       { tūris }
begin
  read(h, d);
  p := d*d/4*pi;
  pavp := 2*p + pi*d*h;
  v := p*h;
  writeln('PLOTAS: ', p: 8: n);
  writeln('PAVIRŠIAUS PLOTAS: ', pavp: 8: n);
  writeln('TŪRIS: ', v: 8: n)
end.

Jeigu nuspręstume padidinti visų rašomų rezultatų tikslumą, pavyzdžiui, rašyti tris, keturis ar daugiau skaitmenų po kablelio, pakaktų programą pataisyti vienoje vietoje – pakeisti skaičių konstantos n apraše.

Konstantų aprašuose duomenų tipas nenurodomas, nes konstantos tipą vienareikšmiškai galima nustatyti iš jai suteikiamos reikšmės užrašo pavidalo.

Konstantos reikšmės programoje keisti negalima. Ji išlieka ta pati visą konstantos gyvavimo laiką.

Uždavinys

2.1.1. Programoje ritinys yra aprašyta konstanta n = 2. Kodėl prieskyros sakinyje

pavp := 2*p + pi*d*h
rašomas skaičius 2, o ne konstantos n vardas?

2.2. Aritmetiniai reiškiniai ir jų reikšmių priskyrimas kintamiesiems

Sveikieji ir realieji skaičiai. Matematikoje sveikieji skaičiai laikomi realiųjų skaičių aibės poaibiu. Programavime realieji ir sveikieji skaičiai priklauso skirtingoms aibėms, neturinčioms bendrų elementų. Taigi, programoje skaičius 5 skiriasi nuo skaičiaus 5.0. Skirtumai atsiranda dėl to, kad sveikieji ir realieji skaičiai skirtingai koduojami, o svarbiausia – skirtingai atliekamos ir operacijos su jais.

Aritmetinės operacijos su sveikaisiais skaičiais atliekamos tiksliai. Tačiau skaičiaus dydis ribojamas ir tą ribą galima greitai pasiekti. Pats didžiausias sveikasis skaičius žymimas vardu maxint. Tai standartinė konstanta. Jeigu rezultatas viršija šį skaičių, jis prarandamas. Tokia situacija vadinama perpildymu.

Koks yra maxint, Paskalio standartas neapibrėžia. Jis priklauso nuo kompiuterio genties ir Paskalio dialekto. Turbo Paskalyje maxint = 32767, Paskalyje-E maxint = – 2147483647.

Leistini realiųjų skaičių rėžiai kompiuteryje kur kas platesni ir retai kada viršijami. Todėl retai kada tenka rūpintis, kad neįvyktų perpildymas. Tačiau aritmetinės operacijos su realiaisiais skaičiais atliekamos apytiksliai. Atsiranda paklaidos. Dėl to, pavyzdžiui, negalima garantuoti, kad visada bus tenkinama, pavyzdžiui, šitokia lygybė

a/b*b = a

Dažniausiai paklaidos būna labai mažos ir jų galima nepaisyti. Todėl su realiaisiais skaičiais mėgstama dirbti: ir perpildymo pavojus negresia, ir paklaidos nejaučiamos. Tačiau retkarčiais pasitaiko atvejų, kai paklaidos gaunamos neįtikėtinai didelės ir iškreipia rezultatą.

Sveikųjų skaičių operacijos. Su sveikaisiais skaičiais atliekamos aritmetinės operacijos

+      sudėtis,
-       atimtis,
*       daugyba,
div   dalyba (rezultatas – dalmuo),
mod dalyba (rezultatas – liekana).

Kiekvienos operacijos rezultatas taip pat sveikasis skaičius.

Painiausios yra dalybos operacijos. Jos ir žymimos neįprastai – baziniais žodžiais, o ne operacijų ženklais. Kai abu operandai teigiami skaičiai, tai dalmens ir liekanos apskaičiavimas problemų nekelia. Pavyzdžiui, aišku, kad

7 div 3 = 2;
7 mod 3 = 1;
3 div 7 = 0;
3 mod 7 = 3.

Tačiau kai bent vienas operandas neigiamas, dalmuo ir liekana nebetenka gyvenimiškos interpretacijos. Tokiu atveju susitarta, kad dalmens ženklas nustatomas taip, kaip priimta matematikoje: jei abiejų operandų ženklai vienodi – dalmuo teigiamas, jei skirtingi – neigiamas. Na, o dalmens d ir liekanos h dydžiai, kai dalijamasis yra a, o daliklis b randami tokie, kad būtų tenkinamos sąlygos:

a = b×d + h
h <  | b |

Taigi,

-7 div 3 = -2
-7 mod 3 = -1
-7 div -3 = 2

Kai daliklis neigiamas, Paskalis liekanos neapibrėžia – perdaug negyvenimiška situacija.

Su realiaisiais skaičiais atliekamos operacijos:

+  sudėtis,
-   atimtis,
*   daugyba,
/   dalyba.

Kiekvienos operacijos rezultatas yra realusis skaičius.

Dalijama apytiksliai tol, kol trupmeninė rezultato (dalmens) dalis dar telpa į realiajam skaičiui skirtą vietą atmintyje. Todėl liekanos sąvoka realiųjų skaičių atveju netenka prasmės.

Akivaizdu, kad sveikųjų ir realiųjų skaičių dalybos operacijos yra skirtingos – jos ir žymimos skirtingai. Tačiau iš tikrųjų skirtingos ir kitos operacijos: sudėtis, atimtis ir daugyba, nors jos žymimos tais pačiais ženklais. Jeigu kam teko susidurti su kompiuterio komandų kodais, tai tas žino, kad sveikųjų skaičių operacijų kodai yra kitokie, negu joms analogiškų realiųjų skaičių operacijų kodai.

Kaip kompiuteris nustato, kurios operacijos variantą atlikti, kai programoje abiem atvejais operacija žymima tuo pačiu ženklu?

Iš operandų tipo. Jeigu operacijų +, -, * abu operandai yra sveikieji skaičiai, tai atliekama sveikųjų skaičių operacija ir rezultatas gaunamas sveikasis skaičius (koks bus rezultato tipas, reikia visada žinoti rašant programą). Jeigu abu operandai realieji skaičiai, tai atliekama realiųjų skaičių operacija ir gaunamas realiojo tipo rezultatas.

O ką daryti, kai operacijų +, – ir * operandai yra skirtingo tipo (vienas – sveikasis, kitas – realusis)? Tokiu atveju sveikasis operandas paverčiamas realiuoju skaičiumi, atliekama realiųjų skaičių operacija ir gaunamas realusis rezultatas.

Dalybos / operacija atliekama tik su realiaisiais skaičiais. Jei vienas arba net abu operandai yra sveikieji skaičiai, tai prieš atliekant operaciją jie paverčiami realiaisiais. Todėl operacijos / rezultatas visada realusis skaičius.

Pateiksime pavyzdžių, iš kurių matyti, kaip priklauso rezultato tipas nuo operandų tipų ir operacijų.

5 + 2 = 7;
5.0 + 2 = 7.0;
5 + 2.0 = 7.0;
5 - 2 = 3;
5.0 - 2 = 3.0;
5 - 2.0 = 3.0;
5 * 2 = 10;
5.0 * 2 = 10.0;
5 * 2.0 = 10.0;
5.0 * 2.0 = 10.0;
5 div 2 = 2;
5 mod 2 = 1;
10 / 2 = 5.0;
10.0 / 2 = 5.0;
10.0 / 2.0 = 5.0;
10.0 / 2.0 = 5.0.

Operacijų div ir mod operandai gali būti tik sveikieji skaičiai. Jeigu bent vienas jų realusis – gaunama klaida. Šią klaidą kompiuteris aptinka transliuodamas programą (t.y., dar nepradėjęs jos vykdyti), nes kiekvieno kintamojo ar reiškinio duomenų tipą galima nustatyti iš programos teksto nepriklausomai nuo pradinių duomenų .

Dar viena bet kokiai dalybos operacijai (div, mod ir /) būdinga klaida – dalyba iš nulio. Žinome, kad iš nulio dalyti negalima. Kai pamirštame ir tokį nelestiną veiksmą bandome pateikti kompiuteriui, jis apie tai iš karto primena, informuodamas apie klaidą. Šią klaidą kompiuteris aptinka vykdydamas programą, nes daliklio reikšmė gali priklausyti nuo pradinių duomenų, o kai programa transliuojama, jie dar nežinomi.

Iš operandų – konstantų ir kintamųjų – sudaromi aritmetiniai reiškiniai. Operacijų atlikimo tvarka nurodoma skliaustais. Kai nėra skliaustų, operacijos atliekamos pagal prioritetus:

-         (unarinė atimtis)
*    /    div    mod
+   -

Aukščiausią prioritetą turi (t.y., atliekama pirmiausiai) unarinė atimtis (skaičiaus ženklo keitimo operacija), žemesnį – daugybos ir dalybos operacijos, o žemiausią (atliekama paskiausiai) – sudėties ir atimties (binarinės) operacijos.

Aritmetinių reiškinių pavyzdžiai:

5
a
a + 5
(a + 5) * 2 div 14
-a * ((c + d) - (alfa + beta))

Atkreipiame dėmesį, kad reiškinys gali būti sudarytas tik iš vienos konstantos arba tik vieno kintamojo.

Kiekvienas reiškinys turi reikšmę. Tai paskutinės atliktos operacijos rezultatas.

Reiškinio reikšmę galima priskirti kintamajam. Tai užrašome prieskyros sakiniu. Jo pavidalas yra šitoks:

kintamojo vardas := reiškinys.

Prieskyros sakinių pavyzdžiai:

k := 5;
k := a;
k := (a + 5) * 12 div 14

Atlikus prieskyros veiksmą, kintamasis, kurio vardas parašytas kairėje simbolio := pusėje, įgyja reikšmę reiškinio, esančio dešinėje simbolio := pusėje.

Kompiuteris atlieka programoje užrašytas operacijas su kintamųjų reikšmėmis bei konstantomis. Operacijų rezultatus vėl įrašo į atmintį, t.y. priskiria kintamiesiems. Taigi kintamųjų reikšmės nuolat keičiamos: iš vienų reikšmių apskaičiuojamos kitos, kol galų gale gaunamos reikšmės, kurias galima pavadinti galutiniais rezultatais.

Reiškinio užrašas yra vaizdesnis, kai abipus žemesnį prioritetą turinčių operacijų paliekama po tarpą. Dėl to, pavyzdžiui, reiškinys

a*b + c*d
yra vaizdesnis, negu
a*b+c*d
o užrašas
a * b+c * d

yra netgi klaidinantis, nes jis skaitytoją orientuoja į kitokią operacijų atlikimo tvarką, negu iš tikrųjų ji yra.

Kadangi reikšmės priskyrimo veiksmas atliekamas paskiausiai, tai abipus prieskyros ženklo visada derėtų palikti po tarpą, ką ir darėme ankstesniuose pavyzdžiuose.

Sveikojo tipo reiškinio reikšmę galima priskirti ir sveikojo, ir realiojo tipo kintamajam. Pastaruoju atveju ji automatiškai pakeičiama realiąja.

Realiojo tipo reiškinio reikšmę galima priskirti tik realiojo tipo kintamajam. Mat jeigu tokį priskyrimą parašytume, kompiuteris nežinotų, ką daryti su realiojo skaičiaus trupmenine dalimi: ar ją atmesti ir skaičių apvalinti. Realųjį skaičių galima pakeisti sveikuoju panaudojant standartines funkcijas trunc ir round. Funkcijos trunc rezultatas yra lygus realiojo skaičiaus sveikajai daliai, o round – apvalintam realiajam skaičiui, pavyzdžiui:

trunc(5.6) = 5;
round(5.6) = 6.

Funkcija iš tikrųjų yra operacija, tik kitaip užrašyta. Pirmiausia eina funkcijos vardas, o po jo skliaustuose išvardijami operandai. Jeigu, pavyzdžiui, vietoj operacijos div programavimo kalboje būtų funkcija, pavadinta tokiu pat vardu, tai vietoj

a div b
reikėtų rašyti
div(a, b).

Kitos Paskalio standartinės aritmetinės funkcijos yra šios:

abs(x)                 apskaičiuoja | a | ,
sqr(x)                 x² ,
sin(x)                 sin x, čia x išreikštas radianais,
cos(x)                cos x, čia x išreikštas radianais,
exp(x)                e^x,
ln(x)                   ln x, x > 0,
sqrt(x)                V¨¨x, x >= 0,
arctan(x)             arctg x reikšmę radianais,
succ(x)               x = x+1,
pred(x)                x = x-1.

Tai standartinio Paskalio funkcijos. Paskalio dialektai jų turi daugiau.

Visų išvardytų funkcijų argumentas x gali būti sveikojo arba realaus tipo reiškinys. Funkcijų abs ir sqr rezultato tipas sutampa su argumento tipu. Visų kitų čia išvardytų funkcijų rezultatas yra realiojo tipo.

Programuotojas gali sudaryti naujas funkcijas. Apie tai kalbėsime 6 skyriuje.

Uždaviniai

2.2.1. Nustatykite, kurio tipo: sveikojo ar realiojo yra šių reiškinių reikšmės:

1. 12 + 6 / 4;

2. 12 + 6 / 3;

3. 12 + 6 div 4;

4. 12 + 6 div 3;

5. 12 + 6 mod 4;

6. 4 + 8.5 * 2

2.2.2. Apskaičiuokite šių reiškinių reikšmes:

1. 16 div 2 div 2 div 2;

2. 16 mod 3 mod 3.

2.2.3. Kurie reiškiniai klaidingi?

1. 10 div 2 / 2;

2. 10 / 2 div 2;

3. a div (b / 2);

4. a - - b;

5. a + + b;

6. a * * b;

7. a * - b;

8. a + 2 * b;

9. a + 2b;

10. a + b2.

2.2.4. Parašykite programą dviejų skaičių geometriniam vidurkiui rasti. Skaičių a ir b
         geometrinis vidurkis skaičiuojamas pagal formulę

g = V¯ab

2.2.5. Parašykite sakinius, kuriais realusis skaičius, reiškiantis pinigų sumą, būtų paverstas
         dviem sveikaisiais skaičiais: litais ir centais.

2.3. Duomenų skaitymas iš klaviatūros ir rašymas į ekraną

Bendru atveju pradiniai duomenys skaitomi iš bylų, kurios yra paruošiamos prieš atliekant programą, o rezultatai rašomi į bylas, kurios išlieka atlikus programą. Apie tai kalbėsime 2.5 skyrelyje.

Kitas, paprastesnis pradinių duomenų pateikimo būdas yra jų surinkimas klaviatūroje. Klaviatūra surinktų duomenų skaitymas nurodomas šitokio pavidalo sakiniu

read(k₁, k₂, ..., k_n);
arba
readln(k₁, k₂, ..., k_n).

Kintamiesiems k₁, k₂, ..., k_n priskiriamos klaviatūroje surinktos pradinių duomenų reikšmės. Jos priskiriamos kintamiesiems iš eilės: kintamajam k₁ – pirmoji reikšmė, kintamajam k₂ – antroji ir t.t. Kintamieji gali būti skirtingų tipų. Reikšmių tipai turi atitikti kintamųjų tipus pagal tokias pačias taisykles, kaip ir prieskyros sakinyje. Pavyzdžiui, sveikojo tipo kintamąjį gali atitikti tik sveikasis skaičius, o realiojo tipo kintamąjį – ir realusis, ir sveikasis skaičius. Mat abiem atvejais – skaitymo sakinyje ir prieskyros sakinyje – kintamajam priskiriama reikšmė. Tik vienu atveju apskaičiuota reiškinio reikšmė, o kitu atveju – klaviatūroje surinkta reikšmė.

Apie duomenų skaitymo sakinio formą readln (angl. read line – skaityti eilutę) kalbėsime 2.6 skyr.

Rezultatus paprasčiausia parodyti ekrane. Rezultatų rašymas į ekraną nurodomas šitokio pavidalo sakiniais:

write(r₁, r₂, ..., r_n);
writeln(r₁, r₂, ..., r_n);

Skliaustuose išvardijami reiškiniai, kurių reikšmes reikia rašyti į ekraną.

Priminsime, kad kintamasis ir konstanta čia laikomi reiškiniais (jie turi reikšmes). Iki šiol rašymo sakiniuose nurodėme tik kintamuosius arba konstantas (simbolių eilutes). Dabar, žinodami, kad čia gali būti bet kokie reiškiniai, galime programas sutrumpinti, iš jų pašalindami rezultatų kintamuosius.

Pavyzdys.

program ritinys;
  const pi = 3.1415626536;
           n = 2;                        { kiek skaitmenų po kablelio }
  var h,                                 { ritinio aukštis }
        d,                                 { pagrindo skersmuo }
        p: real;                          { pagrindo plotas }
begin
  read(h, d);
  p := d*d/4*pi;
  writeln('PLOTAS:', p: 8: n);
  writeln('PAVIRŠIAUS PLOTAS:', 2*p + pi*d*h: 8: n);
  writeln('TŪRIS:', p*h: 8: n)
end.

Palikome tik vieną rezultato kintamąjį p, nes jo reikšmė vartojama ne tik rašymo sakinyje, bet ir kitų rezultatų skaičiavimo reiškiniuose.

Rašymo sakinyje gali būti nurodytas bet koks rezultatų (reiškinių) skaičius. Nėra skirtumo, ar tuos pačius reiškinius surašysime į vieną sakinį, ar išskirstysime į kelis. Todėl sakinį

write(r₁, r₂, ..., r_n)
galima laikyti sakinių
write(r₁);
write(r₂);
...
write(r_n)
santrumpa.

Koks skirtumas tarp sakinių write ir writeln?

Sakiniu write nieko nepasakoma apie rezultatų suskirstymą į eilutes. Sakiniai write rašo rezultatus vieną po kito. Kai nebetelpa, pereinama į kitą eilutę. Perkeliama ten, kur pasiekiamas eilutės kraštas. Taigi skaičius ar tekstas gali būti skeliamas bet kurioje vietoje. Šitaip mechaniškai į eilutes suskaidytus rezultatus nepatogu skaityti. Todėl teksto skirstymą į eilutes geriau nurodyti programoje. Ten, kur reikia, kad būtų pereinama į naują eilutę, rašome sakinį

writeln

Šio sakinio veiksmas prilygtų eilutės pabaigos klavišo paspaudimui, jeigu kompiuteris rašytų rezultatus klaviatūra.

Sakinyje writeln galima nurodyti ir rezultatų. Tada kompiuteris tuos rezultatus parašys, o po to „paspaus“ eilutės pabaigos klavišą. Taigi sakinys

writeln(r₁, r₂, ..., r_n)
yra ekvivalentus sakinių porai:
write(r₁, r₂, ..., r_n);
writeln

Jeigu norima palikti n tuščių eilučių, reikia parašyti n sakinių writeln.

Rezultatų rašymą rekomenduojama užbaigti sakiniu writeln. Paskutinė neužbaigta (t.y. be eilutės pabaigos ženklo) eilutė gali dingti.

1 pavyzdys. Skaitomi du skaičiai ir išspausdinami į atskiras eilutes.

program du;
  var a: integer;
begin
  read(a);
  writeln(a);
  read(a);
  writeln(a)
end.

Programoje vartojamas tik vienas kintamasis. Kai jau atliktas antrojo sakinio veiksmas – parašyta kintamojo a reikšmė, trečiuoju sakiniu skaitoma ir jam priskiriama nauja reikšmė. Ankstesnė kintamojo a reikšmė dingsta, nes į jos vietą rašoma nauja. Ankstesnę reikšmę galima prarasti, nes ji jau išspausdinta ir daugiau programoje nevartojama. Todėl tą patį kintamąjį (o tuo pačiu – ir tą pačią vietą kompiuterio atmintinėje) galima panaudoti kito pradinio duomens reikšmei saugoti. Naujos reikšmės spausdinimą nurodo paskutinis sakinys.

2 pavyzdys. Skaitomi du skaičiai ir išspausdinami atvirkščia tvarka, negu buvo perskaityti: į pirmą eilutę antrasis skaičius, į antrą – pirmasis.

program DuAtbulai;
  var a, b: integer;
begin
  read(a, b);
  writeln(b, a: 5)
end.

Čia vieno kintamojo nebepakanka, nes pirmojo perskaityto kintamojo reikšmę reikia išsaugoti kol bus perskaityta ir parašyta antrojo kintamojo reikšmė.

Kiek vietos skirti į ekraną rašomai reikšmei, nurodoma formatu – sveikuoju skaičiumi (bendru atveju – sveikojo tipo reiškiniu), parašytu po tos reikšmės ir atskirtu dvitaškiu. Pavyzdžiui, sakinyje

write(1234: 6, -1235: 6)

parodoma, kad kiekvienam skaičiui skiriama po 6 pozicijas (6 simbolius) ekrane. Skaičiai bus išdėstyti šitaip

# # 1234 # -1235

Čia ženklu # pažymėti tarpai. Prieš pirmąjį skaičių bus palikti du tarpai, nes skaičius užima tik 4 pozicijas iš jam skirtų 6, o prieš skaičių -1235 liks tik vienas tarpas, nes skaičiui su minusu reikia 5 pozicijų.

Jeigu rezultatas yra realiojo tipo, tai jam galima užrašyti dar vieną (antrą) formatą. Jis nurodo, kiek vietų po taško skiriama skaičiaus trupmeninei daliai. Pavyzdžiui, sakinio

write(3.1415926536: 10: 5, 3.1415926536: 10: 2)

rezultatas bus

3.14159            3.14

Jeigu nenurodytas nė vienas realiojo skaičiaus formatas arba nurodytas tik vienas, tai realusis skaičius rašomas rodykliniu pavidalu. Pavyzdžiui, pagal sakinį

write(3.1415926536)

Turbo Paskalis parašytų

3.1415926536E00

Kai formatas mažesnis už rezultatui reikalingą pozicijų skaičių, tai vis tiek rašomi visi rezultato simboliai, tik nepaliekama tarpų.

Kaip rašoma, kai formatas nenurodytas, priklauso nuo Paskalio dialekto. Turbo Paskalyje rezultatui skiriama vietos tiksliai tiek, kiek jis turi simbolių. Todėl nenurodžius formatų, rezultatai (skaičiai) susilieja ir pasidaro neįskaitomi. Norint atskirti vieną rezultatą nuo kito reikia parinkti formatus, didesnius už rezultato užimamą pozicijų skaičių arba tarp rezultatų įterpti tarpo simbolius, pavyzdžiui,

write(a, '  ', b, '  ', c).

Daugumoje kitų Paskalio kalbos dialektų, kai formatas nenurodytas, skaičiui skiriama viena pozicija daugiau, negu reikėtų pačiam ilgiausiam skaičiui. Tokiu atveju nesusilieja gretimi skaičiai.

Pateiksime pavyzdžių.

3 pavyzdys. Skaitomi trys skaičiai ir rašomi į vieną eilutę atbula tvarka negu jie buvo perskaityti

program trys;
  var a, b, c: integer;
begin
  read(a, b, c);
  writeln(c, ' ', b, ' ', a)
end.

Čia jau kiekvienam skaičiui reikia atskiro kintamojo, nes pirmuosius du skaičius reikia saugoti kol bus perskaitytas ir parašytas trečiasis.

Jeigu, pavyzdžiui, kompiuteriui buvo pateikti pradiniai duomenys

31  12  1998

tai jis išspausdins

1998  12  31

4 pavyzdys. Skaitomi trys skaičiai. Rašomas pirmasis skaičius, antrasis skaičius, pakartotas du kartus, ir trečiasis skaičius, pakartotas tris kartus:

program trys;
  var a: integer;
begin
  read(a);
  writeln(a);
  read(a);
  writeln(a, '  ', a);
  read(a);
  writeln(a, '  ', a, '  ', a)
end.

Jeigu kompiuteriui pateiksime pradinius duomenis

111
222
33

tai, atlikę šių sakinių veiksmus, jis išspausdins skaičius

111
222  222
33  33  33

Trečias skaičius yra dviženklis. Todėl jis nebesilygiuoja su ankstesnėse eilutėse išspausdintais triženkliais skaičiais. Sulygiuoti galima panaudojus formatus.

5 pavyzdys.

program trys;
  const f = 4;
  var a: integer;
begin
  read(a);
  writeln(a: f);
  read(a);
  writeln(a: f, a: f);
  read(a);
  writeln(a: f, a: f, a: f)
end.

Dabar kompiuteris išspausdintų:

111
222  222
  33    33  33

Skaičiai lygiuojami taip, kad vienas po kito būtų vienodo reikšmingumo skaitmenys. T.y., sveikieji skaičiai pagal dešiniąją pusę, o realieji pagal trupmeninę dalį skiriantį kablelį.

Uždaviniai

2.3.1. Ką matysime ekrane po to, kai kompiuteris atliks programą:

program p;
  var pirmas, antras: integer;
begin
  read(pirmas, antras);
  writeln(pirmas, '  ', antras, '  ', pirmas)
end.

jeigu buvo pateikti šitokie pradiniai duomenys:
22  33

2.3.2. Ką matysime ekrane po to, kai kompiuteris atliks programą:

program p;
  var pirmas, antras: integer;
begin
  read(pirmas, antras, pirmas);
  writeln(pirmas, '  ', antras, '  ', pirmas)
end.

jeigu buvo pateikti šitokie pradiniai duomenys:
222  333  444

2.3.3. Ką parašys kompiuteris atlikęs programą

program ppp;
  var a: integer;
begin
  writeln(a);
  read(a)
end.

jeigu buvo pateiktas šitoks pradinis duomuo
22

Atsakymą paaiškinkite.

2.4. Skaičiavimai pagal formules

Šiame skyriuje išnagrinėtų Paskalio kalbos konstrukcijų pakanka, kad būtų galima užrašyti bet kokių skaičiavimų pagal formules programas. Tokių uždavinių programavimas labai paprastas: reikia formulę su aritmetiniais skaičiavimais užrašyti Paskalio kalbos žymenimis.

1 pavyzdys. Tiesinės lygties ax+b=0 sprendimas.

program TiesLygtis;
  var a, b,                  { lygties koeficientai }
        x: real;               { lygties šaknis }
begin
  read(a, b);
  x := b/a;
  writeln(x)
end.

2 pavyzdys. Programa daugianario

a₃x³ + a₂x² + a₁x + a₀
reikšmei rasti.

program daugianaris;
  var x,                       { daugianario kintamasis }
        a₀, a₁, a₂, a₃       { daugianario koeficientai }
        p: real;                { daugianario reikšmė }
begin
  read(x, a0, a1, a2, a3);
  p:= a₀ + x*(a₁ + x*(a₂ + x*a₃));
  writeln(p)
end.

Paskalio kalba kėlimo operacijos neturi. Todėl ją reikia išreikšti daugyba. Paraidžiui užrašę formulę Paskalio kalba, gautume:

p := a₃*x*x*x + a₂*x*x + a₁*x +a₀

Tačiau šią formulę galima užrašyti ekonomiškiau:

p := a₀ + x*(a₁ + x*(a₂ + x*a₃))

3 pavyzdys. Programa, išreiškianti duotą parų skaičių valandomis ir minutėmis.

program laikas;
  var p,                     { parų skaičius }
        h,                     { valandų skaičius }
        min: integer;      { minučių skaičius }
begin
  read(p);
  h := p*24;     write(h: 4);
  min := h*60;  writeln(min: 6)
end.

Jeigu pradinis duomuo būtų skaičius 2, tai kompiuteris, atlikęs pateiktą programą, išspausdintų šitokius rezultatus:

48   2880

4 pavyzdys. Pradiniai duomenys – pirkėjo turima pinigų suma, išreikšta litais ir centais, ir prekės kaina, išreikšta litais ir centais (iš viso 4 skaičiai). Rezultatas – litais ir centais išreikšta pinigų suma, kuri liks pirkėjui, kai jis nusipirks tą prekę. Sudarysime programą šiam uždaviniui spręsti.

Pirmiausia paversime abi sumas centais, o kai rasime skirtumą, jį vėl paversime litais ir centais.

program pirkinys;
  var LtTuri,  ctTuri,                      { pirkėjas turi }
        LtPrek, ctPrek,                    { prekė kainuoja }
        LtLiko,  ctLiko: integer;         { pirkėjui liko }
begin
  read(LtTuri, ctTuri, LtPrek, ctPrek);
  ctLiko := (LtTuri*100 + ctTuri) - (LtPrek*100 + ctPrek);
  LtLiko := ctLiko div 100;
  ctLiko := ctLiko mod 100;
  writeln(LtLiko, ctLiko: 3)
end.

5 pavyzdys. Programa, duotą centų kiekį, išreiškianti mažiausiu monetų skaičiumi.

program centai;
  var suma,                                                  { pinigų suma }
        ct50, ct20, ct10, ct5, ct2, ct1: integer;    { monetos }
begin
  read(suma);
  ct50 := suma div 50; suma := suma mod 50;
  ct20 := suma div 20; suma := suma mod 20;
  ct10 := suma div 10; suma := suma mod 10;
  ct5 := suma div 5; suma := suma mod 5;
  ct2 := suma div 2;
  ct1 := suma mod 2;
  writeln(' Monetų po');
  writeln('50 ct: ', ct50);
  writeln('20 ct: ', ct20);
  writeln('10 ct: ', ct10);
  writeln(' 5 ct: ', ct5);
  writeln(' 2 ct: ', ct2);
  writeln(' 1 ct: ', ct1)
end.

6 pavyzdys. Trikampio plotas. Parašysime programą trikampio plotui skaičiuoti, kai žinomi visų jo kraštinių ilgiai

program TrikPlotas;
  var a, b, c,                 { kraštinių ilgiai }
        p,                         { pusperimetris }
        s: real;                  { plotas }
begin
  read(a, b, c);
  p := (a+b+c)/2;
  s := sqrt(p * (p-a) * (p-b) * (p-c));
  writeln(s)
end.

7 pavyzdys. Dviženklio skaičiaus skaitmenų suma. Žmogus mato skaičių užrašytą skaitmenimis. Todėl šis uždavinys jam labai lengvas. Kompiuteryje skaičiai koduojami kitaip (dvejetaine skaičiavimo sistema). Todėl kompiuteriui dešimtainius skaitmenis reikia apskaičiuoti pasinaudojant kalboje esančiomis sveikųjų skaičių operacijomis. Šiam tikslui tinka sveikųjų skaičių dalybos operacijos.

program SkSuma;
  var s,                       { dviženklis skaičius }
        sum: integer;       {skaitmenų suma }
begin
  read(s);
  sum := s mod 10 +    { vienetai }
             s div 10;         { dešimtys }
  writeln(sum)
end.

Uždaviniai

2.4.1. Parašykite programą, kuri suskaičiuotų, kokiu mažiausiu monetų skaičiumi galima
         išreišti duotą pinigų sumą (centais). Jos rezultatas turi būti tik vienas skaičius –
         monetų skaičius. Pasinaudokite programa centai (žr. 4 pavyzdį).

2.4.2. Turime programą

program Keitimas;
  var a, b, c : integer;
begin
  read(a, b);
  ...
  writeln(a, '  ', b)
end.

Vietoj daugtaškių reikia įrašyti tokius prieskyros sakinius, kad du skaičiai būtų rašomi atvirkščia tvarka, negu jie buvo perskaityti, t.y., sukeičiami vietomis. Pavyzdžiui, jeigu buvo perskaityti skaičiai

123  456
tai turi būti rašoma
456  123

2.4.3. Pradinis duomuo – triženklis natūralusis skaičius. Parašykite programą, kurios
         rezultatas būtų:

a) pradinio duomens skaitmenų suma;
b) skaičius, gautas perrašius pradinio duomens skaitmenis atvirkščiai.

Praktikos darbai

2.4.1. Laiko skaičiavimai. Parašykite programą skirtumui tarp dviejų tos pačios paros laiko momentų rasti. Pradiniai duomenys – du laikai, išreikšti valandomis ir minutėmis (keturi skaičiai). Pirmasis laikas ne vėlesnis už antrąjį. Rezultatas išreiškiamas dviem skaičiais: valandomis ir minutėmis. Programą išbandykite su tokiais pradinių duomenų rinkiniais:

  0   0 23 59
14 35 15 10
14 35 16 10
  2 15   2 15

2.4.2. Trikampis. Parašykite programą, kuri apskaičiuotų trikampio plotą. Pradiniai duomenys – trijų taškų – trikampio viršūnių koordinatės plokštumoje (šeši skaičiai). Programos išbandymui parinkite tokius pradinius duomenis, kurie aprašo:

a) statų trikampį;
b) buką trikampį;
c) tiesę (t.y., visi trys taškai yra vienoje tiesėje);
d) tašką (t.y., visų trijų taškų koordinatės sutampa).

2.5. Duomenų saugojimas tekstinėse bylose

Klaviatūra patogu surinkti nedaug pradinių duomenų. Be to kiekvieną kartą vykdant programą tenka visus pradinius duomenis rinkti iš naujo, nors ir mažai ką norėtume pakeisti, nes seni pradiniai duomenys neišsaugomi.

Į kompiuterio ekraną telpa nedaug rezultatų. Tai, kas rodoma ekrane, neišsaugoma.

Todėl tokie paprasčiausi duomenų pateikimo ir rezultatų gavimo būdai tinka tik mažoms programoms, turinčioms nedaug pradinių duomenų ir nedaug rezultatų. Kai operuojama su didesniais duomenų, būtų patogiau pradinius duomenis imti iš disko, o rezultatus rašyti į diską. Kaip tai padaryti?

Paskalio kalba turi standartinį tekstinės bylos duomenų tipą. Jis žymimas vardu text. Aprašysime du tekstinės bylos tipo kintamuosius:

var duomenys, rezultatai;

Tekstinė byla yra sudaryta iš simbolių. Šis tekstas, kurį skaitome, taip pat gali būti vaizduojamas teksto byla. Jame gali būti visko: žodžių, skaičių, skyrybos ir kitokių ženklų. Tačiau viskas išreikšta simboliais. Taigi, teksto byla yra ilga simbolių seka. Kaip ir įprastame tekste, ji suskirstyta į eilutes.

Taigi bylos kintamojo reikšmė yra struktūrinė – sudaryta iš komponentų – simbolių.Tai struktūrinis duomenų tipas.

Bylos (t.y., bylos tipo kintamųjų reikšmės) saugomos diskuose. Tuo tarpu kompiuteris atlieka operacijas tik su tais duomenimis, kurie saugomi jo operatyvioje atmintinėje. Todėl norint atlikti operacijas su byloje saugomais duomenimis, pirmiau juos reikia priskirti įprastiems kintamiesiems. O tai ne kas kitas, kaip pradinių duomenų skaitymas.

Paskalio programa „žino“ tik tuos vardus, kurie yra aprašyti programoje. Vardas ir juo pažymėtas objektas „gimsta“ kai jis aprašomas ir „miršta“ kai programa baigia darbą. Bylų, saugomų diskuose, vardus tvarko operacinė sistema. Tokios bylos ir jų vardai egzistuoja ilgai, nepriklausomai nuo Paskalio programų. Operacinė sistema nežino vardų, kurie yra aprašyti Paskalio programoje. Taigi, norint, kad Paskalio programa operuotų su bylomis, saugomomis diskuose, reikia abiejų sistemų (operacinės ir Paskalio) susieti. Turbo Paskalyje ir daugelyje kitų sistemų tokia sąsaja programoje nurodoma sakiniu assign, turinčiu tokį pavidalą:

assign(bv, eil)
čia bv – Paskalio bylos vardas,
eil – simbolių eilutė, kurios reikšmė – diske saugomos bylos vardas.

Pavyzdžiui, sakinys

assign(b, 'C:\DUOMENYS.TXT')

aukščiau aprašytą tekstinę bylą b susieja su diske saugoma byla DUOMENYS.TXT. Vadinasi, nuo šiol visi veiksmai, užrašyti su byla b faktiškai bus atliekami su disko C: pagrindiniame kataloge saugoma byla DUOMENYS.TXT.

Kaip minėjome, tekstinėse bylose simboliai suskirstyti į eilutes. Kiekvienos eilutės pabaigą žymi specialus simbolis, vadinamas eilutės pabaigos simboliu. Kai byla peržiūrima kokiu nors žiūrikliu, toje vietoje, kur yra eilutės pabaigos simbolis, tekstas keliamas į naują eilutę. Ekrane nematome eilutės pabaigos simbolių, bet matome tekstą, gražiai suskirstytą į eilutes.

Kokios operacijos atliekamos su bylomis?

Tai mums jau pažįstamos duomenų skaitymo ir rašymo operacijos. Panagrinėsime jų specifiką.

Skaitymo operacija read skaito tekstą, užrašytą byloje, lygiai taip, kaip surinktą klaviatūra. Tiktai skliaustuose po operacijos vardo pirmiausia rašomas vardas bylos, iš kurios bus skaitoma, pavyzdžiui,

read(b, n)

Duomens reikšmė, perskaityta iš bylos b, bus priskirta kintamajam n.

Jeigu sakinyje read pirmasis vardas yra ne bylos vardas, tai tada tada skaitoma iš klaviatūros (ką jau žinome).

Iš klaviatūros perskaitoma viskas, kas buvo surinkta. Iš bylos skaitoma tik tiek, kiek simbolių sudaro reikšmę kintamojo, užrašyto sakinyje read, t.y., skaitoma iki pirmojo simbolio, nebepriklausančio to kintamojo reikšmei. Pavyzdžiui, jeigu bylos b pradžia būtų tokia:

25425   5842   -458

tai pagal ankstesnį sakinį būtų perskaitytas tik pirmasis skaičius 25425, o tolesnis tekstas lauktų savo eilės – kitų skaitymo sakinių. Galima įsivaizduoti, kad byla slenka žymeklis, kurio kairėje yra perskaitytas tekstas.

Tarpai tarp skaičių nesvarbūs – jie praleidžiami. Taip pat nekreipiama dėmesio ir į teksto suskirstymą į eilutes: jeigu skaičiaus nerandama vienoje eilutėje (ar likusioje dar neperskaitytoje jos dalyje), einama į kitą eilutę ir t.t., praleidžiami visi tarpai kol surandamas skaičius.

Yra ir kita skaitymo sakinio forma readln. Šiuo atveju turi įtakos ir teksto skirstymas į eilutes: perskaitoma visa eilutė iki pabaigos. Į skliaustuose išvardytus kintamuosius „netilpusi“ eilutės dalis praleidžiama. Jeigu, pavyzdžiui, pirmosios dvi bylos b eilutės būtų tokios:

25425    5842    -458
2222  3333  4444

tai atlikus sakinius

readln(b, n);   read(b, m)

kintamieji įgytų tokias reikšmes:

n = 25425, m = 2222

Tuo tarpu sakiniai

read(b, n);   read(b, m)

jiems būtų priskyrę tokias reikšmes:

n = 25425, m = 5842

Sakinį readln patogu vartoti tada, kai programoje reikia panaudoti tik dalį duomenų, surašytų tekstų bylos eilučių pradžiose.

Duomens skaitymo iš klaviatūros pakartoti nebegalima, nebent iš naujo jį surinktume. Tuo tarpu iš bylos perskaitytas duomuo nedingsta. Norint pakartotinai skaityti bylą reikia grįžti į jos pradžią – atlikti sakinį

reset(b)

Byla b vėl bus skaitoma iš pradžių – skaitymo laukiantį duomenį nurodantis žymeklis bus nustatytas į bylos pradžią. Bylos žymeklio vietą galima traktuoti kaip bylos reikšmės dalį. O tik ką aprašyto kintamojo reikšmė būna neapibrėžta. Taigi, ir žymeklis gali būti bet kur. Todėl prieš bylos skaitymo veiksmus turi eiti sakinys reset.

Rašymo sakinys write rašo rezultatus (duomenis) į bylą, kurios vardas yra parašytas pirmuoju skliaustuose. Jeigu pirmasis vardas nėra bylos vardas, tai rašoma į ekraną (ką jau žinome).

Sakinys writeln(b) formuoja naujos eilutės rašymą į bylą b.

Rašoma į bylos pabaigą. Prirašomi nauji simboliai neištrinant esamų. Rašoma byla didėja. Todėl rezultatams skirtą bylą pradžioje reikia išvalyti. Tą atlieka sakinys

rewrite(b)

Kai atliekamas šis sakinys, byla b išvaloma – tampa tuščia ir paruošta rezultatų rašymui. O jeigu diske nėra bylos, susietos su byla b, tai tokia byla sukuriama.

Pateiksime pavyzdžių.

Pavyzdys. Byloje SKAIČIAI.TXT yra trys sveikieji skaičiai. Parašysime programą, kuri pirmąjį skaičių iš minėtos bylos perrašys į bylą PIRMA.TXT, o kitus du – į bylą ANTRA.TXT. Pradinių duomenų byla saugoma disko A: pagrindiniame kataloge, rezultatų bylos – disko C: kataloge DUOMENYS.

program TrysBylos;
  var prad,                      { pradinių duomenų byla }
        pirma, antra: text;   { rezultatų bylos }
        x, y: integer;           { perskaityti skaičiai }
begin
  assign(prad, 'A:\SKAIČIAI.TXT'); reset(prad);
  assign(pirma, 'C:\DUOMENYS\PIRMA.TXT'); rewrite(pirma);
  assign(antra, 'C:\DUOMENYS\ANTRA.TXT'); rewrite(antra);
  read(prad, x); writeln(pirma, x);
  read(prad, x, y); writeln(antra, x, y:10);
end.

Operacinės sistemos bylų vardai ir programoje aprašyti bylų vardai yra nepriklausomi vieni nuo kitų: jie gali sutapti, gali būti skirtingi. Be to operacinės sistemos bylų vardai sudaromi pagal kitokia taisykles, negu Paskalio programose naudojami vardai.

Su bylomis yra susiję dvi standartinės funkcijos:

eoln(b) – eilutės pabaiga,
eof(b) – bylos pabaiga.

Tai funkcijos, kurių argumentai yra bylos, o rezultatai – loginės reikšmės (apie logines reikšmes kalbėsime kitame skyrelyje).

eoln(b) = true, jeigu bylos b duomenų žymeklis rodo eilutės pabaigos simbolį ir
eoln(b) = false, priešingu atveju;
eof(b) = true, jeigu bylos b duomenų žymeklis rodo bylos pabaigos simbolį ir
eof(b) = false, priešingu atveju;

Šias funkcijas naudosime vėliai, kai jų prireiks.

Uždaviniai

2.5.1. Parašykite programą, atvirkščią programai TrysBylos, t.y., tokią, kuri iš bylų
         PIRMA.TXT ir ANTRA.TXT perrašytų tris skaičius į vieną bylą SKAIČIAI.TXT.

2.5.2. Perrašykite 2.4 skyrelio 1 pavyzdžio programą TiesLygtis taip, kad pradiniai
         duomenys (lygties koeficientai) būtų skaitomi iš disko C: pagrindiniame kataloge
         esančios bylos PRAD.XXX, o rezultatas būtų rodomas ekrane.

2.6. Standartinės tekstinės bylos

Paskalis turi dvi standartines tekstines bylas, t.y., du standartinius tekstinių bylų tipo kintamuosius:

input – pradinių duomenų byla, susieta su klaviatūra,
output – rezultatų byla, susieta su vaizduoklio ekranu.

Taigi, klaviatūra ir vaizduoklio ekranas sutapatinami su bylomis. Kai kompiuteris skaito klaviatūra surinktus pradinius duomenis, jis elgiasi taip, lyg juos skaitytų iš bylos, pavadintos vardu input. Kai kompiuteris rašo rezultatus į ekraną, jis elgiasi taip, lyg juos rašytų į bylą, pavadintą vardu output. Standartinės bylos nuo įprastų bylų skiriasi tuo, kad jų vardų galima nerašyti į skaitymo ir rašymo sakinius. Jeigu pirmasis skaitymo arba rašymo procedūros parametras yra ne byla, tai tada laikoma, kad reikia skaityti iš standartinės bylos input arba rašyti į standartinę bylą output. Jeigu kreipinyje į funkciją eof arba eoln nenurodytas parametras, tai laikoma, kad ta funkcija taikoma standartinei bylai input. Štai todėl anksčiau ir nepastebėdavome, kad skaitydami arba rašydami duomenis naudojamės standartinėmis bylomis.

Standartinėms byloms taip pat galima taikyti procedūrą assign. Tai yra jas galima susieti su diske saugomomis bylomis.

Pavyzdys. Programą daugianario

a₃x³ + a₂x² + a₁x + a₀

reikšmei rasti (žr. 2.4 skyr. 2 pavyzdį perrašysime taip, kad standartinės bylos input ir output būtų susietos su bylomis, saugomomis diske.

program daugianaris;
  var x,                         { daugianario kintamasis }
        a₀, a₁, a₂, a₃,        { daugianario koeficientai }
        p: real;                  { daugianario reikšmė }
begin
  assign(input, 'DUOM.TXT); reset(input);
  assign(output, 'REZ.TXT); rewrite(output);
  read(x, a₀, a₁, a₂, a₃);
  p:= a₀ + x*(a₁ + x*(a₂ + x*a₃));
  writeln(p)
end.

Uždaviniai

2.6.1. Pavyzdyje nenurodytas nei diskas, nei katalogas, kuriame turi būti bylos DUOM.TXT
         ir REZ.TXT. Kaip Jūs manote, kur šios bylos turėtų būti saugomos?

2.6.2. Perrašykite 2.4 skyrelio 3 pavyzdžio programą laikas taip, kad standartinės bylos
         būtų susietos su bylomis, saugomomis diske.

E Ankstesnis puslapis

3 Turinys

Kitas puslapis F