8. A PASCAL NYELV UTASŒTÁSAI


Az    utasításokat   csoportosíthatjuk    egyszerű    és    struktúrált
utasításokra.  Az egyszerű  utasítások az  üres, az  értékadó,  a  goto
utasítások és az eljáráshívás.

A  struktúrált utasításokhoz soroljuk a blokk, a feltételes (if, case),
a  ciklus (for,  while és  repeat-until) és  a  with  utasításokat.  Az
utasítások ilyen csoportosítását a 8.1 ábra mutatja.



{EMBED MSDraw   \* mergeformat|}



               8.1 ábra Az utasítások csoportosítása

8.1. Egyszerű utasítások

8.1.1. Üres utasítás
Az  utasítás neve  is jelzi,  hogy semmilyen  tevékenységet nem jelent.
Akkor  használjuk, ha  valahol szintaktikailag utasításnak kell lennie,
pl.  case utasításban egy függvényhívás hiányzik és a függvényt még nem
írtuk meg, akkor a ; ( pontosvessző) ezt helyettesíti.

Többször   okoz  gondot   a  feleslegesen   kitett   utasítást   lezáró
pontosvesző,  erre a megfelelő helyen felhívjuk a figyelmet (lásd a for
és az if utasításoknál).


8.1.2. Értékadó utasítás
A  legalapvetőbb Pascal  utasítás  az  értékadás,  amely  áll  egy  bal
oldalból  és egy  jobb oldalból,  a két  oldalt az  értékadás jele a :=
(kettőspont egyenlő) köti össze.
A  bal oldalon  csak változó  állhat, a  jobb oldalon  állhat konstans,
változó  és kifejezés.  A konstans,  a változó  valamint  a  kiértékelt
kifejezés  egyetlen értéket képvisel, melyet a bal oldalon lévő változó
vesz  fel. Ezt  az értéket  pillanatnyi értéknek  is nevezzük, hiszen a
változó értékét bármikor felülírhatjuk.
Az értékadó utasítás formája:

     bal oldal := jobb oldal;
vagyis
     változó   := konstans;
     változó   := változó;
     változó   := kifejezés;

Például:
     x:=3.5;             { konstans , az x pillanatnyi tartalma 3.5 }
     y:=w;               { változó   }
     z:=x*y+sqr(x);      { kifejezés }
     x:=x+1;             {  az x  pillanatnyi tartalma 4.5-re változott
}
8.1.2.1. Aritmetikai értékadás
Először  foglalkozzunk  az  aritmetikai  értékadással.  Az  aritmetikai
értékadásnál  a változó numerikus értéket vesz fel. Egy változó, kivéve
a  boolean változót  perifériáról (klaviatúráról,  lemez file-ból) való
beolvasással is kaphat értéket.

Gyakorlat:  Legyen a  feladat két  szám számtani  és mértani  közepének
kiszámítása.
Az a és b számtani középértéke:
     {EMBED Equation |}

Az a és b mértani középértéke:

     {EMBED Equation |}

A  feladat megoldásához meg kell határoznunk a változók típusát. Ha azt
akarjuk,  hogy az  a és  a b  változó egész  és valós számokat egyaránt
tartalmazzon,  akkor real  típusként kell  deklarálnunk. Az  szk és  mk
változók  az osztás  és a  gyökvonás miatt  mindenképpen real  típusúak
lesznek. A program az adatokat a billentyűzetről olvassa be.

Futtassuk le az ERTEK1.PAS programot:

     program ertekadas1;
     var
          a,b,szk,mk: real;
     begin
          write('1. szam: '); readln(a);
          write('2. szam: '); readln(b);
          szk:=(a+b)/2;
          mk:=sqrt(a*b);
          writeln('Szamtani kozepe: ',szk:6:1);
          writeln('Mertani kozepe : ',mk:6:1);
     end.




A program futási képernyője:
     1. szam: 9
     2. szam: 4
     Szamtani kozepe:     6.5      
     Mertani kozepe :     6.0

A  program tervezésénél  felhívjuk a  figyelmet arra,  hogy a  változók
típusának  a meghatározásánál  át kell  gondolni, hogy milyen értékeket
vehetnek  fel a változók és a műveletek következtében az értékekhatárok
hogyan  alakulnak a  program futása  során. Hiszen  a változó típusától
függ, hogy a benne tárolt számérték milyen nagyságrendű lehet.

Például,  ha a v változó típusa integer, akkor az alábbi programrészlet
hibátlanul működik:

     var
          v: integer;
     begin
          v:= 500;
     end.

De hibás az alábbi programrészlet:

     var
          v: integer;
     begin
          v:= 42589;
     end.

mert  az integer  2 byte-ban tárolja a számértéket és ezért a v változó
csak
-32768 és 32767 között vehet fel értéket.

Ha  tudjuk, hogy  a változó  csak pozitív értéket fog tárolni és értéke
nem  lesz nagyobb  a futás  során 65535-nél, akkor helyesen járunk el a
programrészlet módosításával:
     var
          v: word;
     begin
          v:= 42589;
     end.
Ha  azonban előfordulhat  az, hogy  negatív lesz a v tartalma és a szám
nagysága  meghaladja a  2 byte  ábrázolási képességét, akkor módosítani
kell a változat deklarációját:

     var
          v: longint;
     begin
          v:=-42589;
     end.

Nézzük meg az alábbi programrészletet:

     var
          v1,v2: word;
          ered1: longint;
     begin
          v1:=42589;
          v2:=37242;
          eredm1:=v1+v2;
     end.

Láthatjuk,  hogy a  v1 és v2 változók ugyan alkalmasak a számkonstansok
tárolására,  de az  összegük már  nem fér  el a word típusú változóban,
ezért az eredm1 csak longint lehet.

Gyakorlat: Két változó tartalmának felcserélése

A  programok írása  során gyakran  szükség van  két  változó  értékének
felcserélésére.   Ennek  leggyakoribb példája a számok nagyság szerinti
sorba-rendezése,   hiszen  ez   igazából  a  számok  felcserélésének  a
sorozata.  Legyen a két felcserélendő változó neve x és y. A felcserélő
utasítás  nincs a  Pascal-ban, így  csak értékadással  tudjuk a  cserét
megvalósítani. Ha például a felcserélést az
          x:=y;
utasítással  kezdjük, akkor  mind a két változó értéke meg fog egyezni,
mégpedig  mindkét változó  értéke y  értéke lesz,  az x  eredeti értéke
pedig elvész. Az előbbiek értelmében a
          y:=x;
utasítást már felesleges is kiadni, hiszen nem történik változás.
Nézzük  meg ezt konkrét számokkal. Legyen x értéke 5, y értéke pedig 3.
Az  első utasítás  hatására (x:=y)  mind az x, mind az y értéke 3 lesz,
ezután  az y:=x;  utasítás az  y értékét 3-ról 3-ra változtatja. Ez így
tehát nem oldja meg a problémánkat. Gondoljuk végig, hogy hol a hiba…

A  hiba az  értékadás definíciójában rejlik, mivel a bal oldali változó
felveszi  a jobb  oldalon álló konstans, változó vagy kifejezés értékét
és a korábbi tartalma elvész.

A  megoldás tehát  az, hogy  a bal  oldalon lévő  változó  tartalmát  a
felülírás  előtt ki  kell menteni.  Ehhez egy  harmadik változóra,  ún.
munkarekeszre   van  szükség.  Legyen  a  segéd  változónk  id.  Az  id
változóba  mentsük ki  az x  tartalmát, utána  már felülírhatjuk  az  y
tartalmával,  majd ezután  az  y  felveszi  az  id  által  megőrzött  x
értéket.

Nézzük  meg a  programban, hogyan  változnak  a  változók  tartalma.  A
változók  értékét a program melletti táblázat mutatja olyan módon, hogy
a  táblázatban az adott sorban lévő utasítás végrehajtása utáni értékek
vannak.
A  táblázatban lévő  "-" jel  jelenti,  hogy  a  változónak  még  nincs
értéke.

     program csere;
     var
          x,y,id : integer;                       x    y    id
     begin
          x:=5;                                   5    -    -
          y:=3;                                   5    3    -
          writeln('x : ',x,'  y : ',y); 
          id:=x;                                  5    3    5
          x:=y;                                   3    3    5
          y:=id;                                  3    5    5
          writeln('A csere utan  x: ',x,' y: ',y);
     end.

A  CSERE.PAS program eredménye:

     x : 5  y : 3
     A csere utan x: 3 y: 5
     
Ezzel  a három  utasítással fel  tudtuk cserélni a két változó értékét,
de ez segédváltozó használata nélkül nem sikerült volna.
     
          
8.1.2.2. Logikai értékadás
Boolean  típusú változók true (igaz) vagy false (hamis) logikai értéket
vehetnek  fel. A  logikai értékadásnál  a bal  oldalon  boolean  típusú
változó  áll és  a jobb oldalon pedig boolean konstans, boolean változó
vagy  boolean kifejezés  állhat, amely  reláció is lehet, mert annak az
eredménye szintén boolean értéket ad.

Mint  már említettük,  a boolean változók perifériáról, tehát a read és
readln utasításokkal nem kaphatnak értéket.
Futtassuk le a LOG1.PAS programot:

     program logikai_ertekadas;
     var
                              i,j   : integer;
          b1,b2,b3,b4,b5,b6,b7,b8  : boolean;
     begin
          i :=  2;
          j :=  5;
          b1:= true;
          b2:= false;
          b3:= i < j;
          b4:= b1 and b2;
          b5:= b2 or b1 and b3;
          b6:= b1;
          b7:= (i =3) or (j > 3);
          b8:= (b1 or b2) and (j+2 < i*3);
          writeln('b3: ',b3,' b4: ',b4,' b5: ',b5);
          writeln('b6: ',b6,' b7: ',b7,' b8: ',b8);
     end.

A futási eredmény a következő:

b3: TRUE b4: FALSE b5: TRUE
b6: TRUE b7: TRUE b8: FALSE

Értékeljük ki az eredményt:

A b3 értéke true, mert 2< 5 reláció igaz.
A  b4 értéke  false, mert  az and  művelet bal  oldalán lévő b2 változó
false.
A  b5 értéke true, mert a b1 and b3 igaz, mivel a jobb és a bal oldalon
lévő  logikai változó igaz és az or művelet jobb oldali eredménye igaz,
így a végeredmény is igaz.
A b6 értéke true, mert a b1 tartalma true volt.
A  b7 értéke  true, mert  az or  művelet jobb  oldalán  a  j>3  reláció
teljesült.
A  b8 értéke  false, mert  az and  művelet bal oldalán a reláció értéke
nem teljesült.


8.1.3. Goto utasítás
A   goto  utasítás   feltétel  nélküli   vezérlésátadást  valósít  meg.
Gyakorlatilag  a Pascal-ban  szinte mindig  el  lehet  kerülni  a  goto
utasítás   használatát.  A   gyakorlott  Pascal   programozók  nem   is
használják.  Akkor szép egy Pascal program felépítése, ha nem tartalmaz
goto utasítást, amely a programot áttekinthetetlenné teszi.
A  goto hatásköre az adott blokkon belül érvényes, blokkba beugrani nem
szabad,  de blokkból  kiugrani lehet.  Nem lehet  kiugrani  függvényből
vagy eljárásból.

     program cimke;
     label ide, ki;
     begin  { A blokk }
          ...
          begin { B blokk }
               ...
               goto ide;
               ...
     ide:     ...
          goto ki;
           ...
          end;
     ki:    ...
     end.





8.1.4. Eljáráshívás

Az  eljárást a  nevével és  az aktuális  paramétereivel  hívjuk.  A  9.
fejezet   foglalkozik  részletesen   az   eljárások   készítésével   és
aktiválásával.
Például  az olvas  eljárás a háromszög oldalainak (a,b,c) ad értéket, a
kerulet   eljárás  pedig  az  adott  oldalakból  (a,b,c)  kiszámítja  a
háromszög kerületét (ker).
Az eljárások hívása a következő:

     olvas(a,b,c);
     kerulet(a,b,c,ker);



8.2. Struktúrtált utasítások

8.2.1. A blokk utasítás
A  begin és  end kulcsszavak  közötti  utasítások  sorozatát  összetett
utasításnak,  blokknak nevezzük. Azon Pascal utasítások esetén, amelyek
csak  egy utasítást tudnak végrehajtani, fontos az egynél több utasítás
összefogása egyetlen utasítássá a begin és end használatával.


8.2.2. Feltételes utasítások
A  feltételes utasítások  segítségével  a  programokban  lehetőség  van
bizonyos  feltételek teljesülése  esetén egy  utasítás  vagy  akár  egy
programrészlet   végrehajtására.  A   Pascal-ban  ilyenfajta  műveletek
elvégzésére szolgál az if utasítás.


8.2.2.1. If utasítás
Az  if utasítás  kétirányú, feltételes  elágazást  hajt  végre.  Az  if
utasítás általános formája:

     if logikai kifejezés then utasítás1 else utasítás2;

Az  if után  logikai változó vagy logikai kifejezés állhat, amelynek az
teljesülésétől  függ, hogy  melyik utasítás  kerül végrehajtásra.  Ha a
feltétel  igaz (true),  akkor a then utáni utasítás1 fog végrehajtódni,
ha  a feltétel  hamis (false),  akkor az  else  utáni  utasítás2  kerül
végrehajtásra.  Az if  szerkezetet ;  zárja, az  else elé  viszont  nem
szabad pontosvesszőt tenni.


{EMBED MSDraw   \* mergeformat|}


                  8.2.  ábra Az if then ... else utasítás


Ha  akár a  then vagy  akár az  else után egynél több utasítást akarunk
elhelyezni,  akkor az  utasításokat utasítás zárójelben, tehát begin és
end  közé kell  tenni. Œgy  a feltételes  utasítás a  then ill. az else
után egyetlen blokként fogja azokat végrehajtani.

     if logikai kifejezés then
                            begin
                                  utasítás1;
                                  ...
                                  utasításn;
                             end
                         else
                            begin
                                  utasítás1;
                                  ...
                                  utasításn;
                             end;


A  feltételes utasítás  egyszerűbb formája  az,  amikor  a  feltételtől
függően  egyszerűen csak  végre kívánjuk hajtani vagy át akarjuk ugrani
a megadott utasítást, vagy utasítás blokkot. Ez esetben az if formája:

     if logikai kifejezés then utasítás1;
     kovetkezo utasítás;
vagy
     if logikai kifejezés then
                            begin
                                  utasítás1;
                                    ...
                                  utasításn;
                             end;
     következő utasítás;




{EMBED MSDraw   \* mergeformat|}


                    8.3. ábra If then utasítás

Nézzük  meg az  If  utasítás  használatát,  futtassuk  le  a  FELT1.PAS
programot különböző adatokkal.

     program feltetel1;
     var
          x,y,s : integer;
     begin
          write('x : '); readln(x);
          write('y : '); readln(y);
          if (x < y) then
                         writeln('x : ',x,' a kisebb ertek')
                    else
                         writeln('y : ',y,' a kisebb ertek');
          if (x < y) and (y <>10) then
                                  begin
                                    s:= x + y;
                                    writeln(' x+y : ',s);
                                  end;
          if (x > y) or (x-y < 0) then
                        begin
                         inc(x); dec(y);
                         writeln('x novelt erteke     : 'x);
                         writeln('y csokkentett erteke: ',y);
                       end;
          if (x mod y = 0) then
                           writeln(x,' oszthato 'y)
                         else
                           writeln(x,' nem oszthato ',y);
     end.      

A program eredményei
Első futtatás:

     x : 4
     y : 8
     x : 4 a kisebb ertek
      x+y : 12
     x novelt erteke     : 5
     y csokkentett erteke: 7
     5 nem oszthato 7

Második futtatás:

     x : 7
     y : 3
     y : 3 a kisebb ertek
     x novelt erteke     : 8
     y csokkentett erteke: 2
     8 oszthato 2

Az  if utasításokat  egymásba  is  lehet  ágyazni,  ezt  mutatja  be  a
FELT2.PAS program:
     program feltetel2;
     var
          t : real;
     begin
          writeln('A viz halmazallapotanak vizsgalata');
          write('homerseklet : '); readln(t);     
          if (t > 0) then
                     begin
                       if (t >= 100) then writeln('goz ')
                                   else writeln('viz ');
                     end
                    else writeln('jeg');
     end.                




A program futtatási eredményei:

     A viz halmazallapotanak vizsgalata
     homerseklet : -1
     jeg

     A viz halmazallapotanak vizsgalata
     homerseklet : 12
     viz

Az  if ..  then ..  else ..  if  utasítás  használatára  nézzük  meg  a
FELT3.PAS programot:

     program feltetel3;
     var
          pont: 0 .. 100;
     begin
          writeln('0 es 100 kozotti pontok osztalyzata');
          write('Az elert pontszam: '); readln(pont);
          write('A dolgozat osztalyzata: ');
          if pont= 0 then writeln('Ervenytelen')
                      else
                      if pont<50 then writeln('elegtelen')
                      else
                      if pont<60 then writeln('elegseges')
                     else
                     if pont<70 then writeln('kozepes')
                     else
                     if pont<89 then writeln('jo')
                     else writeln('jeles');
     end.

A program futtatási eredményei:

0 es 100 kozotti pontok osztalyzata
Az elert pontszam: 92
A dolgozat osztalyzata: jeles

0 es 100 kozotti pontok osztalyzata
Az elert pontszam: 88
A dolgozat osztalyzata: jó



               
8.2.2.2. Case utasítás
A   case  utasítással   könnyen  megoldhatjuk   programunk   többirányú
elágaztatását.  A case  utasítás tartalmaz  a case  kulcsszó után  álló
szelektort,  amelyet az  of kulcsszó  zár. Ezt követi egy vagy több ún.
case  konstans és  a hozzátartozó utasítás vagy utasítások és végül nem
kötelezően egy else ág. A case utasítást az end zárja.

Gyakori  hiba a  kezdő programozóknál,  hogy a  case utasítás  miatt  a
program  gyakran "end  hibás",  mivel  a  case  utasítást  záró  end-et
általában kifelejtik.
A case utasítás általános formája:

     case  szelektor of
       cimke1:      utasítás1;
          ...
       cimken:      utasításn;
         else:      utasításm;
     end;

A   szelektor  csak   sorszámozott  típusú  lehet.  A  case  constansok
típusának  meg kell  egyeznie a szelektor típusával. Azon utasítás vagy
utasítások  kerülnek végrehajtásra,  amelyeknek a  cimkéje megegyezik a
szelektor  értékével, ha  nincs ilyen  címke, az  else  utáni  utasítás
kerül végrehajtásra.
A VALASZT1.PAS programban a case szelektora egész szám.

     program valaszt1;
     var  jegy: integer;
     begin
          write('Kerem az erdemjegyet: '); readln(jegy);
          write('A vizsga eredmenye: ');
            case jegy of
               1:   writeln(' elegtelen');
               2:   writeln(' elegseges')'
               3:   writeln(' kozepes');
               4:   writeln(' jo');
               5:   writeln(' jeles');
            else   writeln(' Hibas erdemjegy);
           end;
     end.
{EMBED MSDraw   \* mergeformat|}

               8.4. ábra A case utasítás folyamatábrája
A VALASZT2.PAS programban a case szelektora karakter.

     program valaszt2;
     var
          kod  : char;
          aru  : string;
     begin
          writeln('Az aru minositese kituno(k), ',
          'jo(j),megfelelo(m)');
          write('Az aru megnevezese: '); readln(aru);
          write('A minosites kodja : '); readln(kod);
          writeln;
          write(aru,' minositese: ');
          case kod of
             'K','k':    writeln('kituno');
             'J','j' :   writeln('jo');
             'M','m':   writeln('megfelelt');
          else
               writelen('hibas adat');
          end;
     end.

A VALASZT3.PAS programban a case szelektora résztartomány típusú.

     program valaszt3;
     var
          pont: 0 .. 100;
     begin
          writeln('0 - 100 kozotti pontok osztalyzata');
          write('Az elert pontszam: '); readln(pont);
          write('A dolgozat osztalyzata: ');
          case pont of
             90..100 : writeln(' jeles');
             70.. 89 : writeln(' jo');
             60.. 69 : writeln(' Kozepes');
             50.. 59 : writeln(' elegseges');
             0..  49 : writeln(' elegtelen');
            else     writeln(' Hibas adat…');     
          end;
     end.
     

8.2.3. Ciklusutasítások
A  programban gyakran  van szükség  utasítások ismételt végrehajtására.
Az   ilyen  feladatok  megoldására  szolgálnak  a  ciklusutasítások.  A
Pascalban  három ciklusutasítás  használható. Ha ismerjük az ismétlések
számát,  akkor  a  for  utasítást  használjuk,  máskülönben  valamilyen
feltétel vezéli a ciklust a while és a repeat  until utasításokban.

8.2.3.1. For utasítás
A  for ciklusutasítást akkor használhatjuk, amikor pontosan ismerjük az
ismétlések  darabszámát, így  a ciklusmagot  egy meghatározott számszor
végrehajtjuk.  A for  ciklust kétféleképpen  lehet  használni,  az  ún.
növekvő  ciklus esetén a ciklus változója adott kezdőértéktől egyesével
növeszik  a to  kulcsszó használatakor  és  csökkenő  ciklus  esetén  a
ciklus  változója egyesével  csökken downto  kulcsszó esetén  az  adott
végértékig   és  mindannyiszor   végrehajtja  a   ciklusmagot.  A   for
ciklusutasítás   csak  egyetlen   utasítás  végrehajtására  vontakozik.
Példaként a for utasítás alakja növekvő ciklus esetén :
     for ciklusváltozó:=kezdőérték to végérték do
         ciklusmag ( egy utasítás);

A for utasítás alakja csökkenő ciklus esetén :

     for ciklusváltozó:=kezdőérték downto végérték do
         ciklusmag ( egy utasítás);

A növekvő cilklus esetén
          kezdőérték < végérték

a csökkenő ciklus esetén
          kezdőérték > végérték

feltétel   esetén  indul   el  a  ciklusmag  végrehajtása,  különben  a
ciklusmag egyszer sem lesz végrehajtva.
Gyakori  hiba  a  ciklus  végértéke  után  a  do  kulcsszó  megadásának
elfelejtése.

{EMBED MSDraw   \* mergeformat|}

               8.5. ábra A for utasítás folyamatábrája.
Ha  egynél több  utasítást akarunk  ciklusban végrehajtani, akkor begin
end utasítás zárójelet kell alkalmazni:

     for ciklusváltozó:=kezdőérték to végérték do
         begin
              utasítás1;
                ...
              utasításn;
           end;

A    for  ciklusváltozó:=kezdőérték to  végérték do ; utasítás; tipikus
esete  az üres  utasításnak, mert a ciklus üresen fut le, és a do utáni
utasítás csak egyszer hajtódik végre.

Példaként adjuk össze az első húsz egész számot.

     program for_ciklus;
     var
          szam,osszeg: integer;
     begin
          osszeg:=0;
          for szam:=1 to 20 do
               osszeg:=osszeg+szam;
          writeln('Az osszeg for ciklussal: ',osszeg);
     end.

A futtatás eredménye:

Az osszeg for ciklussal: 210

A  ciklusváltozó csak  sorszámozott típusú  lehet. Általános  esetben a
ciklusváltozó   növekvő  léptetése  a  succ  függvény  szerint,  míg  a
csökkenő léptetése a pred függvény szerint történik.

     var
          a: (hetfo, kedd, szerda, csutortok, pentek, szombat,        
vasarnap);
     begin
          for a:=hetfo to szombat do
            ...

     type
          betu='a'.. 'z';
     var
          i: betu;
     begin
          for i:='a' to 'z' do
           ...


8.2.3.2. While utasítás
A  while utasítás  tartalmaz egy  logikai kifejezést,  amely vezérli az
ismételt utasítások végrehajtását. A while utasítás formája:

     while logikai kifejezés do
            utasítás1;

Ennél  a ciklusfajtánál  a logikai  kifejezés a  ciklusmag végrehajtása
előtt  kerül kiértékelésre.  Ha a  logikai  kifejezés  hamis,  akkor  a
ciklus  egyszer sem hajtódik végre. A logikai kifejezést ezért belépési
feltételnek  is hívjuk.   Az  egyetlen utasításból álló ciklusmag addig
kerül  végrehajtásra, amíg  a logikai  kifejezés  igaz,  amint  hamissá
válik, a ciklus befejezi a működését.

Egynél  több utasítás  ciklusban történő  végrehajtása esetén begin-end
utasítás zárójelet kell alkalmazni

     while logikai kifejezés do
            begin
                utasítás1;
                    ...
                  utasításn
             end;             
{EMBED MSDraw   \* mergeformat|}
               8.6. ábra A while ciklus folyamatábrája

Adjuk össsze az első húsz egész számot.

program while_ciklus;
     var
          szam, osszeg: integer;
     begin
          szam:=1;
          osszeg:=0;
          while szam < 21 do
            begin
               osszeg:=osszeg+ szam;
               szam:=szam+1;
            end.
     writeln('Az osszeg while ciklussal: ', osszeg);
     end.

A futtatás eredménye:
Az osszeg while ciklussal: 210


8.2.3.3. Repeat utasítás
A  repeat utasítás  tartalmaz egy  logikai kifejezést,  amely a  ciklus
végrehajtását   vezérli.  A  repeat-until  között  megadott  utasítások
ismételten   hajtódnak  végre.  Egyszer  mindenképpen  végrehajtódik  a
ciklus,  mivel a  logikai kifejezés  csak az  egyszeri végrehajtás után
kerül  kiértékelésre. A  ciklusmag addig hajtódik végre, amíg a logikai
kifejezés  hamis, és  akkor fejeződik  be, amikor  a logikai  kifejezés
igazzá  válik.  Ebben  az  esetben  a  logikai  kifejezést  a  kilépési
feltételnek hívjuk.
A repeat utasítás általános alakja:

     repeat
          ciklusmag;
       until  logikai kifejezés;

A  ciklusmag több  utasításból is állhat, itt nincs szükség a begin-end
utasítás zárójelre, mert a repeat-until kulcsszavak helyettesítik azt.

Adjuk össsze az első húsz egész számot.

     program repeat_ciklus;
     var
          szam, osszeg: integer;
     begin
          szam:=1; osszeg:=0;
          repeat
               osszeg:=osszeg+ szam;
               szam:=szam+1;
          until szam = 21;
         writeln('Az osszeg repeat ciklussal: ', osszeg);
     end.

A futtatás eredménye:
Az osszeg repeat ciklussal: 210
{EMBED MSDraw   \* mergeformat|}

             8.7. ábra A repeat-until ciklus folyamatábrája



8.2.4. With utasítás
A  with utasítással  egyszerűbben adhatunk  rekordnak értéket,  mivel a
rekord  mezeire, mint  egyedülálló változókra  hivatkozhatunk.  A  with
utasítás általános formája:

     with rekord_változó do utasítás;

Az utasítás tetszőleges egyszerű vagy struktúrált utasítás lehet.

Annyival  rövidebb egy rekord megadási módja, hogy a with után megadott
rekord_változó  nevét és a pontot a do után nem kell újra kiírni, hanem
elegendő csak a mezőneveit megadni.

Az WITH_PR.PAS program bemutatja a with használatát:

program with_pr;
type
    datum = record
              ev    : integer;
              honap : 1..12;
              nap   : 1..31;
              megjegyzes: string;
           end;
var
     szul_nap, mai_nap, holnap: datum;
begin
     with szul_nap do
     begin
         ev    := 1974;
         honap := 3;
         nap   := 13;
         megjegyzes := 'szuletesnap';
    end; { with }
    writeln('Szuletesi datum: ',szul_nap.ev,' ',
             szul_nap.honap,' ',szul_nap.nap);
    writeln('Mai nap datuma ');
     write('Ev   : '); readln(mai_nap.ev);
    write('Honap( 1..12): '); readln(mai_nap.honap);
    write('nap (1..31): '); readln(mai_nap.nap);
    write('megjegyzes: '); readln(mai_nap.megjegyzes);

    holnap.ev := mai_nap.ev;
    holnap.honap:= mai_nap.honap;
    holnap.nap:= 1;
    write('Holnapi datum: ',holnap.ev,' ',
           holnap.honap,' ',holnap.nap);
end.

Két azonos típusú rekord közötti értékadás lehet mezőnként:

     holnap.ev := mai_nap.ev;
     holnap.honap := mai_nap.honap;

Lehet egyszerre az összes mezőnek adni értéket:
     holnap := mai_nap;

Bonyolultabb,  úgynevezett variálható  rekordokat is  létrehozhatunk  a
case utasítás beépítésével.

with  kulcsszó után  több rekordváltozót  is felsorolhatunk, mindaddig,
amíg ez nem vezet a kétértelműségre.

A VARI_REK.PAS a variálható rekordra mutat példát:

program varians_rekord;
type
    sikidom=(teglalap, negyzet, kor);
    alakzat = record
               case fajta: sikidom of
                 teglalap: (szelesseg, magassag : real);
                 negyzet:  (oldal : real);
                 kor:      (sugar: real);
              end;

var
   g: alakzat;
   tipus: sikidom;
   sz,m,l,r,ter: real;

begin
   writeln('Az alakzat tipusa: ');
   for tipus:=teglalap to kor do
    begin
     g.fajta:=tipus;
     with g do
      case fajta of
           teglalap : begin
                        writeln;
                        writeln('TEGLALAP');
                        write('A teglalap szelessege: ');                  
          readln(sz);
                        write('A teglalap magassaga : ');                  
          readln(m);
                        szelesseg:=sz; magassag:=m;
                      end;

           negyzet  : begin
                        writeln;
                        writeln('NEGYZET');
                        write('A negyzet oldala  : ');                     
               readln(l);
                        oldal:=l;
                      end;
           kor      : begin
                        writeln;
                        writeln('KOR');
                        write('A kor sugara  : '); readln(r);
                        sugar:=r;
                      end;
           end;
      with g do
        case fajta of
           teglalap: begin
                      ter:=szelesseg*magassag;
                      writeln('A teglalap terulete : ',ter:10);
                    end;
           negyzet: begin
                      ter:=oldal*oldal;
                      writeln('A negyzet terulete: ',ter:10);
                    end;
           kor:     begin
                      ter:=r*r*pi;
                      writeln('A kor terulete: ', ter:10);
                   end;
        end;
     end;
 end.

A program futási eredménye:

Az alakzat tipusa:

TEGLALAP
A teglalap szelessege: 3
A teglalap magassaga : 4
A teglalap terulete  : 1.200E+01

NEGYZET
A negyzet oldala  : 5
A negyzet terulete: 2.500E+01

KOR
A kor sugara  : 6
A kor terulete: 1.131E+02
Ellenőrző kérdések:

 1.  Mit nevezünk összetett utasításnak?
 2.  Miért  szükséges egynél  több utasítás  össszefogás a  begin   end
utasításokkal?
 3.  Mire szolgálnak a feltételes utasítások?
 4.  Hány fajta feltételes utasítás van?
 5.  Mi az if utasítás általános alakja?
 6.  Az if utasításban hová nem szabad pontosvesszőt tenni?
 7.  Ha  a then  vagy az  else ágban  egy  utasításnál  több  utasítást
szeretnénk     végrehajtani, mit kell tenni?
 8.  Melyik utasítással oldhatjuk meg a többirányú elágaztatást?
 9.  Mit jelent a case utasításban az else kulcsszó használata?
10.  Utasítások ismételt végrehajtását mivel oldhatjuk meg?
11.  Mikor alkalmazhatjuk a for utasítást?
12.  Milyennek kell lenni a feltételnek a while típusú ciklusnál?
13.  A  feltételnek mire kell változnia ahhoz, hogy a while a működését
befejezze?
14.  A repeat ciklusnál hol történik a feltétel vizsgálata?
15.  Milyennek   kell  lennie  a  feltételnek,  hogy  a  repeat  ciklus
működjön?
16.  A  feltételnek mire  kell változnia  ahhoz, hogy a repeat ciklus a
működését      befejezze?

Feladatok

 1.  Olvassa  be  a  téglatest  adatait  és  számítsa  ki  a  téglatest
felszínét és        térfogatát. (TEGLA.PAS)

 2.  Számítsa   ki  az   első  n  négyzetszám  összegét.  Az  n  értéke
konstansként legyen 100. (NEGYZET.PAS)

 3.  n  darab egész számot egy tömbbe olvasson be és vizsgálja meg hány
eleme negatív, nulla és pozitív. (CIKLUS6.PAS)

 4.  n  darab egész  számot egy  tömbbe olvasson  be, számolja meg hány
páros  és páratlan eleme van a tömbnek és hány eleme osztható hárommal.
(CIKLUS7.PAS)
 5.  Max.  30 egész  adat közül  számolja meg  mennyi eleme esik 1..10,
11..100, 101..1000 közé és >1000 fölé. (CASE1.PAS)

 6.  Max.  30 tanuló nevének és megtakarított pénzének nyilvántartására
írjon  programot, az adatokat táblázat formájában írja vissza, valamint
számítsa ki osztálypénz összegét. (CIKLUS51.PAS)

 7.  Készítsen  egy egyszerű  kalkulátor programot,  amely az  adatokat
művelet  szám1 szám2  alakban várja.  A programból  e betűvel  lehessen
kilépni. (CASEPLD.PAS)

 8.  Olvasson be max. 4 jegyű számot és írja ki fordítva. (FORDIT.PAS)

 9.  Irjon   egy  programot,   amely  0   és  100  között  generál  egy
véletlenszámot.  A program  párbeszédes formában kérdezzen a számra, és
segítségül  jelezze, hogy  a kapott  szám kevés  vagy sok a kitalálandó
számhoz  képest. A  lépéseket számlálja,  amelyet a  szám kitalálásakor
írja vissza. (JATEK.PAS)


10.  n  darab kockadobásból  számolja meg, mennyi 1,2,3,4,5 és 6 volt a
dobás értéke. (KOCKA.PAS)

11.  mm-ben megadott távolságot számítson át m, cm és mm-re.     (MM_M
.PAS)

12.  Másodpercben megadott időt számítson át óra, perc, másodpercre.
     (ORA.PAS)

13.  Œrjon  egy öröknaptár  programot, amely  egy  dátumról  megmondja,
hogy melyik napra esik. (OROKNAP.PAS)

14.  A  'Ma szep  ido  van'  szövegben  a  üres  helyet  *  karakterrel
helyettesítse. (POSPR.PAS)

15.  Irjon programot, amely egy dátumról megmondja, hogy szökőév-e.
     (SZOKO.PAS)

16.  1-től kétezerig írja fel a római számokat. (ROMAI.PAS)

17.  Irjunk programot, amely beolvas egy mondatot.
     Például: Ma szep ido van.
     Visszaírja: Mava szevep ividovo vavan.
     Tehát a magánhangzó esetében v betűvel megismétli a magánhangzót:
     i -> ivi, o -> ovo, e-> eve, a-> ava, u-> uvu
     (VAVEVI.PAS)

18.  Irjon  programot, amely az alábbi elrendezésű számhalmazt jeleníti
meg.      Maximálisan   19  sorban.   A  példa   4  sorra   vonatkozik.
(KUPASC1.PAS)

                         1
                    2         2
               3         3         3
          4         4         4         4

19.  Irjon  programot, amely az alábbi elrendezésű számhalmazt jeleníti
meg.      Maximálisan   20  sorban.   A  példa   4  sorra   vonatkozik.
(KUPASC2.PAS)

     1    2    3    4
     1    2    3
     1    2
     1

20.  Irjon  ötös lottó kitöltéséhez generáló programot. A lottószámokat
          bármely   billentyű  lenyomására  jelenítse  meg  a  program,
kilépés az ESC      billentyűvel történjen. (LOTTO.PAS)

21.  Személyi  adatok tárolására  készítsen rekordot.  Irjon programot,
amely     ilyen  típusú elemekből  álló tömböt  feltölt, illetve  adott
elemét listázza.    (REKORD2.PAS).

22.  Értékelje ki a REKORD1.PAS programot, amely adott szempontok     
alapján válogatást végez a rekordtömb elemei között.   

23.  Először értékelje ki, majd futtassa le a SETPR.PAS programot.