Szelekciós utasítasok

Szelekciós utasítások

Egyszerûbb programok esetében a program felépítése általában úgy alakul, hogy elegendõ a programsorok egymás utáni végrehajtása, nem szükséges döntési szerkezetet alkalmaznunk, legtöbbször a ciklusokra sincs szükségünk. Egy egyszerû program lehet a következõ:

Számítsuk ki egy A oldalhosszúságú négyzet kerületét és területét:

Var A: Integer;
Begin
    Writeln('A negyzet oldala: ');
    Readln(A);
    Writeln('A negyzet kerulete: ', 4*A);
    Writeln('A negyzet terulete: ', A*A);
End.

A program nagyon szepen mûködik, amíg a felhasználó helyes adatokat ad meg a négyzet oldalaként, de amint nem megfelelõ adattal próbál dolgozni (pld.: A négyzet oldala: -4), a program nem az elvárható módon fog reagálni (pld.: helytelen eredményt ad, futási hibával leáll, stb). Valamilyen módon ezeket a hibákat ki kellene küszöbölni, méghozzá feltételes szerkezetek, ellenõrzések beiktatásával, amelyek képesek lekezelni a felhasználó által okozott problémákat, mert a programnak nem lenne kötelezõ elszállni, ha egy szám helyett egy betût gépelünk be.

A fentiekbõl lá 616b12g tható, hogy minden magasszintû programozási nyelvnek részét képezik a feltételes szerkezetek, a szelekciós utasítások. A Pascal nyelv kétféle feltételes utasítást tartalmaz:
az If ... then ... else ...; utasítás kétirányú elágaztatást biztosít egy feltétel teljesülésétõl függõen,
a Case ... of utasítás többirányú elágazást (ún. esetszétválasztást) tesz lehetõvé.
 

Az If ... then ... else; utasítás:

Az utasítás kétirányú elágazást tesz lehetõvé, egy feltételtõl függõen a program végrehajtása két irányban folytatódhat, a feltételtõl függõen bizonyos tevékenységeket végrehajthatunk, vagy kihagyhatunk programunk során. Az utasítás szintaktikája:

If feltétel
    then utasítás1
    else utasítás2;

A feltétel határozza meg, hogy a program végrehajtása "melyik irányban halad tovább": ha a feltétel igaz, akkor az utasítás1, ha hamis az utasítás2 fog lefutni. Minden esetben érvényes, hogy csak az egyik ágon található utasítások kerülnek végrehajtásra, tehát ha a feltétel igaz volt, csak az utasítás1 kerül feldolgozásra, utasítás2-t a fordító figyelmen kívül hagyja. A megfelelõ utasítások végrehajtása után a program a feltételes szerkezet után következõ elsõ utasításnál folytatódik. Az If utasítás feltétele lehet egy logikai kifejezés vagy egy logikai tipusú változó is, felváltva alkalmazzuk mindkettõt (a ciklusoktól eltérõen, ahol egyértelmûen gyakoribb a kifejezés). Ha az If utasítás valamelyik ágában több utasítást szeretnénk elhelyezni, akkor ezt a Begin ... End; foglalt szavak segítségével oldhatjuk meg. Fontos, hogy az igaz (then) ág lezárása után nem szabad pontosvesszõt tenni, amennyiben azt még egy hamis (else) ág is követi (fordítási hibát okoz).

Az If utasítás másik gyakran alkalmazott formája, amikor a hamis (else) ágat elhagyjuk. Ebben az esetben az utasítás szintaktikája:

If feltétel
    then utasítás1;

Ennél a formánál amennyiben a feltétel teljesül, akkor az utasítás1 végrehajtásra kerül, egyébként az utasítás1-et figyelmen kívül hagyva folytatódik a program végrehajtása a feltételes szerkezet után következõ elsõ utasítással.

Talán ritkábban alkalmazott formája az If utasításnak, amikor azt szeretnénk elérni, hogy az utasítás2 akkor kerüljön végrehajtásra, ha a feltétel nem teljesül. A megoldás egyszerû: meg kell fordítani a feltételt, célszerû a not operator segítségével:

If not(feltétel)
    then utasítás2;

Ebben az esetben az utasítás2 akkor fog végrehajtásra kerülni, amennyiben a megfordított feltétel teljesül, tehát amennyiben a feltétel (változó vagy kifejezés) hamis értéket vesz fel.

A feltételes utasítások tetszõleges szintig egymásba ágyazhatók. Az egymásba ágyazásnak olyan feltételeknél van értelme, ahol a lehetõségek kizárják egymást. (pld.: Három szám közül melyik a legkisebb.)

Példák az If ... then ... else ...; utasítás alkalmazására:

Olvassunk be egy számot, majd állapítsuk meg, hogy egész szám-e:

Var A: real;
Begin
    Write('Kerek egy szamot: ');
    Readln(A);
    If A=Int(A)
        then Writeln('Egesz szam')
        else Writeln('Valos szam');
End.

Az A változót valós tipusúnak deklaráljuk, mivel valós tipusú változóban tudunk egész értéket tárolni, fordítva viszont nem. A feltétel: amennyiben az A változó értéke egyenlõ önmaga egészrészével (az Int(A) függvény egy valós szám egész részét adja vissza kerekítés nélkül), akkor egész számról van szó.
 

Olvassunk be egy egész számot, amely 1 és 10 közé esik (egyenlõség megengedett), majd állapítsuk meg, hogy páros szám-e:

Var A: Integer;
Begin
    Write('Kerek egy egesz szamot 1 es 10 kozott: ');
    Readln(A);
    If ((A=1) and (A<=10))
        then begin
            If (A mod 2)=0
                then Writeln('Paros szam')
                else Writeln('Paratlan szam');
        end
        else Writeln('A szam nem esik bele a megadott intervallumba.');
End.

A szám beolvasása után elõször azt vizsgáljuk, hogy a szám 1 és 10 közé esik-e (az AND operátor a két feltétel együttes vizsgálata miatt szükséges). Amennyiben a feltétel igaz, akkor (a then ágban) újabb vizsgálat következik, amely a szám oszthatóságára irányul. Ezalapján tudjuk eldönteni, hogy a szám páros vagy páratlan. Ha azonban a szám nem esik bele a megadott intervallumba, a hamis (else) ágban egyetlen utasítás szerepel, kiírjuk a képernyõre, hogy a beolvasott szám nem felel meg a feltételeknek.

Olvassunk be két számot, majd osszuk el az elsõt a másodikkal! Figyeljünk  a 0-val való osztásra!

Var Osztando, Oszto: Integer;
Begin
    Write('Osztando= ');
    Readln(Osztando);
    Write('Oszto= ');
    Readln(Oszto);
    If Oszto=0
        then Writeln('0-val valo osztas nincs ertelmezve')
        else Writeln('A ket szam hanyadosa: ', Osztando/Oszto:10:2);
End.

Amennyiben osztóként 0 értéket olvasunk be, az eredmény helyett egy hibaüzenetet kapunk.
 

A Case ... of ... utasítás:
 
Az utasítás lehetõvé teszi, hogy a program végrehajtása egy változó értékétõl függõen több irányban folytatódjon, illetve, ha az egyik utasításban deklarált egyik feltétel sem teljesül, akkor is meghatározható, hogy milyen utasítások fussanak le. Az utasítás szintaktikája:

Case kifejezés of
    érték_1: utasítás_1;
    érték_2: utasítás_2;
    .
    .
    .
    érték_n: utasítás_n;
    else egyéb_utasítás;
End;

A Case utasítás végrehajtása során elõször a kifejezés (változó) kerül kiértékelésre (általában változót használunk). A kifejezés értékétõl függõen a megfelelõ ág utasítása(i) kerülnek végrehajtásra, tehát ha a kifejezés értéke érték_1, akkor az utasítás_1, ha érték_2, akkor utasítás_2, stb. hajtódik végre. Ha a listában nincs felsorolva a kifejezés aktuális értéke, akkor az egyéb_utasítást fogja a program végrehajtani, amely az else ágban található. A kifejezés helyett sokszor egy változót szoktunk feltételként alkalmazni. A feltétel csak sorszámozott tipusú kifejezés vagy változó lehet. A feltételt szelektornak, a megadott értékeket esetkonstansoknak nevezzük. Az esetkonstansok és az utasítások közé pontosvesszõt kell tenni (pld.: érték_1: utasítás_1). Az esetkonstansok után egy utasítást adhatunk meg, ha több utasítást szeretnénk végrehajtani, azokat Begin ... End; foglalt szavak közé kell írni. Ha valamelyik esetkonstanshoz (az else ágra is igaz) tartozó utasítás végrehajtása megtörtént, a program a Case utasítást záró End; után folytatódik.
Az esetkonstansok, mint nevük is mutatja, konstans értékek lehetnek, tehát nem használhatunk esetkonstansként változót vagy tipizált konstanst, mivel ezek értéke a program futása során változhat. Használhatunk viszont tipusnélküli konstansokat. Ezek alkalmazása a programot szebbé teheti, nagyobb méretû programok esetén azonban áttekinthetetlenné teheti a forráskódot. Esetkonstansként gyakran kell alkalmaznunk intervallum értékeket. Ezeket a konstansokat a résztartomány tipusok deklarációja során alkalmazott módszerrel tehetjük meg. (Lásd a második példát.)
 

Olvassuk be egy szám formájában az osztályzatot, majd írjuk ki szövegesen.

Var O: Byte;
Begin
    Write('Az osztályzat (1..5): ');
    Readln(O);
    Case O of
        1: Writeln('Elégtelen');
        2: Writeln('Elégséges');
        3: Writeln('Közepes');
        4: Writeln('Jó');
        5: Writeln('Jeles');
        else Writeln('Ilyen osztályzat nincs');
    End;
End.

Olvassunk be tíz pozitív egész számot. Számoljuk meg, hogy a beolvasott számok között hány egyjegyû, kétjegyû, háromjegyû, négyjegyû, ötjegyû szám szerepelt.

Var X: Word;
       E_J, K_J, H_J, N_J, O_J: Byte;
       N: Byte;
Begin
    E_J:= 0;
    K_J:= 0;
    H_J:= 0;
    N_J:= 0;
    O_J:= 0;
    For N:= 1 to 10 do
        Begin
            Write('A(z) ', N, '. szam= ');
            Readln(X);
            Case X of
        0..9: E_J:= E_J+1;
        10..99: K_J:= K_J+1;
        100..999: H_J:= H_J+1;
        1000..9999: N_J:= N_J+1;
        10000..65535: O_J:= O_J+1;
            End;
        End;
    Writeln('A beolvasott szamok megoszlasa:');
    Writeln('Egyjegyu: ', E_J);
    Writeln('Ketjegyu: ', K_J);
    Writeln('Haromjegyu: ', H_J);
    Writeln('Negyjegyu: ', N_J);
    Writeln('Otjegyu: ', O_J);
End.

A feladat megoldásához egy ciklus és egy szelekciós utasítás kombinációját kell alkalmaznunk. A számokat nem szükséges tömbben tárolni, mert mindössze a számjegyek számának eldöntéséig van szükségünk az értékre. A különbözõ nagyságredû számok elõfordulásának számát változókban tároljuk (E_J - egyjegyû, K_J - kétjegyû, H_J - háromjegyû, N_J - négyjegyû, O_J - ötjegyû). Ezen változók értékét a ciklusba lépés elõtt le kell nullázni. Mivel tudjuk, hogy 10 számot kell beolvasnunk, célszerû a For ciklus alkalmazása. A ciklusmagon belül történik az érték beolvasása, majd kiértékelése. Megvizsgáljuk a lehetséges eseteket, és a megfelelõ változó értékét megnöveljük. Az else ág alkalmazása ebben az esetben felesleges, mert minden esetet megvizsgálunk (A hatjegyû szám begépelése már hibaellenõrzési kérdés. Egyes esetekben futási hibához, más esetekben hibás mûködés mellett tovább fut a program, de ezt más, itt nem tárgyalandó módszerekkel ki lehetne szûrni). A ciklus futása a tizedik szám beolvasása után befejezõdik. Végül kiiratjuk hogyan oszlottak meg a beolvasott számok.