A Pascal nyelv alapjai
Írta : Kovács Endre János
Tartalomjegyzék
2. Fejezet - a Pascal környezet megismerése
3. Fejezet - Az első program (Hello Word!)
4. Fejezet - A változókról általában
5. Fejezet - Feltételes utasítások
6. Fejezet - Kapcsolatok a feltételben
Nos, azt hiszem, most azokhoz kell szólnom, akik még egyáltalán nem foglalkoztak programozással... Nekik azt tudom mondani, hogy itt az alapvető programozási lépéseket tanítom meg. Akik ennél már magasabb szintre léptek, azok se ugorják ezt át, mert lehet, hogy ők is találhatnak itt olyan dolgokat amik érdekesek lehetnek számukra.
E rövid bevezető után hadd mutassam be a Pascal környezetet:
Látható, hogy a legfelső sor a Pascal környezeti részét tartalmazza.
File: Új PAS fájl létrehozása, Meglévő megnyitása, Mentés, Mentés másként... stb
Edit: Szöveg- másolása, kivágása, beillesztése... stb.
Search: Keresési szekciók
Run: Program futtatása, paraméterezése...stb.
Compile: Program EXE-re fordítása, program információ...stb.
Debug: Nyomkövetési részek. A 'watch ' ablakot szokták itt a leggyakrabban emlegetni, itt tudjuk majd a változóink (majd később...) értékét nyomon követni
Tools: Segédprogik a Pascalhoz...
Options: A Pascal beállításai. Hova fordítsa az EXE a TPU (türelem! később!) fájlokat... stb.
Window: A WINDOW(S)-ban fellelhető 'nézet' menühöz hasonlítanám....
Help: Erre szükséged lehet, ha elakadsz... (Shift+F1)
Nos, ennyi a felső menü... alatta az a szép kék terület a 'fejlesztői rész', ahova majd az utasításokat írod a gépnek...
Ok? Akkor mehetünk is tovább...
A legelső program:
Ha elindítottuk a Pascalt, akkor írjuk be az alábbi sorokat:
BEGIN
WriteLn('Hello World!');
END.
Tudom, eléggé elcsépelt... de ez van. Nos, mit is írtunk? A BEGIN jelen pillanatban a program kezdetét jelzi, az END. (a PONT fontos!) pedig a program végét. A kettő közötti rész pedig azt jelenti, hogy: 'Írd a képernyőre:' Hello World! A pontosvessző itt még nem, de később nagyon fontos szerepet tölt majd be!
A program lefutása után azonnal visszatértünk a Pascal környezetébe, így nem láthattuk a 'végterméket'. Nyomjunk egy Alt+F5 -öt, itt megtekinthetjük a lefutott programot, majd egy billentyű leütésével visszatérhetünk a Pascal-hoz.
Tehát a WriteLn (kis- nagybetű nincs megkülönböztetve) a Write Line röviditése, ami annyit tesz -egyenlőre- hogy a zárójel utáni részt írja ki a képernyőre.
Write, WriteLn:Két külön utasítás minimális különbséggel. Mi is az?
Írjuk át a programunkkat úgy hogy ne WriteLn, hanem Write utasítás legyen:
BEGIN
Write('Hello World!');
END.
Ha jól megnézzük, azt a szembetűnő különbséget tapasztaljuk, hogy a WriteLn után így néz ki a DOS ablak:
Hello World!
_
Míg a Write utasítás után:
Hello World!_
Hoppá! Tehát a kurzor (az a villogó micsoda) helyzetének a végkifejletében játszik szerepet! Ha WriteLn, akkor a szöveg kiírása után kezdődik egy új sor, míg a Write utasítás után a szöveg után KÖZVETLENÜL megmarad a kurzor! Juhéjjjjj! Megvan az első programunk! Bemutatkoztunk a világnak!
Azért megmutaton egy gyors képen keresztül is:
Nézzük tehát, hogy eddig mit is csináltunk: Tudjuk, hogy a programban kell lennie egy nyitó (BEGIN) és egy záró (END.) résznek. Ezek között helyezkednek el az utasítások. Már két utasítással megismerkedtünk, az egyik a WriteLn, ami a képernyőre ír megadott szöveget és a kurzort a következő sorba helyezi. A másik utasítás a Write, ez csupán abban különbözik az előzőtől, hogy a kurzor a legutolsó karakter után marad.
Jogosan merül fel a kérdés ezek után, hogy ezen kívül hogyan tarthatjuk még a kapcsolatot a felhasználóval?
Írjunk egy olyan programot, amely beolvassa a felhasználó nevét, majd üdvözli őt:
VAR Nev: String;
BEGIN
Write('Kérem a nevét: ');
ReadLn(Nev);
WriteLn('Üdvözöllek ', Nev ,'!');
END.
Azt hiszem most bőséges magyarázattal kell szolgálnom. Először is, beszélni szeretnék egy pár szót a VÁLTOZÓkról. A változók olyan programozási eszközök, amelyekbe értékeket (számokat, szöveget...stb.) lehet eltárolni. Tehát nem más, mint egy általunk lefoglalt terület a memóriában.
A változókat a VAR szóval lehet deklarálni (lefoglalni számukra a helyet a memóriában), amit a program elején kell beírnunk (csak 1-szer kell egy programban), majd azt követi a változó(k) neve(i) és az(ok) típusa. A típusok határozzák meg, hogy mekkora területet kell lefoglalni.
Változók típusai:
|
Változó neve |
Változó leírása |
Lefoglalt terület (bájt) |
|
CHAR |
1 karaktert tudunk vele eltárolni |
1 |
|
STRING |
Karaktersorozat tárolásához (pl.: név) |
Karakterek száma |
|
BYTE |
Szám tárolása (0..255 között!!!) |
1 |
|
INTEGER |
Szám tárolása (-32768..32767 között!!!) |
2 |
Ez persze nem a teljes lista, de kezdetnek elegendő lesz. A fenti példában is látható, hogy ha hosszabb szöveget szeretnénk letárolni a memórában (pl.: név, cím ...stb.), akkor a STRING típust kell alkalmaznunk.
Nos, amit még tudnunk kell az az, hogy van még egy szabály amit feltétlenül be kell tartanunk:
Nézzük tovább az előbbi forráskódot: máris a szemükbe tűnik az új parancs: ReadLn. Ez a 'Read Line' rövidítése, ezzel a paranccsal tudunk adatokat bekérni billentyűzetről. Használata a következő: ReadLn(Változónév); . A fenti sorokban tehát van egy 'Nev' nevű, string típusú változónk, amit arra használunk fel, hogy a ReadLn parancs segítségével megtöltünk a felhasználó nevével.
Ám ezzel még nem vagyunk kész! A WriteLn (és persze a Write) utasításnál egy apróság(!) kimaradt. Az aposztróf ( a ' jel) jelzi, hogy a programozó által megadott aposztrófok között levő szöveg fog megjelenni a képernyőn. Változók kiírása esetén viszont ezeket az aposztrófokat el kell, hogy hagyjuk. Ilyenkor a változóban levő érték (pl.: a felhasználó neve) fog kiíródni. Az előző példa eléggé bonyolult ebből a szempontból, mivel statikus (mindíg ua.) és dinamikus (változóból vett) szöveget is tartalmaz. Az 'ÜDVÖZÖLLEK ' és a '!' mindíg kiíródik, de közöttük ott van a NEV nevű változó ami viszont mindíg más lesz (más begépelés esetén). A statikus és dinamikus szöveget vesszővel kell elválasztani úgy hogy a statikus szöveget először le kell zárni az aposztróffal.
'Üdvözöllek ' , Nev , '!' Zölden a statikus szöveg látszódik, pirossal a dinamikus. Megjegyzem, hogy a vessző helyett a + jelet is alkalmazhatjuk ( WriteLn('Üdv '+Nev+'!'); ). Felmerülhet a kérdés, hogy mi van akkor, ha a statikus stringben is van aposztróf? Ilyenkor duplázva írjuk az aposztrófot: 'Hello '+Nev+'! this is eMPa''s webpage!'
És még egy szót a változókról, mert ez később még jól fog jönni:
Változóinknak úgy tudunk értéket adni, ha egy := -t teszünk a változó és az érték közé. Így:
Változónév:=Érték;
Pl.:
Var
I: Byte;
S: String;
BEGIN
I:=134;
S:='Andrew';
END.
Remélem szembetűnő tény az, hogy amennyiben számmal dolgozom nem teszek aposztrófot ('...'), csak akkor, ha szöveggel!
Remélem, ez érthető volt. Mert ami most jön....... Az se lesz nehéz ;)
Vannak olyan esetek, amikor a program futása során elágazásba ütközünk. Pl.: A bekért névről el kell döntenünk, hogy megegyezik-e a saját nevünkkel. Ha igen, akkor kiírja, hogy névrokon az illető, ellenben jön a már jól ismert üdvözlő (legyen a programozó neve: 'eMPa'). Valahogy így valósul meg a program:
VAR Nev: String;
BEGIN
WriteLn('Kérem adja meg a nevét: '); ReadLn(Nev);
if Nev='eMPa' then WriteLn('Haha! Te is fiam eMPa?') else WriteLn('Üdvözöllek '+Nev+'!');
END.
Azt gondolom nem kell részleteznem, hogy a program 4. sorában van a lényeg, azt viszont hogy mi is van ott azt igen. Tehát: a feltétel magyarosítva így szól: HA a Név eMPa, AKKOR írd ki: Haha.... KÜLÖNBEN írd ki: Üdv...
Az IF a HA, a THEN az AKKOR az ELSE pedig a KÜLÖNBEN. Ez utóbbit nem muszály alkalmazni. Az IF után jön a feltétel (vagy feltételek, de ezt majd...), majd a THEN után jön az IGAZ-ág, vagyis ha a feltétel teljesül (pl.: a Nev megegyezik eMPa-val). Ezután jöhet - az ELSE szócska után - a HAMIS-ág, ami akkor hajtódik végre, ha a feltétel nem teljesül (pl.: nem eMPa a felhasználó). Még egy fontos dologra felhívnám a figyelmet: ha az igaz vagy a hamis (vagy mindkét) ágba több utasítást szeretnénk végrehejtatni, akkor azokat külön BEGIN-END közé kell betenni, de ott az END után nem pontnak, hanem pontosvesszőnek kell lennie! Illetve a KIS- és NAGYBETŰK meg vannak különböztetve a vizsgált karaktersorozatban! (eMPa nem egyenlő empa, vagy EMPA...stb.!)
Pl.:
BEGIN
...utasítások...
if változó='walamy' then
begin
...utasítás... Ez az IGAZ-ág
...utasítás... Ez az IGAZ-ág
end
else
begin
...utasítás... Ez a HAMIS-ág
...utasítás... Ez a HAMIS-ág
end;
...utasítások...
END.
Összehasonlítások:
Ha már így szóba került, akkor írom: a relációs jelekkel tudunk összehasonlítani változót-változóval, változót-értékkel az alábbiak szerint:
|
Reláció |
Művelet |
Változó-változóval példa |
Változó-értékkel példa |
|
= |
egyenlő |
if változó1=változó2 then |
if változó1=10 then |
|
<> |
nem egyenlő |
if változó1<>változó2 then |
if változó1<>10 then |
|
> |
nagyobb |
if változó1>változó2 then |
if változó1>10 then |
|
>= |
nagyobb egyenlő |
if változó1>=változó2 then |
if változó1>=10 then |
|
< |
kissebb |
if változó1<változó2 then |
if változó1<10 then |
|
<= |
kissebb egyenlő |
if változó1<=változó2 then |
if változó1<=10 then |
Nos, ez eddig szép és jó. Egészen addig, amíg csak két feltétel van (ha eMPa, ha nem eMPa). De mi van akkor, ha már több feltételt is szeretnénk megvalósítani? A következő -már eléggé elkoptatott- feladat ezt a problémát tökéletesen stimulálja:
Kérjük be a felhasználótól a VÍZ hőmérsékletét és írjuk ki annak megfelelően a halmazállapotát!
VAR Homerseklet : Integer;
BEGIN
Write('Kérem, adja meg a víz hőmérsékletét! : '); ReadLn(Homerseklet);
if Homerseklet>=100 then WriteLn('Ez gőz') else
if Homerseklet=0 then WriteLn('Ez jég!') else
WriteLn('Ez víz!');
END.
Mielőtt fellendülnének a szemöldökök elárulom, hogy nem a magas értéktartománya miatt választottam az INTEGER típust, hanem azért, mert ez negatív számokkal is tud dolgozni. Ugyanakkor megjegyzem, hogy erre alkalmas lett volna továbbá a SHORTINT, ami -128 -tól 127 -ig, illetve a LONGINT, ami pedig ... hát, eléggé nagy tartományban képes kezelni a számokat.Látható, hogy az adatbekérés után jön az első feltétel. Itt megvizsgáljuk, hogy a hőmérséklet nagyobb-egyenlő -e, mint 100. Ha IGEN, akkor kiírjuk, hogy gőz. Ha NEM, akkor (csak akkor!) lépünk tovább a következő feltételre, ami megvizsgálja, hogy a hőmérséklet egyenlő-e 0-val. Ha IGEN, akkor Kiírjuk, hogy jég. Ha NEM akkor (csak akkor!) kiírjuk, hogy víz. Itt már felesleges lenne egy újabb IF, mivel a legutolsó eldöntés tulajdonképpen arról szól, hogy ha nem is gőz, nem is víz, tehát egyik feltétel sem teljesül, akkor (csak akkor!) hajtsa végre az utasítás(oka)t. Jelen esetben ez a WriteLn('Ez víz!') volt. Ok?
Nézzünk meg még egy feladatot:
A bekért osztályzat alapján írjuk ki, hogy az kitűnő, jó, közepes, elégséges vagy elégtelen-e.
Mielőtt vadul nekilátnánk IF-ek tömkelegét begépelni, ismerkedjünk meg egy új szerkezettel:
CASE kifejezés OF
Érték1: utasítás...
Érték2: utasítás...
...
ÉrtékN: utasítás...
else utasítás...
END.
Ami nem más, mint tetszöleges számú IF utasítás egyszerűsített változata. Az előző példában tehát volt egy osztályzat, aminek 5 lehetséges feltétele volt (vagy kitűnő, vagy jó....). Ilyenkor célszerű a fennt leírt CASE utasítást alkalmazni. Már csak azért is, mert így átláthatóbb forráskódot kapunk.
Ha több utasítást szeretnénk egy érték után végrehajtani, akkor BEGIN-END; közé kell helyezni:
CASE kif. OF
...
ÉrtékN: begin
utasítás1;
utasítás2;
utasításN;
end;
...
END;
És még valami: Az else ág itt sem kötelező, azt a bizonyos -előbb tárgyalt- utolsó HAMIS ágat jelenti, amikor egyik feltétel (itt: Érték) sem teljesül, akkor hajtódik végre (mint -feljebb- a víznél).
A könnyebb érthetőség kedvéért kiegészítem a feladatot annyival, hogy ha 4-est kapott az illető, akkor nem csak azt írjuk ki, hogy 'jó', hanem egy új sorba azt is, hogy 'majdnem sikerült'. Lássuk hát!
Var Osztalyzat: Byte;
BEGIN
Write('Kérem, gépelje be az osztályzatot!: '); ReadLn(Osztalyzat);
Case Osztalyzat Of
5: WriteLn('Kitűnő!');
4: begin
WriteLn('Jó!');
WriteLn('Majdnem sikerült!');
end;
3: WriteLn('Közepes');
2: WriteLn('Elégséges');
1: WriteLn('Elégtelen');
End;
END.
Az utolsó előtti End; a CASE-t zárja le! Pfffff.... kicsit elfáradtam.... na, menjünk tovább!
Milyen kapcsolat lehet két feltétel között? Nos, erre nehéz válaszolni. Mit is értek egyáltanán kapcsolat alatt? Ismét egy példát hívnék segítségül:
A beolvasott számról döntsük el, hogy kissebb mint 100, és nagyobb, mint 10! Húha! Ezt még a CASE-zel is eléggé macerás lenne megírni! Szerencsére nem is ezt választjuk...
Var Szam: Byte;
BEGIN
Write('Kérek egy számot!: ');ReadLn(Szam);
if (Szam<100)AND(Szam>10) then WriteLn('Ez ilyen szám!') else WriteLn('Ez az intervallumon kívül esik...');
END.
Még alá is húztam a kritikus részt! Mi is az az AND ott? Tulajdonképpen egy ÉS. Magyarul így szólna az utolsó előtti sor: HA ('Szam' kissebb, mint 100) ÉS ('Szam' nagyobb, mint 10) AKKOR ... KÜLÖNBEN ...
Tehát: Feltétel akkor IGAZ, ha (első állítás=IGAZ ) és (második állítás=IGAZ) és (N. állítás=IGAZ). Ha közülük bármelyik állítás HAMIS (vagyis nem teljesül), akkor a Feltétel=HAMIS.
Az előző példában csak akkor tudtuk kiírni, hogy 'Ez ilyen szám', ha teljesült az is, hogy SZAM<100, és teljesült az is, hogy SZAM>10. Ha valamelyik (akár egy is) az állítások közül nem IGAZ, akkor a Feltétel sem IGAZ!
Megjegyzés: Látható, hogy a kapcsolatokat zárójelbe kell tenni. Tehát: (Állítás1)kapcsolat(Állítás2)kapcsolat(ÁllításN). Ez van...
Milyen kapcsolatok vannak még? Nos, amit leggyakrabban még használni szoktunk az az OR, vagyis a VAGY kapcsolat. Nézzük meg ezt is egy példán keresztül:
Fordítsuk meg az előző feladatot, a beolvasott számot vizsgáljuk meg és döntsük el, hogy kissebb mint 10 vagy nagyobb mint 100.
Var Szam: Byte;
BEGIN
WriteLn('Kérek egy számot!: ');ReadLn(Szam);
if (Szam<10)OR(Szam>100) then WriteLn('Ez a mi számunk!') else WriteLn('Hát ez nem...');
END.
Látható, hogy itt is aláhúztam a lényeget. Az OR egy olyan logikai VAGY kapcsolat, amely akkor ad IGAZ értéket, ha legalább az egyik (tehát vagy az egyik vagy a másik vagy az N. vagy akár mindegyik állítás IGAZ). De precizen fogalmaztam! A fenti példa tehát akkor ad vissza igaz értéket, ha (Szam=9 vagy 8 vagy 7 vagy ...)VAGY(Szam=101 vagy 102 vagy 103 vagy...). Ellenkező esetben HAMIS értéket ad vissza, és akkor jön az else ág....
Ez érthető volt?
Van még egy pár kapcsolat, de mivel én az alapokat szeretném itt megtanítani és ezek elegendőek lesznek a további ismeretek elsajátításához, így ezekre most nem térek ki. Sorry...
Nézzük a következő feladatot:
Egy árumozgató a raktárban a következő teendőt végzi el:
1., Megfogja a dobozt,
2., felemeli,
3., elviszi a raktár megadott helyére,
4., ott lerakja
5., visszamegy a többi dobozért, ha még van...
A munkásnak kb. 150 darab dobozt kell átmozgatnia, nincs se segítsége, se más eszköze, mint a 2 keze. (A munkás nem őrült meg, jól megfizetik...nnna....). Ja, és egyszerre csak 1-et bír el!
Írjuk fel ezt programszerűen! Tehát 150-szer kell felírnunk, hogy 'Megfogja a dobozt, felemeli, elviszi a raktár megadott helyére, ott lerakja, majd visszamegy a többi dobozért...'. Nosza!
1. 'Megfogja a dobozt, felemeli, elviszi a raktár megadott helyére, ott lerakja, majd visszamegy a többi dobozért...'
2. 'Megfogja a dobozt, felemeli, elviszi a raktár megadott helyére, ott lerakja, majd visszamegy a többi dobozért...'
3. 'Megfogja a dobozt, felemeli, elviszi a raktár megadott helyére, ott lerakja, majd visszamegy a többi dobozért...'
4. 'Megfogja a dobozt, felemeli, elviszi a raktár megadott helyére, ott lerakja, majd visszamegy a többi dobozért...'
... hát, már most elfáradtam... pedig csak copy-ztam...
Hogyan lehetne egyszerűsíteni ezen?
A Pascal 3 féle lehetőséget biztosít az egymás után levő utasítások többszöri végrehajtására:
Nézzük az ígért példákat:
- Az elsőre nagyon jó példa volt -szerintem- a munkás meg a dobozai... (150 dobozt kell mozgatni, az 150 db utasítás-sorozat)
- A második már bonyolultabbnak tűnik, de talán nem is... Nézzük csak:
Addig eszem a cseresznyét a tálból, amíg még van benne... látható, hogy van egy feltétel, ami alapján eldönthető, hogy a program mikor fejezze be az utasítások végrehajtását (ha már nincs több cseresznye). Továbbá az is látható, hogy nem is biztos, hogy le fog futni az utasítás (mert lehet, hogy már üres volt a tál, mire nekiláttunk volna...). Persze lehet kekeckedni velem, hogy 'bibí, én akkor is megszámolom, hogy mennyi cseresznye volt a tálban, és akkor ez a megoldás semmit sem ér', de vannak esetek amikor ez a célravezetőbb megoldás... oké?
- Végezetül a harmadik, ami csak annyiban különbözik az előzőtől, hogy legalább 1-szer biztosan végrehajtódik.
Addig eszem a csokikat, amíg éhes vagyok... Nem hinném, hogy 0 csoki megevése után lenne olyan ember aki jóllakna. És persze feltételezzük, hogy éhes vagyok!!! Tehát legalább 1 csokit meg kell ennem ahhoz, hogy jóllakjak... Ok?
Akkor nézzük meg ezeket a gyakorlatban is:
Az első példa a FOR ciklusszervező utasítást mutatta be. Ennek a működése a következő:
For ciklusváltozó:=kezdőérték To végérték Do utasítás;
A ciklusváltozó egy olyan 'változó', ami automatikusan változik. Kap egy kezdőértéket, majd egészen addig növekszik (vagy csökken... de ezt most talán ne...), amíg értéke nem éri el a végérték-et. Tehát:
Var Dobozok: Byte;
BEGIN
For Dobozok:=1 To 150 Do
begin
WriteLn('Megfog,');
WriteLn('felemel,');
... stb ...
end;
END.
Remélem, ez érthető volt. Arról van szó, hogy az Dobozok nevű változó 1-től 150-ig növekszik, és minden egyes növekedéskor végrehajtódik a megadott utasítás (vagy utasítások BEGIN-END; között!).
Érdekesség: A FOR-TO-DO részt a ciklus fejlécének, az utánna levő utasítás(oka)t pedig a ciklus magjának nevezzük...
Nézzük a 2. példát:
A WHILE elöltesztelős ciklust mutatta be a cseresznyés példa.
While feltétel Do utasítás;
Azért elöltesztelős, mert mielőtt végrehajtódna a ciklusmag (a hozzátartozó utasítások) megnézi, hogy a feltétel igaz-e. Ha igen, akkor végrehajtja azt, különben átlépi és a ciklusmag utáni első utasítással folytatja a program a futást.
BEGIN
While van_meg_cseresznye Do WriteLn('Eszek még egy cseresznyét!');
END.
Azt a függvényt persze senki se keresse, hogy 'van_meg_cseresznye', mert csupán példaként írtam...
De ezt már próbaképpen be lehet gépelni:
Var Nev: String;
BEGIN
While Nev='' Do
begin
Write('Kérem, adja meg a nevét: ');
ReadLn(Nev);
end;
END.
Annyit elöljáróban megsúgok, hogy a program indításakor a Pascal nullázza a változókat, így a BEGIN utáni részben a Nev értéke üres (ezt dupla aposztróffal szoktuk jelölni = ''). Így a While utáni utasítások biztosan végre fognak hajtódni... De! Ha a BEGIN után egy Nev:='eMPa'; sort írunk, akkor viszont nem! Mert a While előtt a Nev változó már nem lesz üres, ugyanis 'eMPa' értéket kap. Ezért aztán már nem is foglalkozik a ciklusmaggal, hanem tovább ugrik az end; utáni utasításra (jelen esetben az END. -re). Ok? Hidd el, ez egy nagyszerű vizsgálati lehetőség nagyobb programok (de a kissebbeknél is!) esetén!
Nézzük ezek után a 3. példát:
Azt mondtam, hogy nincs nagy különbség az előző és ez között, csupán annyi, hogy ez min. 1-szer biztosan végrehajtódik... nos, ezt a REPEAT UNTIL ciklusszervező utasítással tudjuk elérni!
BEGIN
Repeat
WriteLn('Eszik még egy csokit...');
Until Jollakott;
END.
Addig futkározik az 'Eszik még egy csokit...' a képernyőn, amíg a Jollakott nem válik IGAZ-zá.
De nézzünk egy gépelhetőbb példát (mert még mindíg nincs 'Jollakott' nevü függvény...)
Var Jelszo: String;
BEGIN
Repeat
Write('Kérem, adja meg a jelszót: '); ReadLn(Jelszo);
Until Jelszo='eMPa';
WriteLn('Helyes a jelszó, beléphetsz...');
END.
Amit elsőre megjegyeznék az az, hogy ha valaki 'EMPA', vagy 'empa' néven próbál meg bejelentkezni, akkor az sajnos nem lesz jó... Kizárólag az 'eMPa' szót fogadja el a program... Ez most nekünk jó (hiszen jelszóról van szó), de már egy korábbi fejezetben is gondot okozott a kis-nagybetűk összekeveredése...
Ezért most egy kicsit kitérnék erre is:
Minden egyes leütött billentyűhöz, pontosabban minden egyes karakterhez tartozik egy azonosító. Ezt az azonosítót az ASCII karaktertáblázat tartalmazza, ami 256 elemű (0-255).
Magyarul: Minden egyes karakternek más-más kódja van (pl.: a=97 , A=65). Ezért van az, hogy a Pascal a Stringek kezelésekor megkülönbözteti a kis- ill. nagybetüket!
Később ezt a problémát is megoldjuk, csak azért írtam ezt le, hogy mindenki értse a miértjét a dolognak... ok?
Visszatérve a REPEAT UNTIL ciklushoz:
Kizárólag ennél az utasításnál nem kell több utasítás esetén BEGIN-END, mivel az UNTIL jelzi a ciklus lezárását!
Tehát felesleges a következőt írni:
repeat
begin
end;
until .... blablabla ....