A kétágú szelekciók - folytatás

Persze az egymásbaágyazás nem jelenti azt, a stuktogram szabályait ne tartanánk be, tehát nem lóghatnak át a téglalapok egymásba ! Természetesen bizonyos esetekben egyszerűsíthetô a kétágú szelekciók felépítése bizonyos logikai műveletekkel. Az egymásbágyazott kétágú szelekciókat olyan esetben lehet egyszerüsíteni ha a külsô szelekció és a második belsô szelekció igaz vagy hamisra elvégzendô tevékenysége ugyanaz. Ilyenkor a két megadott feltételt vagy-gyal kössük össze.

Vagy séma:

Létezhet olyan két egymásba ágyazott szelekció is melynek elsô hamis ága ki írja, hogy valami nem stimmel, az igaz ágában pedig a második szelekció van. A második szelekció igaz ága adja meg a jó eredményt míg a hamis az elsôhöz hasonlóan a hibát írja ki. Ekkor a két szelekció feltételét és-sel kössük össze.

Az elsô példa elrettentés célját szolgálja:

Végig vesszük a logikai műveleteket melyeket a szelekciók feltételeinek egyszerűsítésére is használhatunk:

A VAGY művelet:

• A VAGY (OR, szép magyar szóval diszjunkció) művelet eredménye akkor igaz ha legalább egyik operandusának logikai értéke igaz. Lássuk az egyszerűbb megértés végett a logikai táblázatot két operandusra, rendre A-ra és B-re:

• Az ÉS (AND, szép magyar szóval konjukció) művelet eredménye akkor és csak akkor igaz ha a résztvevô összes operandus (itt: feltétel logikai értéke) igaz.

• A NEM (NOT, szép magyar szóval negáció) művelet eredménye mindig a megadott operandusának ellenkezôje. Ellentétben a VAGY ill. ÉS művelettel, csak egy operandusa van.

• Ez a művelet nem egészen ide tartozik de elmondom elôre, hogy máskor már ne kelljen magyarázkodni:

A KIZÁRÓ VAGY (eXclusive OR) művelet eredménye akkor és csak akkor igaz ha a résztvetô operanusok közül pontosan egy igaz. Lássuk az igazság táblázatot a segítség kedvéért:

A többágú szelekciók

Ennek elkerülése végett van a több ágúszelekció, mint minden nyelv (szinte minden nyelv) egyik alap eleme.

Stuktogramm beli ábrája:

Az ábráról is egyszerűen leolvasható, hogy különbözô értékekre különbözô môdon reagál programunk. Amennyiben egyik értéket sem vette fel a vizsgált kifejezés akkor lehetôség van egy egyébként ág kialakítására.

FONTOS, hogy vizsgálat során az elemeket mind fel kell sorolni, s nem lehet olyan feltételt adni, mint pl. Egy kétágú szelekciónál, ha X < 0. Itt meg kell adni, hogy ha X: =-1, -2, -3, -4 Vagy X: [-1, -1000] intervallumban van. Az intervallum megadása is véges sok elem felsorolásával egyenértékű. Bizonyos programozási nyelvek megengedik az intervallum használatát (Pascal), míg mások nem (C, C++).

Lássunk egy példát a használatra:

kisbetű ...

Itáráció - azonos tevékenységek egymás utáni ismételése adott feltétel szerint

• Elöl- és
• Hátultesztelô ciklust

Az Elöltesztelô ciklus

Az Elöltesztelô ciklus jellemzôi:

• A ciklust irányító feltétel kiértékelése a ciklus mag lefuttatása elôtt történik ami azt jelenti, hogy nem feltétlenül biztos, hogy legalább egyszer is lefutna a ciklus magja.
• A ciklusban addig ismétlôdik a ciklusmag végrehajtása amíg a feltétel igaz, mert lefutási-feltételt adtunk - ill. kell megadnunk.
• Amennyiben a lefutási feltétel hamissá válik akkor a ciklusmag már nem hajtódik végre, hanem a futtatás kilép a ciklusból, s a ciklus utáni elsô utasítással folytatja tevékenységét.

Nézzünk egy példát ennek alkalmazására. Olvassunk be egész, elôjeles számokat és adjuk ôket össze amíg 0-t nem ütünk be.

• Látjuk elôször beolvastuk a számot. De miért ? Mert lehet, hogy valaki véletlenül indította el a programot, és rögtön indítás után ki akar lépni. Így ha 0-val kezdünk rögtön kilépünk.
• Ha nem 0-val kezdtünk akkor az osszeghez hozzádja a beolvasott számot, és újat kér be:
• ha ez nulla volt kilép a ciklusból, ha nem újból hozzáadja, és így tovább.
• Azt ugye észrevettük, hogy az elején ossz=0-t írtunk. Nos ezt azért tettük, mert kezdôértéket kell adni minden változónak elsô használat elôtt, ugyanis deklarálás után nem biztos, hogy 0-t tartalmaz. (Úgy is mondják, hogy memória szemetet tartalmaz a még nem inicializált változó.)

A Hátultesztelô ciklus

A Hátultesztelô ciklus jellemzôi:

• A ciklust irányító feltétel kiértékelése a ciklus mag lefuttatása után történik ami azt jelenti, hogy biztos, hogy legalább egyszer lefut a ciklus magja.
• A ciklusban addig ismétlôdik a ciklusmag végrehajtása amíg a kiugrási feltétel nem lesz igaz, mert kiugrási- és nem lefutási feltételt adtunk - ill. kellet megadnunk. Tehát addig teker (ismétlôdik) a ciklus amíg a feltétel hamis.
• Amennyiben a kiugrási feltétel igazzá válik akkor a ciklusmag már nem hajtódik végre, hanem a futtatás kilép a ciklusból, s a ciklus utáni elsô utasítással folytatja tevékenységét.

Nézzünk meg az elôzô példát átalakítva: (Olvassunk be egész, elôjeles számokat és adjuk ôket össze amíg 0-t nem ütünk be.)

• Láthatjuk elôször inicializáljuk az osszeg változót.
• Majd beolvassuk az elso szam-ot, ha ez 0 akkor hozzáadja az osszeghez, az-az nem változik semmi, és kilép.
• ha nem nulla az alsô szám akkor hozzáadja az osszeg-hez és elôrôl kezdi a ciklust, stb.

Léptetéses ciklus - az elöltesztelô speciális változata

Lássuk hogyan oldhatnánk meg általánosan egy elöltesztelô ciklussal azt, hogy x-szer hajtson végre egy tevékenységet:

 
Az elôzô példánkat melyben 0 végjelig olvastuk be a számokat modosítsuk úgy, hogy megkérdezzük a felhasználótól, hány számot kíván beolvasni, majd beolvassuk az x számot és összeadjuk. Íme a stuktogram:
 

Röpke áttekintés kedvéért nézzük meg hogyan épül fel egy Pascal ill C program:

• Pascal:

• Egy C program általános felépítése:

Nos lássuk az értékadást, mint elsô fontos m?veletünket:

• Pascal:

A_Halmaz := B_Halmaz;
A halmazoknak vagy azonos típusúaknak kell lennie, vagy típus konverziót kell alkalmazni.
• C:

a_halmaz = b_halmaz;

A különbség, hogy Pascal-ban := (tehát kettôspont és egyenlô)
 

Változó deklarálása:

• Pascal:

A fenti program sémában megadott helyeken a:
var VáltozóNév1, VáltozóNév2: Típus;
forma alapján.
• C:

1, Minden blokkon kívül: lehet globális (mindenhol elérhetô) változót deklarálni (lásd a C prg. Sémát)
2, Elvileg bármely blokkban, lehet csak ott elérhetô, lokális változót deklarálni (lásd a C prg. Sémát)
Formula:
Típus válotzónév1, változónév2, ...;

Adat bevitele:

• Pascal:

var X: Word;
BEGIN
ReadLn(X);
END.
• C:

#include <stdio.h>
void main()
{
int X;
scanf("%d", x);
}

Kétágú szelekció:

• Pascal:

if logikai_feltétel
then utasítás1
else utasítás2;
A then ágba akkor kerül ha igaz a feltétel, ha hamis akkor az else ágba jut.
• C:

if (logikai_feltétel)
{ utasítás1; }
else {utasítás2;}
Az utasítás1-et igaz érték (1) esetén hajtja végre, az else utánit ha hamis.
FIGYELEM: Az else utasítás mindig a hozzá legközelebb álló else-vel nem párosított if-hez fog tartozni, így megfelelôen {}-jelezzünk !

Egymásbaágyazott kétágú szelekció:

• Pascal:

if logikai_feltétel
then if logikai_feltétel2 then utasítás1
else utasítás2
else utasítás3;
A then ágba akkor kerül ha igaz a feltétel, ha hamis akkor az else ágba jut.
• C:

if (logikai_feltétel)
{ if (logikai_feltétel2) {utasítás1; } }
else {utasítás2;}
else {utasítás3;}
Persze ez a zárójelezés csak példa ha azt aharjuk, hogy az else másik if-hez tartozzon nem így kell zárojelezni.

Többágú szelekció:

• Pascal:

var betu: Char;
case betu of
'a'..'z': WriteLn('Kisbet?');
'A'..'Z': WriteLn('Nagybet?');
'0'..'9': WriteLn('Szám');
' ' : WriteLn('Space');
else WriteLn('Más karakter');
end;
• C:

char betu;
switch (betu) {
case 'a': case 'b': és fel kell sorolni egészen z-ig és: printf("Kisbet?"); break;
case 'A': case 'B': és fel kell sorolni egészen Z-ig és: printf("Nagybet?"); break;
case '0': case '1': és fel kell sorolni egészen 9-ig és: printf("Szám"); break;
default: printf("Más karakter"); // itt elhagyható a break;
}

Látjuk, hogy Pascal-ban megadhatunk intervallumot is, míg C-ben fel kell sajna sorolni az összel elemet. Pascalban a hatásköre a kiválasztott elem után 1 parancs vagy begin - end; közé rakva több. C-ben hasonlóan, csak break-kal ki kell szálni a switch-bôl, hogy az elsô jó elem után NE vizsgálja meg a többit.
 

Elöltesztelô ciklus

• Pascal-ban:

while lefutási_feltétel do
begin
{ciklusmag}
end;
• C-ben:

while (lefutási_feltétel) {
// ide jön a ciklusmag
}

Hátultesztelô cilkus

• Pascal:

repeat
{ciklusmag}
until kilépési_feltétel;
• C:

do {
//ciklusmag
} while (lefutási_feltétel);

    Következô számunkban folytatjuk a léptetéses ciklus Pascal ill. C formuláját, majd a stuktogram elemeit.
Amennyiben valakinek kérdése van a fent elmondottakkal kapcsolatban, az írjon az alábbi eMail-cimre.