7. ALAPVETŐ I/O műveletek


7.1. Irás képernyőre: Write és Writeln eljárások
A   Pascal  programozásban   a  standard  output  (szabványos  kimenet)
periféria a képernyő. A képernyőre két eljárással irhatunk:

     Write(paraméterek);
     Writeln(paraméterek);

A paramétereket vesszővel elválasztva kell felsorolni.
A paraméterek lehetnek:

     -  szöveg '' aposztrofok között,
     -  változónevek,
     -  konstansok,
     -  aritmetikai kifejezések,
     -  logikai kifejezések,
     -  függvényhívás.

A Write és a Writeln eljárások között az alábbi különbség van:

     -   a write  eljárás a  kurzor által  mutatott pozícióra  ír, és a
kurzort a      kiírás utáni pozícióban hagyja.

   -      a  writeln eljárás  is a kurzor által mutatott pozíciótól ír,
azonban a      paramétereknek   a  képenyőre   való  kiírása   után   a
következő sor ele-  jére állítja a kurzort.

   -      a  paraméter nélküli writeln; eljárással üres sort írhatunk a
képernyőre.

A  7.1. ábra  szemléletesen  bemutatja  a  különbséget  a  két  eljárás
között.
{EMBED MSDraw   \* mergeformat|}

     7.1.  ábra Különbség  a. Write  eljárás és  a b.  Writeln  eljárás
között

7.1.1. Szöveg kiírása a képernyőre
A  write és  a writelen  eljárásokban a szöveg konstanst '' között kell
megadni.

A   mintaprogramokban  az  eredmény  kiírása  előtt  a  képernyő  előző
tartalmát  letöröljük, hogy  a program  többszöri futtatása  esetén  az
eredmények  üres képernyőn jelenjenek meg. A képernyő törlésére szolgál
a  clrscr paraméter  nélküli eljárás, amely a crt unit-ban található. A
crt könyvtárat a uses kulcsszó után kell meghivatkozni.

Futtassuk le az IR1.PAS programot:

program ir1;
uses crt;
begin
     clrscr;
     writeln('Szoveg irasa kepernyore');
     writeln('Ez a program fejlece');
     writeln;
     write('Az ');
     write('elso ');
     write('sor. ');
     writeln;
     write('A masodik ');
     writeln('sor.');
     writeln('Harmadik sor.'#10#13'Negyedik sor.');
     writeln(#7#7'Ketszer csenget');
end.

A program eredménye:

Szoveg irasa kepernyore
Ez a program fejlece

Az elso sor.
A masodik sor.
Harmadik sor.
Negyedik sor.
Ketszer csenget

A  példában is  látható, hogy  a writeln  eljárás a  sort  zárja  és  a
kurzort  a következő  sor elejére  állítja. A  write segítségével kiírt
információ  a kurzorral jelzett sorba kerül. Mivel a write nem zárja le
sort,  a következő write az előzővel azonos sorba ír. Gyakran szükséges
a  programban, hogy a megkezdett sorban írhassuk tovább a program által
később kiszámolt eredményt.

A  program utolsó  writeln eljárása  két darab  #7 csengő  (bell) kódot
tartalmaz,  ha a  programot lefuttatjuk  kétszer  fog  csengetni  és  a
képernyőn a 'Ketszer csenget' szöveg jelenik meg új sorban.

7.1.2. Egész típusú eredmények kiiratása
A  Turbo Pascalban  a  változók  kiirására  létezik  egy  ún.  standard
formátum.  Az egész számok, egész típusú változók valamint egész típusú
kifejezések  értékét szorosan  egymás mellé  írja a  write és a writeln
eljárás,  csak a negatív előjelet írja ki, a pozitív előjel helyén üres
helyet   sem  hagy   ki.  Természetesen  ilyen  kiírásnál  az  eredmény
kiértékelhetetlen,  ilyenkor a  writeln(i,j,k); eljárás  hívás  helyett
writeln(i,' ',j,' ',k); hívást alkalmazhatjuk.

Kiiratás mezőszélességgel

     write(parameter: n);
     writeln(parameter: n);

ahol    n   egész szám, a mezőszélesség

A  write vagy  writelen eljárásban  a paraméter  után kettőaponttal (:)
elválasztva  megadott egész  számot mezőszélességnek  nevezünk. A mező-
szélesség  határozza meg, hogy a számkiírás mekkora helyet foglaljon le
a képernyőn.

Ha  a mezőszélesség nagyobb, mint a szám jegyeinek száma, hozzáadva még
az  előjelét, akkor  természetesen megfelelő számú üres hely keletkezik
a szám előtt, mert a mező jobb széléhez igazítva történik a kiírás.
Például írjuk ki az alábbi konstansokat:

     writeln(-100,22);
-10022
     writeln(-100,' ',22);
-100 22
     writeln(-100:6,22:4);
   -100  22

A  -100 kiírásánál  a szám előtt 3, a 22 kiírásánál a szám előtt 2 üres
hely keletkezik.
Megjegyezzük,  hogy ha  olyan mezőszélességet adunk, amelybe nem fér el
a  szám, akkor  a Turbo  Pascal  nem  ad  hibajelzést,  hanem  áttér  a
standard kiírási formátumra.

Értékeljük ki, majd futtassuk le az IR2.PAS programot:

program ir2;
uses crt;
var
   i,j,k: integer;
begin
   clrscr;
   i:=12; j:=-12; k:=+100;
   writeln('Standard kiiratas);
   writeln(i,j,k);
   writeln('Eredmeny szoveges kiiratasa');
   writeln('i=',i,' j=',j,' k=',k);
   writeln('Kiiratas mezoszelesseggel');
   writeln(i:4,j:5,k:6);
   writeln('i=',i:3,' j=',j:4,' k=',k:4);
   writeln('Helytelen mezoszelesseg megadasa');
   writeln(i:1,j:2,k:3);
   writeln('Kifejezes kiiratasa');
   writeln('k+i=',k+i);
   writeln('Konstansok kiiratasa');
   writeln(12,-100);
   writeln(12:4,-100:5);
end.

A program eredménye:

Standard kiiratas
12-12100
Eredmeny szoveges kiiratasa
i=12 j=-12 k=100
Kiiratas mezoszelesseggel
  12  -12   100
i= 12 j= -12 k= 100
Helytelen mezoszelesseg megadasa
12-12100
Kifejezes kiiratasa
k+i=112
Konstansok kiiratasa
12-100
  12  -100


7.1.3. Valós eredmények kiiratása
A  valós, tehát  lebegőpontos számok  kiiratásának is  létezik standard
formátuma.  A valós szám mindig egy egészre normálva, Turbo Pascal 5.0,
5.5  változatnál 10 tizedesjegyre kerül kiírásra úgy, hogy a 10 hatvány
helyett E és a kitevő két helyiértéken kerül kiirásra, pl.

     0.001     1.0000000000E-03
    -1.2      -1.2000000000E+00
    11.3       1.1300000000E+01
 92560.43      9.2560430000E+04

Turbo  Pascal 6.0  verzióban a  tizedek száma  15 és  a kitevő 4 jegyen
kerül ábrázolásra:

     -1.123456789012345E-0001
      2.123456789012345E+0000

A   valós  számok   kiírásánál  is   adhatunk  a   mezőszélességet.   A
mezőszélesség  kiszámításánál a  következőket kell  figyelembe venni: 3
hely  szükséges a  szám előjele, az egészrész és a tizedespont miatt, a
exponens  számára a  verziótól függően  4 vagy  6  hely  szükséges(  E,
előjel  és  a  kitevő).  Tehát  a  mezőszélességnek  verziótól  függően
nagyobbnak  kell lenni  7-nél vagy  10-nél. Ha  kevesebbet  adunk  meg,
akkor  hibajelzés nélkül  lebegőpontosan egy egész és egy tized értéket
fog írni normált alakban a Turbo Pascal.

Fixpontos kiíratási formátum:

     write(parameter: m:n);
     writeln(parameter:m:n);

ahol   m       egész szám, mezőszélesség,
      n        egész szám, a tizedek száma,

Van   még  egy   kiíratási  forma,  ahol  a  valós  számot  fixpontosan
irathatjuk  ki, tehát  az egész és a tizedes részeivel az exponens rész
nélkül.  Ebben  az  esetben  a  mezőszélességet  újabb  :  (kettőspont)
követi,   mely  után   megadott  egész  szám  a  tizedek  számát  fogja
meghatározni.  A tizedek  száma a  mezőszélesség részét  képezi,  tehát
beleértendő a mezőszélességbe.
Értékeljük ki, majd futtassuk le az IR3.PAS programot:

program ir3;
uses crt;
var
   a,b,c,d,e: real;
begin
 clrscr;
 a:=12.56; b:=-12.56; c:=0.5; d:=1.0e-3;
 e:=1.63e+3;
 writeln('Standard kiiratas');
 write(a); write(b); writeln;
 writeln(c,d);
 writeln(e);
 writeln('Kiiratas mezoszelesseggel normalt alakban')
 writeln('a=',a:9,' b=',b:10);
 writeln('Helytelen mezoszelesseg megadasa');
 writeln('a=',a:4,' b=',b:4);
 writeln('Kiiratas fixpontos alakban');
 writeln('a=',a:9:2,' b=',b:10:3);
 writeln('a=',a:2:1,' b=',d:10:0);
 writeln('Konstansok kiiratasa');
 writeln(123.456,123.456:10,' ',-123.456:10:3,' ',          
          0.001:7:3);
 writeln(123.456:1:1,' helytelen mezoszelesseggel');
 writeln('Kifejezesek');
 writeln('a+c=',a+c:8:2);
 writeln(' sqr(2)=',sqr(2),' sqr(2.0)=',sqr(2.0));
end.

A program eredménye:

Standard kiiratas
 1.2560000000E+01-1.2560000000E+01
 5.0000000000E-01 1.0000000000E-03
 1.6300000000E+03
Kiiratas mezoszelesseggel normalt alakban
a= 1.26E+01 b=-1.256E+01
Helytelen mezoszelesseg megadasa
a= 1.3e+01 b=-1.3E+01
Kiiratas fixpontos alakban
a=    12.56 b=   -12.560
a=12.6 b=       -13
Konstansok kiiratasa
 1.2345600000E+02 1.2345E+02   -123.456  0.001
123.5 helytelen mezoszelesseggel

Kifejezesek
a+c=   13.06
sqr(2)=4 sqr(2.0)= 4.0000000000E+00



7.1.4. Boolean típusú eredmények kiiratása
A   boolean  konstansok,   változók  kifejezések   kiiratása  hasonlóan
történik,  mint az  egész számoknál, mivel a standard kiiratás pontosan
annyi  karakterre vonatkozik,  mint maga  a true vagy a false konstans,
tehát  a kiirási  felsorolásnál az  eredmény  szorosan  egymás  mellett
keletkezik.  Itt is  megadhatunk mezőszélességet,  ekkor a  true vagy a
false jobbra igazítva íródik ki.

Példaként,  nézzük meg  az  IR4.PAS  programot,  amely  demonstrálja  a
boolean típusú kiiratásokat:

program ir4;
uses crt;
var
   b1,b2: boolean;
begin
   clrscr;
   writeln('Boolean valtozok kiiratasa');
   b1:=true; b2:=false;
   writeln('Standard kiiratas');
   writeln(b1,b2);
   writeln('Mezoszelesseg megadasa');
   writeln(b1:6,b2:6);
   writeln('Helytelen mezoszelesseg megadasa');
   write(b1:3); write(b2:4);
   writeln;
   writeln('Logikai kifejezesek kiiratasa');
   writeln('2 <3 : ',2 < 3,' b1 and b2:',b1 and b2);
   writeln('Logikai konstansok kiiratasa');
   writeln(true,' ',false);
end.

Értékeljük ki a program eredményét:

Boolean valtozok kiiratasa
Standard kiiratas
TRUEFALSE
Mezoszelesseg megadasa
  TRUE FALSE
Helytelen mezoszelesseg megadasa
TRUEFALSE
Logikai kifejezesek kiiratasa
2 < 3 : TRUE b1 and b2:FALSE
Logikai konstansok kiiratasa
TRUE FALSE

Foglaljuk  össze a  különböző  típusú  változók  mezőszélességgel  való
kiiratását (KIIR.PAS):

program kiir;
uses crt;
begin
   clrscr;
     writeln('#':1);
     writeln('#':3);

     writeln(1992:1);
     writeln(1992:4);
     writeln(1992:5);
     writeln(1992:7);
     writeln(-1992:1);
     writeln(-1992:3);
     writeln(-1992:5);
     writeln(-1992:7);
     writeln('Nyomj Enter-t…');
     readln;
   clrscr;
     writeln('hello':1);
     writeln('hello':3);
     writeln('hello':5);
     writeln('hello':7);

     writeln(true:1);
     writeln(true:3);
     writeln(true:5);
     writeln(true:7);
     writeln(false:1);
     writeln(false:3);
     writeln(false:5);
     writeln(false:7);
     writeln('Nyomj Enter-t…');
     readln;
   clrscr;
     writeln(123.456:1:1);
     writeln(123.456:1:3);
     writeln(123.456:1:4);
     writeln(123.456:5:1);
     writeln(123.456:6:1);
     writeln(123.456:7:1);

     writeln(-123.456:1:1);
     writeln(-123.456:1:3);
     writeln(-123.456:1:4);
     writeln(-123.456:5:1);
     writeln(-123.456:6:1);
     writeln(-123.456:7:1);

     writeln(567.8:1);
     writeln(567.8:8);
     writeln(567.8:9);
     writeln(567.8:10);
     writeln(567.8:11);

     writeln(-567.8:1);
     writeln(-567.8:8);
     writeln(-567.8:9);
     writeln(-567.8:10);
     writeln(-567.8:11);

     writeln('Nyomj Enter-t…');
     readln;

end.



{EMBED MSDraw   \* mergeformat|}

{EMBED MSDraw   \* mergeformat|}






7.2. Olvasás billentyűzetről: Read, Readln eljárások
A  Turbo Pascalban  a standard  input (szabványos bemeneti) periféria a
billentyűzet.  A read  és a  readln eljárások  felfüggesztik a  program
futását  és a  klaviatúráról az ENTER billentyű lenyomásáig olvassák az
adatokat.
     
     read(paraméterek);
     readln(paraméterek);

A paraméterek:
     -  csak változók  lehetnek, kivételt  képeznek a boolean változók,
mivel azok értékét nem lehet beolvasni billentyűzetről.

Először  vizsgáljuk meg  a  read  eljárás  működését.  A  read  eljárás
felfüggeszti  a program  futását és várja az adatok billentyűzeten való
begépelését  befejezve az  ENTER leütésével. A read utasítás a begépelt
adatokból  sorra értéket ad a paramétereinek. Ha kevesebb adatot adtunk
meg,   mint  amennyi  a  read  paraméterlistáján  volt,  akkor  további
adatmegadásra  vár az  eljárás. Ha  viszont több  adatot gépeltünk  be,
mint  amennyi szükséges  volt a read eljárásnak, akkor a következő read
eljárás a további adatokat átadja a paramétereinek.

A  numerikus adatokat  legalább egy  üres hely (space karakter) vagy az
ENTER választja el egymástól.

program io1;
uses crt;
var
   szam,szam1 : integer;
begin
  clrscr;
  write('Kerek egy egesz szamot: ');
  read(szam);
  writeln('A beolvasott elso szam   : ',szam);
  write('Kerek egy egesz szamot : ');
  read(szam1);
  writeln('A beolvasott masodik szam: ', szam1);
end.


Futtassuk le az IO1.PAS programot az alábbi adatokkal:

Kerek egy egesz szamot: 2 3
A beolvasott elso szam  : 2
Kerek egy egesz szamot: A beolvasott masodik szam: 3

A  fenti futtatásnál  a 23  helyett véletlenül 2 3-at adtunk meg ENTER-
rel  terminálva, amely két külön adatnak bizonyul, így a read eljárás a
szam  változóba betöltötte  a 2-es  értéket. Ellenőrzésképpen vissza is
írattuk  a képernyőre  a 'A beolvasott elso szam  : ' szöveg mellett és
valóban  a 2  jelenik meg.  Mivel a következő eljáráshívás szintén read
és  mivel a  read   tovább tud olvasni az input pufferból és így a 3-as
számot beolvasva nem függeszti fel a program futását.

A  'Kerek egy  egesz szamot:  'szöveg után nem vár adatbevitelre, ezért
ebben  a sorban  jelenik meg  az ellenőrző szöveg 'A beolvasott masodik
szam:  ' mellett  a 3,  amelyet tévesen  adtunk  meg.  Futtassuk  le  a
programot az adatok helyes megadásával is.

Az  IO1.PAS programot  módosítsuk úgy,  hogy  a  read  eljárás  helyett
readln   eljárást  hívást   alkalmazzunk.  Futtassuk   le  az   IO2.PAS
programot.

program io2;
uses crt;
var
   szam,szam1 : integer;
begin
  clrscr;
  write('Kerek egy egesz szamot: ');
  readln(szam);
  writeln('A beolvasott elso szam   : ',szam);
  writeln('Kerek egy egesz szamot : ');
  readln(szam1);
  writeln('A beolvasott masodik szam: ', szam1);
end.

Futtassuk le a programot az alábbi adatokkal:

Kerek egy egesz szamot:  3 5
A beolvasott elso szam   :  3
Kerek egy egesz szamot : 4
A beolvasott masodik szam: 4
Kiértékelve  az eredményt  láthatjuk, hogy  a 3  5 ENTER  került be  az
input   pufferba.  A   readln  eljárás  egy  sort  olvas  be,  egyetlen
paraméterének  ad  értéket.  Tehát  a  szam  változó  felveszi  a  3-as
értéket,   amely  a   A  beolvasott   elso  szam  :  '  szöveg  mellett
ellenőrzésképpen visszaírásra kerül.

A  következő readln  nem folytatja  az olvasást  az  előzőleg  begépelt
adatsorból,  hanem új  begépelésre vár, ami az input pufferba maradt az
az  adat elveszik  a beolvasás  számára.   4 és ENTER begépelése után a
readln a szám1 változónak a 4-es értéket adja, amelyet újra kiíratunk.
Megjegyezzük,  hogy a  paraméter nélküli  readln eljárással szintén egy
sort  olvasunk, az  adatok elvesznek,  mivel  nem  kerülnek  tárolásra,
ezzel a módszerrel sort tudunk kihagyni a beolvasandó adatok közül.

Olvassunk karaktereket először read utasítással:

program io3;
uses crt;
var
   c1,c2,c3,c4: char;
begin
   clrscr;
   write('Karakterek beolvasasa: ');
   read(c1); read(c2); read(c3); read(c4);
   writeln('A beolvasott karakterek:');
   writeln('c1=',c1,' c2=',c2,' c3=',c3,' c4=',c4);
end.

Az IO3.PAS program futtatási eredménye:

Karakterek beolvasasa: abcdef
A beolvasott karakterek:
c1=a c2=b c3=c c4=d

Láthatjuk,   hogy  az   abcdef  karaktersorozatból   a   read   eljárás
folyamatosan  olvas és csak annyi karaktert vesz ki az input pufferból,
amennyi paraméternek kell értéket adni.





Az IO4.PAS programban a karaktereket readln eljárással olvassuk be:

program io4;
uses crt;
var
   c1,c2,c3,c4: char;
begin
   clrscr;
   writeln('Karakterek beolvasasa:');
   readln(c1); readln(c2); readln(c3); readln(c4);
   writeln('A beolvasott karakterek:');
   writeln('c1=',c1,' c2=',c2,' c3=',c3,' c4=',c4);
end.

A program futási eredménye:

Karakterek beolvasasa:
abcd
efg
hij
kl
A beolvasott karakterek:
c1=a c2=e c3=h c4=k

Láthatjuk,  hogy hiába  gépeltük be  az abcd  karaktersorozatot, hogy a
négy  karakter változónak  adjunk értéket,    mivel  a  readln  eljárás
paraméterlistáján  csak egyetlen karakter változónak kell, hogy értéket
adjon,  így az  új sorig  beolvasott adatsorozatból  az első  karaktert
adta  értékül a  c1 változónak.  A következő  readln már  nem olvas  az
előző  sorból,  ezért  újabb  karakter  bevitelre  vár.  Látható  a  'A
beolvasott  karakterek:' fejléc  alatt  visszairatott  karakterváltozók
tartalmából,  hogy a  readln mindig az új sorban megadott első karakter
értékét vette át.

Most  módosítsuk újra  a programot  úgy, hogy  a beolvasandó 4 karakter
változóját  egyetlen readln  paraméterlistáján adjuk  meg. Futtassuk le
az IO5.PAS programot.

 program io5;
uses crt;
var
   c1,c2,c3,c4: char;
begin
   clrscr;
   writeln('Karakterek beolvasasa:');
   readln(c1,c2,c3,c4);
   writeln('A beolvasott karakterek:');
   writeln('c1=',c1,' c2=',c2,' c3=',c3,' c4=',c4);
end.

A program futtatási eredménye:

Karakterek beolvasasa:
abcd
A beolvasott karakterek:
c1=a c2=b c3=c c4=d

Nézzük  meg miben  tér el  a program futtatási ereménye az előzőtől. Az
abcd  ENTER begépelése  után a  readln eljárás a paraméterlistáján lévő
négy  karakterváltozónak mindegyikének  tudott értéket  adni  az  input
pufferból.

Nézzük meg, ha másképpen adtuk volna meg az adatokat:

Karakterek beolvasasa:
abc
A beolvasott karakterek:
c1=a c2=b c3=c c4=

Ennél  az adatmegadásnál  látható, hogy  a readln a sorvégéig olvasva a
három  változójának, a  c1, c2 és c3 változóknak tudott értéket adni, a
c4  tartalma nem  látszik, amely az újsor karakter értékét vette fel. A
karakteres  beolvasásnál az  újsor is karakternek számít, ezért nem vár
újabb karakter leütésére a c4 változó.


Futtassuk  le az  IO6.PAS programot az alábbi adatokkal, értékeljük ki,
hogy mit kapunk eredményül:

5.1  6.7  3  4
8.1 5 6
8 9






program io6;
uses crt;
var
   x,y: real;
   n,m: integer;
begin
   clrscr;
   writeln('Numerikus adatok beolvasasa');
   readln(x); readln(y); read(n); read(m);
   writeln('A beolvasott adatok');
   writeln('x=',x:6:2,' y=',y:6:2,' n=',n,' m=',m);
end.

A program futtatási eredménye:

Numerikus adatok beolvasasa
5.1  6.7  3  4
8.1 5 6
8 9
A beolvasott adatok
x=  5.10 y=  8.10 n=8 m=9

A program eredményének magyarázata:

A  readln(x) az első sort olvasta be és az x az első értéket, az 5.1-et
vette  fel, a többi adat a sorból elveszett. A következő readln(y) újra
új  sort olvasott  és az  y a  második sor  első adatát,  a 8.1 értéket
vette  fel. Itt  is elvesztek  a további  adatok a  sorból. A  harmadik
sorból  a 8 és a 9 adatokat a két read eljárás olvasta be és így kapott
értéket az n és az m változó.
A program beolvasó sorait a következőképpen módosítjuk:

     readln(x,y,n,m);
          vagy
     read(x,y,n,m);

Az IO7.PAS program:

program io7;
uses crt;
var
   x,y: real;
   n,m: integer;
begin
   clrscr;
   writeln('Numerikus adatok beolvasasa');
   readln(x,y,n,m);
   writeln('A beolvasott adatok');
   writeln('x=',x,' y=',y,' n=',n,' m=',m);
end.

akkor az adatmegadás a következő lehet:

5.1 8.1 8 9

A program futtatási eredménye:

Numerikus adatok beolvasasa
5.1 8.1 8 9
A beolvasott adatok
x=  5.10 y=  8.10 n=8 m=9
vagy akár minden szám lehet külön sorban is

5.1
8.1
8
9

A program futási eredménye:

Numerikus adatok beolvasasa
5.1
8.1
8
9
A beolvasott adatok
x=  5.10 y=  8.10 n=8 m=9

Az  első adatmegadásnál  két valós  és két  egész számot adtunk meg egy
üres  hellyel elválasztva  egy sorban  ENTER-rel terminálva.  A  readln
eljárás  paraméterlistáján x,y  két  valós  és  n,m  két  egész  típusú
paraméternek  kell értéket  adni. Az input pufferbe bekerülő számadatok
pontosan  megfelelnek a  paraméterek számának  és típusaiknak,  így  az
eljárás  sorban értéket  tud adni a paramétereinek az egyetlen megadott
adatsorból.

A  másik adatmegadásnál  a számokat  ENTER leütésével adtunk meg, tehát
minden   adat  új  sorban  van.  A  read  illetve  a  readln  ennél  az
adatmegadásnál   azonosan  működik.   Mindkét  eljárásnak  a  paraméter
listáján  négy változónak  kell értéket  adni, mivel  csak  egy  adatot
adtunk  meg, így  egyedül az  x  változó  veheti  fel  az  értékét.  Az
eljárások   ezért  további  adatmegadásra  várnak  és  a  külön  sorban
megadott értékeket sorra átadják a paramétereiknek.

A  példaprogramok nem  figyelmeztették a  felhasználót, hogy  milyen és
mennyi  adatot kell  megadni a  programnak, ezek  csak abból  a  célból
készültek,  hogy megmagyarázzák  a read  és a readln eljárások működése
közötti  különbséget. Természetesen a programoknak párbeszédes formában
kell  működniök, hiszen  egy üres  képernyő és  villogó kurzor mellett,
mégha  magunk is  írtuk a  programot,  az  adatok  megadási  sorrendjét
elfelejthetjük.  A    Pascal  beolvassa  az  egészként  megadott  valós
számot,  de ha  egész számot  vár és  tizedes pontot talál a beolvasott
számban, akkor hibajelzést ad.

Példaként  nézzük meg  egy programrészletet, amely párbeszédes formában
olvassa be a különböző típusú adatokat:

program io8;
uses crt;
var
   nev : string;
   ev  : integer;
   suly: real;
   m   : real;
begin
   clrscr;
   write('Szemely neve  : '); readln(nev);
   write('Szuletesi eve : '); readln(ev);
   write('Testsulya [kg]: '); readln(suly);
   write('Magassaga [cm]: '); readln(m);
   writeln('A beolvasott adatok');
end.




Gyakorlatok

1.   Feladatként  egészítsük ki az IO8.PAS programot, hogy a beolvasott
adatokat írja vissza a képernyőre (IO8M.PAS) .


2.   Az IO9.PAS programot futtassuk le az alábbi adatokkal:

15  200
1.003
g
adatok

Mit fogunk látni a képernyőn?
program io9;
uses crt;
var
   szoveg: string;
   i,j   : integer;
   x     : real;
   kar   : char;
begin
   clrscr;
   write(' i j  =');
   readln(i,j);
   write('   x  =');
   readln(x);
   write(' kar  =');
   readln(kar);
   write('szoveg=');
   readln(szoveg);
   writeln;
   writeln('A beolvasott adatok:');
   writeln('i:',i,' j : ',j);
   writeln('x     :',x);
   writeln('kar   : ',kar);
  writeln('szoveg:', szoveg);
end.

3.   Śrjunk  programot az alábbi adatok beolvasására. Az adatok számára
megfelelő  típusú változókat  deklaráljunk, a beolvasott adatokat írjuk
vissza a képernyőre:

     0 100
      3
     1.2  3.4  5.7
     q
     adat

4.   Értékeljük   ki  az  alábbi  programot,  ellenőrizzük  az  FG2.PAS
program erdményével:

program fg2;
begin
  writeln(' 1.= ',chr(succ(ord('e'))+3):4);
  writeln(' 2.= ',chr(ord(pred('c'))-1):4);
  writeln(' 3.= ',21 mod (sqr(9))+5*2:4);
  writeln(' 4.= ',('b'>'c') and (8<9) or (succ(false)):4);
  writeln(' 5.= ',('a' < succ('a')) and odd(13):4);
  writeln(' 6.= ',12 mod 77:4);
  writeln(' 7.= ',77 mod 12:4);
  writeln(' 8.= ',odd(33):4);
  writeln(' 9.= ',odd(12):5);
end.

5.   Értékeljük  ki az  alábbi programot,  mit ír ki a képernyőre, majd
ellenőrizzük le a MITIR.PAS program futási eredményével.

     program mitir;
     begin
       writeln(2*6 div 4*3:
           48 mod 3-(50-(50 div 4)*4)+6);
     end.

6.   Először  értékeljük ki  a programot,  azután  ellenőrizzük  le  az
IR5.PAS program futási eredményével.

program ir5;
var
   sz    : string;
   i,j   : integer;
   a,b,c : real;
   ch    : char;
   b1,b2 : boolean;
begin
   sz:='Megoldas'; ch:='X'; a:= 3.1; b:=2.42; i:=5; j:=-1;
   writeln(sz);
   writeln; write(ch); writeln(' -> Y');
   writeln(a,b); write(a:8,' ',b:10); writeln;
   writeln('a+b=',a+b:7:2);
   b1:=i < j; b2:= b1 or (a > b);
   write(b1, ' ',b2); writeln(' ',b1 and b2);
   writeln('i*j=',i*j);
end.