Ugyan követtem már el olyan kifejezést aminek a végeredménye ligikai típusú lett, de nem mondtam róla semmit.
Tehát, először is ismerkedjünk meg egy új típussal, a logikai, azaz boolean. (Eddig akkor ismerjük az integer-t és
most már ezt is. Említettem, hogy majd lesz egy részletesebb ismertetése a típusoknak, ez még nem az.) A
típust George Boole angol matematikus tiszteletére hívják így. Ő alkotta meg a bool algebrát. Ahogy az lenni
szokott, életében nem ismerték el munkáját, úgy vélték a gyakorlatban nem lehet használi semmire. Csak
halála után 70 évvel Claude Shannon bukkant rá munkájára, miközben filozófiát tanult. Ő jött rá arra, hogy
az elektromechanikában igen is hasznos. Az eletromoskapcsolók tulajdonságainak használata a logikai
műveletekhez az alapja az egész modern számítástechnikának. Így Boole, Shannon közreműködésével,
megteremtette a digitális korszak elméleti alapjait. De ennyit a történelemről.
Nézzük meg közelebbről ezt a típust. Összesen két értéket vehet fel. Igaz, hamis, azaz true és false. Amikor
az elágazásban, illetve feltételes ciklusban összekapcsoltunk két számot valamilyen relációs jellel, akkor a
végeredmény ilyen típusu volt. Igaz, nem deklaráltunk egy változót és tettük bele ezt a végeredményt, (nem is
lenne értelme, hiszen csak felesleges pluszmunka) ennek ellenére amikor azt mondtuk if (3<2) then gépünk
kiszámolta ezt az értéket majd az elágazás ennek alapján folytatódott. Jelen példában ez az érték hamis (false),
ezért a then ág nem is hajtódna végre.
Az if-ekben és feltételes ciklusokban (while, repeat) mindíg olyan kifejezésnek kell állnia, aminek a
végeredménye boolean típusú. De mikor lesz az? Láttuk, hogy amikor valamilyen relációs jellel kötöttünk
össze két számot akkor az volt. Tehát ha egy kifejezésben van <,>,<=,>=,= akkor annak végeredménye boolean
típusú. A Pascalban az = jel összehasonlítást jelent. Eldöntjük két értékről, megegyeznek-e. Az értékadás
azért lett a := jel, hogy ne keveredjen a kettő.
Nézzünk egy példát!
Program bool; { A programnak nem adhatnánk azt a nevet, hogy }
Uses crt; { boolean, hiszen az foglalt szó. }
var logikai : Boolean; { Változó deklarálása, melynek boolean a típusa. }
BEGIN
ClrScr;
logikai := true; { Értéke csakis true, }
WriteLn(logikai);
logikai := false; { vagy false lehet. }
WriteLn(logikai);
logikai := 5+2<8+1 { ez egy logikai kifejezés }
WriteLn(logikai);
logikai := 5+2 = 8+1 { ez is logikai kifejezés }
WriteLn(logikai);
logikai := logikai; { Saját magát is értékül adhatom, hiszen a típusaik megegyeznek. }
WriteLn(logikai);
logikai := true > false; { A két értéket össze lehet hasonlítani, a true a nagyobb. }
WriteLn(logikai);
readkey;
END.
Programunk futtatás során az alábbiakat fogja kiírni:
true
false
true
false
false
true
Az utolsó kettőt kivéve remélem egyiket sem kell magyarázni. Az utolsó előtti esetében semmi különös nem történik, hiszen
saját magát adtam értékül, így értéke nem változott. Az utolsó már érdekesebb. A true és false szavak mögött természetesen
szintén számok állnak. Nyílván gépünk csakis azokkal tud dolgozni. A számok ésetében pedig van értelme relációkról beszélni.
Azt hiszem ezzel ki is tárgyaltuk a boolean típust. Térjünk át az igazságtáblákra.
Mielőtt azonban ezt megtennénk ismerkedjünk meg két fontos fogalommal, az operátorokkal és operandusokkal. Ezeket már eddig
is használtuk, csak nem neveztük nevén őket. Az operandusok azok az értékek amiken a műveleteket végezzük. Ezek lehetnek
változók, de akár konkrét számok is. Az operátorok azok, melyek megmondják milyen műveletet kell végrehajtani az adott
operanduson, illetve operandusokon. Nézzünk egy példát:
eredmény := 3+9;
A 3 és a 9 operandus, míg a + jel operátor. Ennyi.
Milyen operátorokat ismerünk eddig? Általános iskolában megtanultuk a következőket: +,-,*,/,<,>,=. Ezek a Pascal nyelvben is
szerepelnek. Lássuk mi van még. Létezik még: and, or, not, xor. Ezen operátorok a relációsjelekhez hasonlóan szintén logikai
típusú eredményt adnak. Mind a 4-el nap mint nap találkozunk. Lássuk hát őket egyesével.
NOT: Ez egy egyoperandusú operátor azaz egy értékre van hatással, méghozzá tagadja azt. Not True = False. Azonkívül, hogy
egyoperandusú operátor fontos tulajdonsága, hogy mindíg az operátor előtt kell álljon. Ha az életből szeretnénk példát
találni rá akkor mondhatjuk úgy működik mint egy rossz kisgyerek. Mindíg mindennek az ellenkezőjét akarja.
AND: Magyarul és. Bár ezzel valószínűleg nem mondtam semmi újat. Ez már két operandusú operátor. Többnyire két logikai
értéket kapcsolunk össze vele. Akik voltak már önkéntes véradáson azok tisztában vannak vele, hogy ki kell tölteni egy
kérdőívet. A kérdések a donor egészségi állapotát mérik fel. Ha van olyan (akár egy is) amelynek nem felel meg akkor nem
adhat vért. Itt a kérdések ÉS-ekkel vannak összekötve. Tehát csak akkor lesz a végeredmény igaz, ha mindegyik operandus
igaz. Ha bármelyik hamis, vagy mindkettő hamis, akkor a végeredmény is hamis. Az and operátornak a két operandusa között
kell állnia. logikai := true and false; Ez a kifejezés egy false értéket tesz logikai nevű változóba.
OR: Magyarul vagy. Szintén kétoperandusú, és a két operandusa között kell állnia. Esténként a tv előtt gyakran találkozunk
vele. Amikor azt mondják, hogy a film megtekindését 12 éven aluliaknak szülői felügyelet.... Mindenki ismeri. Tehát vagy
elmúltál 12 éves, vagy legyen ott anyu, apu. Nyílván itt elég ha az egyik teljesül, de abból sincs gond, ha mindkettő.
logikai := true or false. Ez a kifejezés egy true értéket tesz logikai nevű változóba.
XOR: (eXlusive OR) Magyarul: kizáró vagy. Szintén kétoperandusú és a két operandusa között kell állnia. Amikor az anyuka azt
mondja kisgyermekének, hogy jól viselkettél az ovodában, ezért kapsz fagyit, vagy csokit. A kisgyermek tisztában van vele,
hogy a kettő közüll bármelyiket választhatja, de mindkettőt nem. Ezek alapján a xor akkor lesz igaz, ha két operandusa közüll
pontosan az egyik igaz. Akkor lesz hamis, ha mindkettő hamis, vagy mindkettő igaz. logikai := true xor false. Ez a kifejezés
egy true értéket tesz logikai nevű változóba.
Az elmondottak táblázatba foglalva:
AND
|
igaz
|
hamis
|
|
igaz
|
igaz
|
hamis
|
|
hamis
|
hamis
|
hamis
|
|
OR
|
igaz
|
hamis
|
|
igaz
|
igaz
|
igaz
|
|
hamis
|
igaz
|
hamis
|
|
XOR
|
igaz
|
hamis
|
|
igaz
|
hamis
|
igaz
|
|
hamis
|
igaz
|
hamis
|
|
Ezeket a táblázatokat igazságtáblázatoknak hívják. Írhattam volna igaz és hamis szavak helyett az angol megfelelőjüket is,
sőt gyakran szoktak 0- és 1-eket használni. Természetesen mindegyik ugyanazt jelenti.
Most, hogy ismerjük az operátorok egy részét, fel kell tennünk a kérdést, hogy egy olyan kifejezésben amiben több is
szerepel belőlük milyen sorrendben végzi el őket a gép. Vegyük az alábbi kifejezést: 5 + 3 * 4. Iskolában tanultuk, hogy
a szorzást előbb kell elvégezni mint az összeadást. Ezt a Pascal is tudja. De mi a hejzet ezzel:
false AND NOT true < true XOR false OR true
Nyílván van egy szabályrendszer ami alapján dolgozik. Ez a szabályrendszer elég jól illeszkedik ahhoz amit
matematikából megtanultunk. Táblázatban Összefoglalva:
|
1
|
@, not
|
|
2
|
*, /, div, mod, and, shl, shr
|
|
3
|
+, -, or, xor
|
|
4
|
=, <>, <, >, <=, >=, in
|
Tehát a táblázat segítségével: A legnagyobb precedenciája a NOT-nak van, ezért az hajtódik végre elsőként. Így lesz:
false AND false < true XOR false OR true
Második az AND. Így kapjuk a
false < true XOR false OR true
Na igen ám, de itt a XOR és az OR azonos szinten helyezkedik el. Melyiket kell hát hamarabb elvégezni? A balról jobbra
szabály lép életbe, tehát az olvasással is megegyező irányban sorba vesszük őket.
false < true OR true
lett az eredmény. Majd elvégezzük az OR
műveletet is:
false < true
A relációs jelek egészen alul szerepelnek a táblázatban, így ez maradt utoljára. Mivel a false
kisebb a true-nál, így a reláció igaz lesz, tehát a kifejezés értéke:
true
A táblázatból látszik az is, hogy a szorzás és osztás előbbrevaló mint az összeadás és kivonás.
A táblázatban szerepel néhány olyan operátor is, mely még ismeretlen számunkra. Azokról majd később lesz szó. Most csak azért
szerepelnek itt, hogy táblázatunk teljes legyen. Eme táblázatot egyébként precedencia táblázatnak hívják. Minnél lentebb
van egy operátor annál kisebb a precedenciája és annál később lesz elvégezve az általa jelölt művelet.
Írjunk egy konkrét programot. A feladat: Kérjünk be egy 0 és 15 közé eső számot. A 0 és 15 még megengedett. Ha a felhasználó
rossz értéket ad meg, ne vegyük figyelembe. Egyszerűen töröljük a hibás értéket a képernyőről, de csak azt és mást ne. Tehát
a ClrScr-t nem használhatjuk erre. Miért fontos ez? Tegyük fel, egy nagyobb programot írunk. Ekkor a képernyő tele lehet
programunk szövegével. Nem törölhetjük a teljes képernyőt, hiszen az tele lehet fontos információkkal. Fontos feladat tehát
a monitor egy meghatározott részének törlése. Hogyan tudunk törölni a ClrScr nélkül? Teleírjuk szóközökkel a kívánt részt.
Program beker;
Uses crt;
var szam : Integer;
BEGIN
ClrScr;
szam := -1;
{ A ciklus addig megy, amíg megfelelő számot be nem írják. }
While ((szam > 15) or (szam < 0)) do
begin
GoToXY(7,1); write(' '); { Törlés szóközzel. }
GoToXY(1,1); write('szam: ');
ReadLn(szam); { Szám bekérése. }
end;
Write('A beirt szam: ',szam);
ReadKey;
END.
Nézzük a ciklust! While ciklus addig ismétlődik amíg a benne azereplő kifejezés igaz. Jelen esetben ez:
((szam > 15) or (szam < 0)). Az OR igazságtáblája alapján tudjuk, hogy ha bármelyik operandusa igaz, akkor a végeredmény is
igaz. Tehát ha 0-nál kisebbet írunk akkor is igaz lesz, és ha 15-nél nagyobbat akkor is. Ilyenkor ismétel. Egészen addig,
amíg a megfelelő számot be nem írjuk.
Szam változó értékét a ciklus előtt ismét el kellett rontani, hiszen a default értéke 0 lenne az pedig megfelel a
kitételeknek, így a ciklus egyszer sem hajtódna végre. Hogyan lehet ezt elkerülni?? Melyik az a feltételes ciklus ahol
mindenképpen lefut egyszer a ciklusmag?? Igen, kedves olvasó, a hátultesztelős ciklus. Próbálkozz meg, és írd át a programot
önállóan erre! Ha nem sikerül, olvasd el mégegyszer az előző tutoriálban írtakat. Ha még akkor sem megy, íme:
Program beker;
Uses crt;
var szam : Integer;
BEGIN
ClrScr;
Repeat
GoToXY(7,1); write(' '); { Törlés szóközzel. }
GoToXY(1,1); write('szam: ');
ReadLn(szam); { Szám bekérése. }
Until ((szam <= 15) and (szam >= 0)); { Ugye nem is volt nehéz?? }
Write('A beirt szam: ',szam);
ReadKey;
END.
Nem különösebben nehéz, csak az operátorokat kellett átírni. A relációk megfordultak az OR-ból pedig AND lett. Így nincs
szükség a szam változó elrontására, ezért egyszerűsödik a program.
Ezzel fejezem be a harmadik tutoriált. A következőben a tanult ismereteket felhasználva programot fogunk írni.
