Pascal nyelvről

• Welcome

Üldözlök minden olvasót. Gondoltam alkotok valami hasznosat is. Úgyhogy itt egy leírás arraaz esetre, ha valaki pascal nyelvet szeretne tanulni.Ennek a leírásnak nem célja mindent részletesen leírni, inkább a tényleg fontos dolgokra"korlátozódik".És inkább a gyakorlati dolgokat fogjuk tárgyalni, nem száraz egyetemi jegyzetnek szánom.Ha nincs semilyen számítógépes ismereted eddig, vagyis ha egy windows átlagfelhasználóvagy, (nem tudod, mi a fájl kiterjesztése, nem tudod, mi a parancssor, explorerrel böngészel:) stb), inkább ne kezdj neki addig, amíg nem érted, hogyan is működik a számítógép. (Azinformatikaórákat nam tarom elégnek).Na ennyi ide elég is, vágjunk beléje.Ja! és ha hüjeséget írok, javítsatok ki.

• Alapozás

Na, most átvesszük, naggyából hogyan is működik az egész.Nem akarom ide leírni a processzor működését meg az ASM nyelvet, mert az sokaknakelvenné a kedvét.Először is FreePascal nyelven fogunk dolgokat irogatni.Ehhez kell egy fordító, ami a Pascal forráskódból EXE futtatható fájlt csinál. Ezt nevezzükfordításnak.De miért is van erre szükség?Hát azért mert az a "nyelv" amit a processzor megért, (vagyis a gépi kód), túl bonyolultahhoz, hogy nagyobb programokat megírjunk benne.Persze az sem lehetetlen, de a billentyűzedet is elporladna tőle.Ezért találták ki az assembly nyelvet. Az assembly kód már nem gépi kód, de sokban hasonlítrá, az ASM egy alacsony szintű nyelv.Az ASM (gy.k:assembly) kódokat is le kell fordítani, assemblerrel (az assembly fordítókathívják így), gépi kódra, amit a processzor (ill. az oprendszer) is ért.A Pascal az meg egy magas szintű nyelv, éppen ezért azzal érdemes kezdeni.Az alacsony és magas szintű nyelvek közt kb. annyi a különbség, hogy ami a magas szintűnyelvben "menj haza", az az alacsony szintű nyelvben "ha még nem vagy otthon,tedd az egyiklábad a másik után.Ha már otthon vagy, akkor ne.Mégegyszer előlről"Remélem érthető.Na, ott tartottam, hogy kell egy pascal fordító. Szerintem az FPC a legjobb.Innen letölthető: http://downloads.sourceforge.net/project/freepascal/Win32/2.2.2/fpc-2.2.2.i386-win32.exe?use_mirror=dfn (Remélem jó linket adtam meg : ), ha esetleg nem :http://www.freepascal.org )

Nem nagy, kb. 33 Mb letöltve, és teljesen telepítve is csak kb. 100 Mb.Telepítsük a "Next,Next,Next..." módszerrel. : )Ez egyébként ez nem a legújabb verziója, de nekünk ez most jobban megfelel, mert awingraph unitot nem sikerül a 2.2.4-gyel működésrebírnom.Ha fel van telepítve, csináljunk valahol egy munkakönyvtárat, ahova majd elmentjük apascalos dolgokat.Ja! és a Windows fájlkezelő alapértelemezésben elrejti a fájlok kiterjesztését, úgyhogymenjünk be a sajátgépbe, -> C: meghajtó, -> felül "eszközök", ezen belül "mappa beállításai"-> az előugró ablakban kattints a "nézet" fülre és az alsó listából az "ismert fájlok

kiterjesztésének elrejtése" vagy valami hasonló , angol windowsban "hide extensions forknown file types" melletti kis pipát tüntesd el, aztán felül kattints az "apply to all folders"vagy talán "alkalmazás minden mappára" vagy "beállítás alapértelmezettként" gombra. Mostmár a fájlok kiterjesztése (gy.k:általában a fájlnév utolsó három betűje a pont után, afájltipust jelöli, pl. .JPG, .mp3, .pas, stb.) is látszani fog. És erre szükségünk is lesz,úgyhogy ezt a lépést ne hagyd ki.Na, ha már így berendezkedtünk, nyissunk meg egy parancssort (gy.k:start -> futtatás ->cmd.exe ->OK), és csináljunk is valami futtathatót végre.Először is a "cd" paranccsal lépjünk be a munkakönyvtárba, ahol majd dolgozni fogunk.Ha esetleg valaki nem lenne járatos a parancssor használatában, ajánlom ismerkedjen megvele közelebbről, az irományom megértéséhez szükség lesz rá.Na, ha eddig minden érthető, nyissunk meg egy szövegszerkesztőt, és itt most nem az afontos hogy sok betűtipus legyen benne, meg ismerje a word-artokat, meg ilyesmi, hanemlegyen minél egyszerűbb.Egyelőre megfelel a sima jegyzettömb, a Worddel nem sokra mennélforráskódszerkesztésben.Ha megnyitottad, másold bele ezt a kis szöveget (Ctrl+C,Ctrl+V):

program progi;

uses crt;

beginwriteln('Hello World! az egyszeruseg kedveert');end.

Ha ez megvan, mentsd el abba a mappába amit az előbb létrehoztál, a neve legyen mondjukp_1.pas.Később majd megmagyarázom.És fontos hogy ne úgy mentd el hogy p_1.pas.txt-re módosítsa a nevét a jegyzettömb.Na mostmár megvan a forráskód.Mint ahogy azt már leírtam, a forráskód egy egyszerű szövegfájl, olyan mint az összes többitxt fájl, csak a neve nem .txt -re végződik, hanem pascal forráskódok esetében .pas -ra.Most kattintsunk a már megyitott parancssorra, amivel beléptünk a munkakönyvtárunkba,oda ahova el van mentve az előbbi kis forráskód.Most írjuk be a következőt: "C:\FPC\2.2.2\bin\i386-win32\fp.exe"Idézőjelek nem kellenek, és ne is próbáld Ctrl+C-Ctrl+V-vel, mert az valószínűleg nem fogmenni parancssorban.Ha minden rendben, megjelenik egy DOS-os ablak, benne egy eléggé kezdetlegeskezelőfelülettel.Kattintsuk felül a File menüre, majd válasszuk belőle az Open menüpontot.

Itt nagy nehezen ki tudjuk tallózni a forráskód-fájlunkat, ha úgy mentetted el, ahogymondtam, kattints a p_1.pas-ra egyet, aztán az "OK", vagy "Open" gombra.Ekkor meg kell jelennie a forráskódnak egy kis ablakban a DOS-os ablakunkon belül.Itt lehet szerkeszteni is a kódot, de nekünk most nem az a lényeg (mert szerintem rémálomebben szerkeszteni). Kattintsunk felül a Compile menüre, és válasszuk a Compilemenüpontot.Most a fordító lefordítja a forráskódunkat, elkészít egy p_1.exe nevű futtatható fájlt abban amappában, ahol vagyunk.Persze ha hiba van a kódban, akkor nem tudja lefordítani a fordító, és kiírja, mi a hiba, éshanyadik sor hanyadik karakterében található.Olyankor ha tudjuk, javítsuk ki a hibát, és fordítsuk újra az egészet.Ha sikeres volt a fordítás, nyissunk meg egy újabb parancssort, lépjünk be abba a könyvtárba,ahova a forráskódunkat mentettük, és írjuk be ezt:p_1.exeHa minden rendben, a parancssorban megjelenik egy kis szöveg: 'Hello World! (azegyszeruseg kedveert)'Aztán visszakapjuk a promptot, és írhatunk tovább a parancssorba.Hát ez a progi nem sok mindent művelt, delegalább szemléltettem vele, hogzan is lehetforráskódból programfájlt csinálni.Ja! És a félreértések elkerülése végett még most leírnám, hogy a szerkesztőben(pl.jegyzettömb) megnyitott forráskód-fájlt (jelen esetben p_1.pas) először el kell menteni(Ctrl+S) , és aztán újra le kell fordítani, és csak aztán látszanak a változások a készprogramban.Na, a következő fejezetben megpróbálok valami értelmesebb dolgot írni.

• A pascal nyelv - alapok

A pacal nyelv egy magas szintű nyelv - mint azt már leírtamö.Egy Pascal programkód mindig a 'program' kulcsszóval kezdődik, persze idézőjelek nélkül.Ezt a szót egy azonosító követi, itt bármit megadhatunk, teljesen mindegy, csak annyi akikötés, hogy csak betűvel kezdődhet ('a'-tól 'z'-ig), speciális betű vagy ékezet nem lehetbenne, és betűvel (ugyanúgy a-tól z-ig), számmal, vagy aláhúzásjellel kell folytatódnia.Sor végére (általában) pontosvessző kerül.A kulcsszavak a programnyelv (esetünkben pascal) lefoglalt szavai, az azonosítók pedig olyanszavak, amikkel saját dolgokat azonosítunk, pl. saját változók, eljárások, stb., de erről majdkésőbb.Persze egy azonosító nem lehet egy kulcsszóval azonos, mert bajban lenne a fordító :).Ja, és nem hozhatunk létre két egyforma azonosítót, akkor sem, ha az egyik pl. eljárás, amásik meg pl. változó.Egyébként Pascalban a kis-nagybetű eltérések nem számítanak, vagyis Abc ugyanazt jelenti,mint az aBC.Remélem, ez eddig érthető.Aztán a következő sor (persze nem muszály új sorba írni, akár az egész programot is lehetegy sorba írni (ha nem akarod átlátni),de az utasítások végére akkor is pontosvesszőt kellrakni, és ez nagyon fontos!) kezdődjön az uses kulcsszóval, utána szóköz, és utána ahasználni kívánt unitok felsorolása, vesszőkkel elválasztva ha több van, aztán utasítás végérepedig pontosvessző.Ejtsünk itt pár szót a unitokról.

Az unitok előre megírt programrészeket tartalmaznak, nélkülük sokszor elég nehéz lenne amunka.A uses kulcsszóval kezdődő sorban tudatjuk a fordítóval, hogy milyen unitokat szeretnénkhasználni a programunkon belül.A crt unit főleg a parancssor használatához kapcsolódó dolgokat tartalmaz.Természetesen a unitok is fájlok (asszem .ppu a kiterjesztésük), azokat is le kell fordítani, ésa unit-forráskód-fájlok kiterjesztése is .pas.Később majd ejtünk szót a unitok írásáról is.Aztán ami ez után következik az előző példában, az a begin kulcsszó, amit maga a programkövet,(a főprogram), és aztán egy end és egy pont.Ami a begin és az end van, az szép sorban végre fog hajtódni.És persze vannak más részei is egy programkódnak, de erről majd később.Na, most már kezdek egy új fejezetet.

• Változók és eljárások

Na, akkor egy újabb példaprogram következik, mentsük el mondjuk p_2.pas néven, ésfordítsuk le:

program p_2;

uses crt;

varvaltozo:string;

procedure kiiras(mit:string);beginwriteln(mit);end;

procedure beolvas(var mibe:string);beginreadln(mibe);end;

beginkiiras('írj be valamit!');beolvas(valtozo);kiiras(valtozo);end.

Ebben a kódban már van pár újdonság.Most már felmerülhetett a kérdés: mi is a writeln()?Hát a writeln egy eljárás, parancssorba lehet vele szöveget kiírni a képernyőre.

Mint az látható, a writeln utáni két zárójel között meg kell adnunk valamit (valamiket).Jelen esetben azt, hogy mit írjon ki az eljárás, de ez most nem lényeges.Amit az eljárás neve után írunk a zárójelek közé, azt argumentumoknak vagyparamétereknek nevezzük.A paraméterek azt határozzák meg, hogy hogyan csinálja az eljárás amit csinál, avagyopciókat adhatunk át az eljárásnak.Ha egy eljárásnak nincsenek paraméterei, akkor üres zárójeleket írunk, vagyis egyszerűennem írunk semmit a praméterek heyére, ez így van a létrehozásnál, és a meghívásnál is.Jelen esetben a writeln eljárás a crt nevű unitban van létrehozva (nem ez a szakszerűkifejezés egyébként), és mert tudattuk a fordítóval az uses kezdetű sorban, hogy a crtunitban is keressen eljárásokat (egyébként változókat is, róluk is írok majd), most a fordítónem írja ki hogy error, mert tudja hogy mit jelent a writeln.Egyébként a writeln eljárást is megírta egyszer valaki, nekünk ezért nem kell.Amikor az eljárásokat lefuttatjuk, azt meghívásnak nevezzük.Egy eljárás meghívása a következőképpen történik:eljárásnév(paraméter1,paraméter2,paraméter3,paraméterN);Merthogy az eljárás meghívása egy utasítás, a végére pontosvessző kerül.Nos, most leírom, hogyan lehet eljárásokat létrehozni.

procedureeljárásnév(paraméter1:paraméter1_típusa;paraméter2:paraméter2_típusa);begin

//az ide írt utasítások fognak végrahajtódni amikormeghívod az eljárástend;

Ezt így persze nem lehet lefordítani. A kulcsszavakat, amik helyett nem írhatsz mást,kiemeltem.És ezt a kis eljárást így lehetne meghívni(lefuttatni), bárhol a programon belül, vagy máseljárásokban:

eljárásnév(14,65);

Tehát ha létrehoztunk paraméter-változókat, akkor értéket is kell adnunk nekik.Ezt az értéket a meghíváskor vagy közvetlenül odaírjuk (lásd fent az előbbi példában), vagyegy másik változó nevét írjuk a paraméter helyére, és akkor az adott változónak az értékemásolódik a neve helyére.Ez így nézne ki:

eljárásnév(változónév,32);

Ha eljárást szeretnénk létrehozni, azt a globális változók létrehozása után tehetjük meg.Egyébként (természetesen) egy eljárást meg lehet hívni a többi eljárásban is, de csak akkor,ha az adott eljárás a kódban előbb van létrehozva, mint az, amiben meghívjuk, és ez igaz a

függvényekre is , de róluk majd később.Ja, de még nem írtam le, mik is a változók.A változókban adatokat tárolhatunk, és azért hívják őket változóknak, mert meg lehetváltoztatni az értéküket.Egy változó a memóriának egy területe, vagyis a RAM-ban tárolódik.A változókban olyan adatokat tárolhatunk, amikre csak addig van szükség, amíg a programunkfut, ha leáll a program, a változóink megsemmisülnek, törlődnek.Vannak egyszerű és összetett változók, mi most az egyszerűekkel fogunk foglalkozni.Egy változónak három tulajdonsága van: a név, az érték és az adat típusa.Ha egy változót úgy képzelünk el mint egy dobozt, akkor a dobozon levő felirat a változónév,a doboz tartalma a változó értéke, és a tipust leginkább a doboz méretéhez lehethasonlítani.A leggyakoribb változó-adattípusokról itt egy kis táblázat:

Adattípus leírás Érték-példa

integer egy integer típusú változóbanegész számot tárolhatunk el

520

charegy darab karakterttárolhatunk el az ilyen típusúváltozókban

'A' vagy ha ASCIIkódban adjuk megakkor #65

byte0-tól 255-ig egy számottárolhatunk benne, amemóriában 1 bájtontárolódik

123

real tizedestörteket tárolhatunkel benne

23.235(tizedesvessző

helyett mindigpontot írunk)

string karakterláncot, vagyis egy sorszöveget tud tárolni

'szöveg'

boolean értéke vagy igaz (TRUE), vagyhamis (FALSE) lehet.

TRUE vagy FALSE

Vannak persze más adattípusok is, de szerintem ennyi most elég.Most nézzük meg az előbbi kódrészletben (a p_2.pas fájlra gondolok) az uses kezdetű sorutáni részt.Itt felsorolhatjuk azokat a változókat, amit a főprogramban, és az összes eljárásban használniszeretnénk.Ezek a globális változók. Azért globálisak, mert nem csak egy eljáráson belül léteznek,hanem az egész programban, és az összes eljárásban ismertek.Ha az előbbi dobozos példából kiindulva "bele szeretnénk rakni valamit egy dobozba", (itt"doboz" szó alatt változót értek :), akkor azt a következőképpen tehetjük meg:(ez itt egy integer (egész szám tárolására alkalmas) típusú változó, és azt szeretnénk hogy azértéke mostantól 50 legyen):

változónév:=50;

vagypedig ha egy másik változó (legyen mondjuk a neve "x") értékének másolatát szeretnénkbeletölteni a változónkba:

változónév:=x;

Ilyen egyszerű.Most térjünk vissza egy icsit az eljárásokhoz.Az előbb azt írtam, hogy az eljárás paramétereivel általában azt határozhatjuk meg, hogy azeljárás hogyan csinálja, amit csinál.Most nézzük meg az előbbi p_2.pas kódot. Van a főprogramban egy eljáráshívás, a readln()eljárás.Ez az eljárás arra szolgál, hogy parancssorban hagyja, hogy beírj egy szöveget, és amikorentert nyomsz, a beírt szöveged bekerül a readln eljárás paraméterében megadott stringtipusú változóba.Na de hogyan csinálja?Mert az eddigiekből kiderülhetett, hogy ha egy elárásnak az paraméterében Nem konkrétértéket (pl. 52) adok meg, hanem egy változónevet, akkor az adott változó neve helyérebehelyettesítődik az értéke, és akkor az eljáráson belül nem tudjuk módosítani aparaméterben átadott változó értékét, ha megpróbáljuk, errort ír ki a fordító (próbáld csakki!).Ezért találták ki a cím szerinti paraméterátadást.Ennek az a lényege, hogy a paraméterben megadott (globális) változónak nem az értékehelyettesítődik be a helyére, hanem a címe.És akkor már tudjuk módosítani az értékét az eljáráson belül.De akkor az eljárás "létrehozásánál" (nem ez a jó kifejezés) a cím szerint átadandó paraméterelé oda kell írnunk a var kulcsszót.Ez így néz ki:

procedure eljárásnév(varcím_szerint_átadandó_paraméter_neve:cím_szerint_átadandó_paraméter_típusa;NEM_cím_szerinti_param2:típus);beginaz eljárás utasításai;end;

Remélem ez eddig érthető.A kulcsszavakat kiemeltem.Egyébként ha egy cím szerint átadandó paraméter helyére csak egy értéket írunk, és nem egyváltozónevet, akkor a fordító errort fog kiadni, és nem fordítja le a kódot.És nem írtam még az eljárások lokális változóiról.Ezek olyan változók, amelyek csak az eljáráson belül léteznek.Amikor meghívod az eljárást, létrejönnek, aztán amikor a program végrehajtása kilép azeljárásból, megsemmisülnek.Így lehet lokális változókat csinálni:

procedureeljárásnév(paraméter1:tipus;paraméter2:tipus;címszerintiparaméter1:típus);varlokális_változó1:tipus;lokális_változó_2:tipus;lokális_változó_3:tipus;lokális_változó_N:tipus;begin...end;

Ezek a lokális változók, mint mondtam, csak az aljáráson belül használhatóak, ha pl afőprogramban, vagy másik eljárásban próbáljuk mondjuk megváltoztatni vagy felhasználni azértéküket, a fordító errort ír ki. Próbáld csak ki!És ha már létezik egy globális változó, aminek ugyanaz a neve, mint egy eljárás lokálisváltozójának, akkor az adott eljárásban a globális változó megszűnik létezni, és helyette vana lokális.Persze ha annak megváltoztatjuk az értékét, attól a globális változó értéke nem változik.

Az eljárásokat egyébként önmagukon belül is meg lehet hívni, (ezt rekurziónak hívják), devigyázni kell vele, mert ha egy eljárás meghívja önmagát, az összes lokális változója újralétrejön, mégegy példányban.És ha egy eljárás mondjuk másodpercenként mondjuk 100szor meghívja magát, elég hamarbetelik a memória, és hibaüzenetet kapunk.

• Elágazások és kifejezések

Az elágazások arra jók, hogy egy megadott kódrészlet csak akkor hejtódjon végre, ha egybizonyos feltétel fenáll.Az ilyen feltételek a kifejezések.A kifejezések értéke lehet igaz, vagy lehet hamis.Ebből már leszűrhetted, hogy egy boolean tipusú változó értékadásakor is használhatszkifejezéseket.Egy kifejezés állhat olyan feltételekből, mint pl. egyik változó nagyobb vagy kisebb amásiknál, vagy egy változó kisebb egy megadott értéknél, vagy egyenlőek.Az egyes részfeltételeket zárójelek közé kell raknunk, és kapcslolatot is kialakíthatun köztük,pl hogy csak akkor legyen igaz a kifejezés, ha mindkét részfeltétel fennáll, vagy esetleg elégaz egyik, stb, lehet variálni.Na most megmutatom, hogyan lehet elágazást csinálni:

if (feltétel) thenbeginezek az utasítások akkor hajtódnak végre , ha a feltételfennáll (a kifejezés értéke Igaz (true))end elsebegin

ezek meg akkor, ha a feltétel nem áll fenn (a kifejezés értékehamis (false))end;

A kulcsszavakat kiemeltem.A részfeltételek pl. ilyenek lehetnek ( az if utáni zárójelek között):

x<10

(az x nevű integer változó értéke kisebb 10-nél)vagy

x>100

(az x nevű integer változó értéke nagyobb 100-nál)vagy

x=52

(az x nevű integer változó értéke egyenlő 52)vagy

x<=6

(az x nevű változó értéke kisebb mint 6, vagy 6-tal egyenlő)vagy

x>=6

(az x nevű változó értéke nagyob 6-nál, vagy egyenlő 6-tal)vagy

x=y

(az x nevű integer változó értéke egyenlő az y nevű ineger változó értékével)vagy

s='szöveg'

(s nevű string változó értéke egyenlő 'szöveg'-gel)Mint láthatjuk, a különböző adattípusú változókat öszehasonlítani nem lehet, pl az lehetetlenhogy egy string tipusú változó értéke egy integer szám legyen.pl ha a következő példában az s nevű változó típusa string, akkor ez lehetetlen:

s=50

próbáljuk ki, mi történik, ha különböző típusú változókat használunk egy részfeltételben, ésnézzük meg milyen errort ad a fordító, abból is lehet tanulni.Most pedig megnézzük, hogyan lehet a feltételek között logikai kapcsolatokat kialakítani.A programírás során gyakran előfordul, hogy egy kódrészletet akkor szeretnénk végrehejtani,ha több kifejezés (feltétel) értéke is igaz.Ezt úgy lehet megoldani, hogy a részfeltételeket (mi kissebb vagy nagyobb minél, mi egyenlőmivel, stb) külön-külön zárójelbe rakjuk, így (az if utáni zárójelek között):

(x<10)and(x>5)

Ha ez a feltétel, akkor a then utáni kódrész csak akkor fog végrehajtódni, ha az x nevűváltozó értéke 5 és 10 között van.És lehet olyat is, hogy egy kódrész csak akkor hajtódjon végre, ha legalább egy igaz afeltételek közül:

(x=10)or(x=20)

Ha ez a feltétel, a then utáni kódrész csak akkor fog végrehajtódni, ha az x nevű változóértéke 10 , vagy 20.És van még egy szó, amivel a kifejezések értékét meg lehet fordítani:

(not(x<10)

Ez olyan, mintha ezt írnánk:

x>=10

Vagyis ha a not szó utáni zárójeben lévő kifejezés értéke igaz, akkor hamis lesz, vagyfordítva.És ezekkel, mint mondtam, lehet variálni:

if (not((x<10)and(y=52)or(z<=100))) thenbegin...end elsebegin...end;

Próbáld megfejteni a feltétel értelmét :)Na, ha már ennyit tudunk, adok feladatot, mert a gyakorlat is fontos.1. Készíts egy programot, ami bekéri a nevedet, és ha nyomsz egy entert, kiírja, amit beírtál,kivéve akkor, ha azt írtad be hogy 'semmi', mert akkor azt írja, ki, hogy 'miért semmi?'.

• Ciklusok és alapműveletek

Gyakran előfordul, hogy egy kódrészletet többször végre szeretnénk hajtani.

Most nem arra gondolok, hogy kétszer egymás után, hanem mondjuk 1000szer.

Ilyenkor nem az a megoldás, hogy ezerszer leírjuk, amit végre szeretnénk hajtani, hanem az,

hogy ciklusokat használunk.

A ciklusok általában úgy működnek, hogy megadunk egy feltételt, és a ciklustörzsben

megadott utasítások addig hajtódnak végre újra meg újra, amíg a megadott feltétel fennáll.

A ciklustörzs a ciklusnak az a része, amiben az ismételni kívánt utasítások vannak.

Többféle ciklus létezik, itt most bemutatok néhányat.

1. Repeat-until

repeatez itt a ciklustörzs

...

until (feltétel);

A kulcsszavakat kiemeltem.

Ez a fajta ciklus úgy működik, hogy először végrehajtódnak a ciklustörzs utasításai, aztán

megnézi a program, hogy a feltételben megadott kifejezés értéke igaz-e, és ha igaz, a

ciklustörzset nem hajtja végre többször, hanem a ciklus utáni utasításokra ugrik.

Vagyis, ha többször nem is, de egyszer mindenképpen végrehajtódik a ciklustörzs.

Az ilzen ciklusokat hátultesztelős ciklusoknak nevezzük.

Példa (p_3.pas, fordítsuk le):

program repeat_until_pelda;

uses crt;

vara:integer;

beginrepeatwrite('szoveg');a:=a+1;until (a>10);end.

2. While-do

while (feltétel-kifejezés) dobeginciklustörzs...end;

Ez egy elöltesztelős ciklus, vagyis először megnézi, igaz e a megadott kifejezés ( a feltétel),és csak akkor fut le a ciklustörzs, ha a kifejezés eredménye IGAZ (TRUE).Példa (legyen mondjuk p_4.pas):

program while_do_pelda;

uses crt;

vara:integer;

begin

while (a<10) dobeginwrite('szoveg');a:=a+1;end;end.

3. For

for változó:=kezdőérték to meddig_futtassa dobeginciklustörzs...end;

Ez már kicsit bonyolultabb.Itt a for kulcsszó után értéket kell adnunk egy integer tipusú változónak, és a to kulcsszóután meg kell adnunk, meddig növelje a program a változó értékét.Egyébként a to helyett írhatunk downto-t, és akkor nem növelni, hanem csökkenteni fogja amegadott változó értékét.Itt egy példa (p_5.pas), ebből talán meg lehet érteni:

program for_pelda;

uses crt;

vara:integer;

beginfor a:=1 to 10 dobeginwrite('szoveg');end;end.

Észrevehetted, hogy mind a három példaprogram ugyanazt csinálja, kiírja a képernyőre10-szer egymás után hogy 'szoveg', de minden példában kicsit máshogyan.És két helyen is látunk ilyen értékadást: a:=a+1;Ez az utasítás növeli eggyel az a nevű integer változó értékét.Vagy úgy is mondhatnánk, az a nevű változóba beletölti az 'a+1' kifejezés értékét.

Ez kicsit olyan mint a matekóra.Vagyis egy matematikai kifejezésben használhatunk alapműveleteket:

összeadás:+kivonás: -szorzás: *osztás: /

A matematikai kifejezéseknek mindig egy integer vagy real tipusú szám az eredménye, nemúgy mint a logikai kifejezéseknél (true-false).A matematikai kifejezések felhasználhatóak feltételekben, integer, vagy real tipusú változóértékadásánál, vagyis minden olyan helyen, ahol egy számra van szükség.És természetesen a matematikai kifejezéseknél is lehet zárójeleket használni, mint ahogyanazt matekórán megtanulhattad, asszem másodikban.És itt most következzen egy példa (p_6.pas).

program matek_p;uses crt;vara:integer;begina:=5*5;write(a+(123-43*(a+5)));end.

Ja és integert osztani nem lehet, ugyhogy ha egy számot el akarunk osztani egy másikkal,legyen az adattípusa real.

És talán még nem mondtam, hogy a write() eljárás egy kakukktojás az eljárások között, mertbármennyi paramétert átadhatunk neki, és a paraméterek tipusa is mindegy.Ez a readln() eljárásra is igaz, de ha ott pl egy integerbe szeretnénk beolvasni egy számot, ésnem számot, hanem szöveget (stringet) írunk be, a program errorral kilép.Egyébként van a write() eljárásnak egy másik változata, a writeln(), ami annyiban különbözika write-tól, hogy a kiírás után a kurzort a következő sorba rakja, vagyis "nyom egy entert" akiírás után.És ha a writeln() eljárásna nem adunk át paramétert, akkor simán csak a következő sorelejére ugrik a parancssorban.És amit utána kiírunk, az már mind új sorba kerül.Na ennyi elég is egy fejezetbe.Adok feladatot, de a fantáziádra bízom, kísérletezz, próbálgass.

• Függvények és visszatérési értékekAz eljárások ugyebár arra jók, hogy ne kelljen újra megírnunk egy kódot ha egy kicsitmásképpen akarjuk végrehajtani.És most az eljárásonak egy új fajtájával ismerekedünk meg, ezek a függvények.Van úgy, hogy egy kifejezésben egy olyan értéket szeretnénk felhasználni, amit egyetlenváltozó sem tartalmaz, hanem ki kell számolni, más adatokból kell összeállítani.

Ilyenkor jól jön egy függvény, ami a meghívása után visszatér egy értékkel, és ez az értékbehelyettesítődik a meghívás helyére.Például így:if (keypressed()) thenbegin...end elsebegin...end;Ez esetben a then utáni kódrészlet csak akkor fog végrehajtódni, ha le van nyomva egybollentyű.Ez azért van, mert a keypressed() függvény (a függvények is eljárások, csak van visszatérésiértékük) visszatérési értékének a tipusa boolean, és ha le van nyomva egy billentyű, akkor azeljárás visszatérési értéke TRUE (igaz) lesz.De ha nincs lenyomva, akkor FALSE-t ad vissza, természetesen ilyen esetben az else utánirész hajtódna végre.Persze egy függvény visszatérési értékének a tipusa nem csak boolean lehet.Most nézzük, hogyan lehet ilyen függvényeket csinálni.A programnak ugyanabban a részébe írjuk, ahova az eljárásokat írtuk (a var és a globálisváltozók után), mert mint mondtam a függvények is eljárások, csak van visszatérési értékük.Így:

function függvénynév(paraméter1:tipusa; paraméter2:tipusa;címszerinti_paraméter1:tipusa;pareméterN:tipusa):visszatérési_érték_tipusa;var...begin...end;

Mint látható, annyi a különbség az eljárásokhoz képest, hogy a procedure kulcsszó helyettazt írjuk hogy function, és a paramétereket bezáró zárójel és a sorvégi pontosvessző közéodaírunk egy kettőspontot, majd a visszatérési érték adat-tipusát.Felmerülhetett a kérdés, egy függvényen belül hogyan tudjuk megváltoztatni a visszatérésiértékét?Hát a függvényen belül van egy speciális változó, (nem kell külön létrehoznunk!), aminek atípusa természetesen ugyanaz, mint a függvényünk visszatérési értékének a tipusa.Ennek a változónak mindig ugyanaz a neve, mint a függvényünknek.És ha értéket adunk neki, akkor azzal az értékkel fog majd visszatérni a függvény.Ezt egy konkrét példával jól lehet szemléltetni (p_7.pas):program osszeadas;

uses crt;

varmihez:integer;mit:integer;

eredmeny:integer;

function osszeadas(p_mihez:integer;p_mit:integer):integer;beginosszeadas:=p_mihez+p_mit;end;

beginwriteln('összeadó program');writeln('kérem az első számot:');readln(mihez);writeln('ok, kérem a másodikat:');readln(mit);eredmeny:=osszeadas(mihez,mit);writeln('az eredmény:');writeln(eredmeny);end.

Ez egy elég egyszerű kis program, de a céljának megfelel.Ebből láthatjuk, hogy ha a függvényen belül bárhol értéket adunk a függvénnyel azonos nevűváltozónknak, akkor a függvény azzal az értékkel fog visszatérni, persze nem azonnal, hanemmég lefut a teljes függvény.És egy függvény visszatérési értékét rengeteg helyen fel lehet használni.Majdnem minden olyan helyen használhatjuk, ahova egyébként egy konkrét értéket isírhatnánk, mint pl 50, vagy 'abcd'.És ha matematikai vagy logikai (főleg feltételeknél és boolean változóknál) kifejezésbenhasználunk függvényeket (akkor természetesen a visszatérési értékük heyettesítődik be ameghívásuk helyére), ügyeljünk arra, hogy a fügvény neve és a zárójelbe tett paraméterekután ne tegyünk pontosvesszőt.Szerintem ez egyszerű.És most adok feladatot:Az előző összeadó programot fejleszd tovább, úgy, hogy szorozni, osztani, és kivonni islehessen vele.Úgy képzelem el, hogy először bekéri a végzendő műveletet, aztán a két számot, és aztánírja ki az eredményt.És a változók tipusánál vedd figyelembe, hogy integert nem lehet semmivel se osztani, mertlehet hogy az eredmény már nem egész szám (integer) lesz.Ja!És legyenek a programban függvények.Sok sikert.

• Tömbök

Előfordul néha, hogy szükségünk van mondjuk 10000 darab változóra, mondjuk ha egy képetszeretnénk eltárolni a programunkban.De bajos lenne mind a 10000 változót külön létrehozni, a billentyűzet is tönkremenne. :)Ezért találták ki a tömböket.Egy tömbnek van egy neve, és több eleme, az elemek mennyiségét meghatározhatjuk.

És minden eleme ugyanúgy viselkedik, mint egy egyszerű változó.Egy tömb minden elemének ugyanaz az adattipusa, itt ugyanolyan tipusokat használhatunk,mint az egyszerű változóknál.Na nézzük, hogyan lehet tömböket létrehozni.A tömböket a főprogramnak (vagy egy eljárásnak vagy függvénynek) ugyanabban a részébenhozzuk létre, ahol az egyszerű változókat, vagyis a var kulcsszó után, így:

tömbnév:array[mettől..meddig] of elemek_tipusa;

Példa:

tomb:array[1..1000] of integer;

Ebben a példában létrehoztunk egy 'tomb' nevű tömböt, 1-től 1000-ig vannak megszámozva azelemei, és minden eleme integer tipusú.Az 1..1000 helyett megadhattunk volna 5..10-et is, és akkor 10-5, vagyis 5 eleme lenne atömbnek, 5 től tízig számozva.És ha egy tömb egyik elemének értéket szeretnénk adni, vagy fel szeretnénk használni azértékét, akkor tudatnunk kell valahogy a fordítóval, hogy melyik elemről van szó.Ezt úgy lehetséges, hogy a tömb neve után szögletes zárójelek közé írunk egy tömbindexet.A tömbindex egy integer (vagy byte) tipusú érték (egy egész szám), és azt mutataja, hogymelyik elemét szeretnénk elérni a tömbnek.És figyelembe kell vennünk, hogy ha pl van egy tömbünk 2-től 8-ig számozva, akkor atömbindex nem lehet mondjuk 1 vagy 9, hanem 2-től 8-ig kell megadnunk.Ez lényeges, mert ha hibás a tömbindex, runtime error lesz.Konkrétan így indexelünk egy tömböt:tömbnév[tömbindex]:=érték;És tömbindexnek megadhatunk egy egyszerű értéket:tomb[56]:=érték;vagy egy változót (integer vagy byte tipusút):tomb[változónév]:=érték;vagy egy matematikai kifejezést, ami tartalmazhat konkrét értékeket, vátozókat, ésfüggvényhívásokat is, pl:tomb[6000*5-(472+függvény(paraméter1,paraméter2))+változó]:=érték;De ha ilyen hosszú kifejezéseket használunk tömbindexnek, ügyeljünk arra, hogy a programfuttatása során semmiképpen se történhessen meg, hogy nemlétező tömbelemrehivatkozunk.Például ha van egy tömbünk 1-től 10-ig számozva, úgy írjuk a programot, hogy a megadottmatematikai kifejezés értéke is 1-től 10-ig legyen valamennyi.És még nem írtam a többdimenzós tömbökről.Ha úgy képzelünk el egy fentebb bemutatott, normál (egydimenziós) tömböt, mint egy hosszúsor csempét, akkor egy kétdimenziós tömböt úgy képzelhetünk el, mint egy csempékkelkirakott téglalapot.A többdimenziós tömbönek az a lényegük, hogy nem egy tömbndexük van, hanem több, azelőző csempés példában 2.A létrehozáskor is jelezni kell a fordítónak, hogy hány dimenziót szeretnénk.Így:

tömbnév:array[mettől..meddig,mettől..meddig,mettől..meddig] of tipus;

Mint itt látható, midegyik dimenzióhoz külön meg kell adnunk, hogy mettől meddig legyenszámozva, az értékeket vesszővel kell elválasztani.Elvileg bármennyi dimenziót megadhatunk, csak a billenyűzet, meg a kézizmok korlátozzák aszámát :).Persze általában nincs szükség 3-nál több dimenziós tömbökre.És ha egy többdimenziós tömb egyik elemének értéket szeretnénk adni, vagy fel szeretnénkhasználni az értékét, akkor a tömbindexeket is vesszőkkel kell elválasztanunk, pl így (ez egy3 dimenziós tömb):3Dtömb[index1,index2,index3]:=érték;Itt is érvényesek a fentebb leírt, tömbindexekre vonatkozó szabályok.Egyébként meg a többdimenziós tömbök ugyanúgy viselkednek, mint az egydimenzióstömbök.

• Rekordok

A rekordok arra jók, hogy különböző tipusú változókat foghatunk össze bennük egy csoportba.A rekordokból példányokat lehet létrehozni, a var szó utáni részben, ahol a többi változót islétrehozzuk.A rekordok példányainak elemváltozóik vannak, tehát a rekordváltozók is összetett változók.De mielőtt a var utáni részben saját változótipusként használhatnánk a rekordokat, létre iskell hoznunk őket, vagyis tudatnuk kell a fordítóval, hogy a létrehozott példányoknak milyenelemei legyenek.Ezt a var előtt, az uses kezdetű sor után tehetjük meg, ilyen módon:

type rekordnév=recordelemváltozó1:tipus;elemváltozó2:tipusa;elemváltozóN:tipusa;end;

A kulcsszavakat kiemeltem.Tehát amikor létrehozzuk magát a rekordot (Nem annak egy példányát), változókat hozunklétre, úgy ,mint a var szó utáni részben.

És a var utáni részben így lehet példányokat létrehozni:

varváltozónév:rekordnév;

Ekkor a létrehozott változónknak létrejönnek az elemváltozói.Ha egy rekordváltozó egyik elemváltozóját fel szeretnénk használni, vagy értéket szeretnénkneki adni, azt úgy tehetjük meg, hogy a változónév után ponttal elválasztva odaírjuk az adottelemváltozó nevét:

változónév.elemváltozónév:=érték;

És ha egy egész tömbnyi példányt szeretnénk létrehozni egy rekordból, akkor azt ugyanúgylehet, mintha a rekord neve egy adattípus lenne:

vartömbnév:array[mettől..meddig] of rekordnév;

És persze ha használni szretnénk egy ilyen rekordváltozó elemváltozóit, indexelnünk is kell atömböt:

tömbév[tömbindex].elemváltozó:=érték;

Szerintem ez nem bonyolult.És egy rekord egyik eleme is lehet rekord, ez fontos. De ha egy rekord (nem példány) egyikeleme szintén rekord, vigyázni kell arra, hogy a rekordban használt rekord a kódban előbblegyen létehozva, mint az a rekord, amiben használjuk.Ja és elfelejtettem eddig mondani, hogy pascalban nemcsak a változók lehetnek lokálisak,hanem a függvények, eljárások, és tipusok (vagyis rekordok) is, de ezek sorrendjéretermészetesen az ejáráson belül is vigyáznunk kell:1. rekordok (tipusok)2. változók (és rekordok példányai)3. eljárások és függvények4. az eljárás fő kódja (vagy a főprogram)

Következzék most egy konkrét példa rekordora (p_8.pas):

program csillagos;uses crt;

constcsillagszam=30;

type pos=recordx:integer;y:integer;

end;

type csillag=recordspeed:integer;color:integer;helyzet:pos;

end;

var

csillagok:array[1..csillagszam] of csillag;

procedure modosit();vari:integer;ok:boolean;

beginok:=false;for i:=1 to csillagszam dobeginif (csillagok[i].helyzet.x<80) thenbegin

csillagok[i].helyzet.x:=csillagok[i].helyzet.x+csillagok[i].speed;end elsebegincsillagok[i].helyzet.x:=1;csillagok[i].color:=random(15);repeatcsillagok[i].speed:=random(4);if (not(csillagok[i].speed=0)) thenbeginok:=true;

end elsebeginend;

until (ok);end;

end;end;

procedure ertekadas();vara:integer;ok:boolean;

beginfor a:=1 to csillagszam dobegincsillagok[a].helyzet.x:=random(80);csillagok[a].helyzet.y:=random(25);csillagok[a].color:=random(15);repeatcsillagok[a].speed:=random(4);if (not(csillagok[a].speed=0)) thenbeginok:=true;

end;until (OK);

end;end;

procedure kirajzol();vari:integer;

beginfor i:=1 to csillagszam dobegingotoxy(csillagok[i].helyzet.x,csillagok[i].helyzet.y);textcolor(csillagok[i].color);write('*');

end;end;

beginclrscr();randomize();ertekadas();repeatmodosit();kirajzol();delay(50);clrscr();

until (keypressed());end.

Ez egy látványos kis program, parancssorban indítsd, csillagokat fogsz látni.Érdemes jól átnézni, mert lehet belőle tanulni.

• Unitok

A unitokra (ejtsd junit) nem lehet azt mondani, hogy programok, mert önmagukban nemfutnak le, hanem más pascal programok írásakor lehet őket felasználni, mint pl a crt és mégsok más unitot.Egy unit eljárásokat, függvényeket, változókat, és rekordkat is tartalmazhat.Azért készítünk unitokat, hogy saját eljárásainkat, függvényeinket mások számára könnyebenhasználhatóvá tegyük.Ha használni szeretnénk egy kész unitot, mint már azt megírtam, az uses kulcsszó után odakell írnunk az unitfájl nevét.Mert a unitok is fájlok, és a kiterjesztésük asszem .ppu.Természetesen amíg nincsenek lefordítva, a unitok kiterjesztése is .pas.Na nézzük, miből is áll egy unit.Sokban hasonlít egy programra, de a lényege más.Egy unitot természetesen nem a program kulcsszóval kezdünk, helyette azt írjuk, hogy unit.Eddig a program kulcsszó után bármit megadhattál, de most fontos, hogy a unit kulcsszó utána unit fájlnevét add meg, persze kiterjesztés nélkül, és a sor végére persze pontosvessző.És mert a unitot programokban használjuk, a fájlnév nem tartalmazhat szóközt és különleges,pascalban használt karaktereket.Aztán jön a unit két fő része: az interface, és az implementation.

Ezeket a részeket természetesen az implementation és az interface kulcsszavakkal kelljeleznünk a fordítónak, és először mindig az interface rész jön.Az interface részbe azokat a dolgokat írjuk, amiket kívülről, a unitot később használóprogramból látni szeretnénk.Ha ide eljárásokat vagy függvényeket teszünk, azoknak csak a fejrészét kell ide írnunk,vagyis csak a 'procedure' vagy 'function' kulcsszóval kezdődő sorát.A függvény vagy eljárás többi részét (és a fejrészt is, mégegyszer) az implementation részbenkell megírnunk.Ha az interface részbe nem írjuk bele egy függvény vagy eljárás fejrészét, akkor az adotteljárás csak a unit többi eljárásában vagy függvényében lesz hasznáható, kívülről nem foglátszani.És ez igaz a változókra is, persze mivel a változóknak nincs fejrészük, elég őket egy helyrebeírni, ha kívülről láthatóvá szeretnénk tenni, akkor az interface részbe, ha pedig aztszeretnénk, hogy kívülről ne lehessen látni, akkor az implemetation részbe.Ez után a két rész után jön még egy programoknál is szokásos begin és egy end , aztán egypont.Ebben a részben pl kezdőértéket adhatunk a változóknak, és egyéb, a unit működéséhezszükséges műveleteket is elvégezhetünk.Na most megmutatom, hogyan is néz ki egy unit.Ez a példaunit alapműveletek végzésére használható (fájlneve:matek.pas):

unit matek;

interface

function osszeadas(mihez:real;mit:real):real;function kivonas(mibol:real;mit:real):real;function szorzas(mit:real;mivel:real):real;function osztas(mit:real;mivel:real):real;

implementation

function osszeadas(mihez:real;mit:real):real;beginosszeadas:=mihez+mit;end;

function kivonas(mibol:real;mit:real):real;beginkivonas:=mibol-mit;end;

function szorzas(mit:real;mivel:real):real;beginszorzas:=mit*mivel;end;

function osztas(mit:real;mivel:real):real;beginosztas:=mit/mivel;end;

beginend.

Remélem ebből a példából meg lehet érteni, hogy hogyan működnek a unitok.És remélem, működik is amit írtam :)

• Konstansok

Néha van úgy, hogy egy bizonyos számot (vagy stringet) több helyre is be kell írnunk a kódonbelül.Ha ilyenkor meg szeretnénk változtatni azt a bizonyos értéket, fárasztó dolog végigmenni azegész kódon, és kézzel kijavítani az érték mind a 26 előfordulását.Ezért találták ki a konstansokat. Az előbbi csillagos példában is találkozhattál konstanssal, acsillagok száma egy konstansban van eltárolva.A konstansok kicsit hasonlítanak a változókra, de csak egyszer, a létrehozásukor lehet nekikértéket adni, ezért állandóknak is nevezik őket.A konstansoknak nincsen adattipusuk, a fordító egyszerűen csak behelyettesíti az értéküket anevük helyére.Az uses kezdetű sor után hozhatjuk létre őket, így:

constkonstansnév1='string (szöveg)';konstansnév2=45;konstansN=34.58;

Tehát a const kulcsszóval jelezzük a fordítónak, hogy a konstansok következnek.Ez után minden konstansunkat használhatjuk a tipusok (rekordok) létrehozásától afőprogramig mindenhol.És itt láthatjuk, hogy az értékek megadásánál itt is ügyelni kell a helyes formátumra, plstringeket egyszeres idézőjelek közé írjuk, stb, lásd fentebb, a változótipusok táblázatában.

Egyébként nem csak az így létrehozott konstansokat nevezzük konstansnak, hanem mindenolyan értéket a programunkon belül, amit a program a futtatás során nem tudmegváltoztatni.Itt pl a változók értékadására gondolok, meg az if-eknél és ciklusoknál a feltételekban

szereplő számokra, stringekre, stb.Vagyis:

valtozo:="string";valtozo2:=43;tomb[13]:="szöveg";

Ebben a kórdészletben kiemeltem a konstansokat.Na most ugye jól meg kevertelek?Úgyhogy leírom: Konstansoknak nevezzük az olyan változókat, amelyeknek az értékét aprogram futása során nem lehet megváltoztatni, és konstansnak nevezzük a programunkbanszereplő egyéb konkrét értékeket is, amelyek egyébként szintén nem fognak megváltozni aprogram futása során.

Na mostmár naggyából átvettük a pascal nyelvet, úgyhogy ez után leginkáb gyakorlatidolgokat fogok leírni.

• A kódok rendezése

Ha sok kódot írunk, mondjuk 10-15000 sort, könnyen átláthatatlanná válhat az egész, ha nemrendezzük valahogyan.Mindenkinek másképp átlátható egy kód, de vannak általános szabályok.Legfontosabb, hogyha valamit begin-end blokkba írsz, akkor azt a részt kicst írd bejjeb, ésami azon belül is begin-end (vagy repeat-until, vagy más) blokkban van, azokat is írd egykicsit bejjebb.Egyszerűbb lesz ezt megenni, ha letöltöd a notepad++ nevű szövegszerkesztőt: innenEz az egyik legjobb forráskódszerkesztő, kiemeli a kulcsszavakat, és még rengetegszolgáltatása van.Ha npp-ban beljebb kezdessz egy kódrészt, akkor úgy is fogja folytatni, tehát sokkalátláthatóbb lesz.Próbáld ki.És vannak még a kommentek.Ezek olyan szövegek a forráskódban, amiket a fordító nem vesz figyelembe, és arra valóak,hogy magyarázzni, jelölni, vagyis kommentálni lehet velük a kódot.Három féle komment létezik:

kód();kód();{ez itt egy komment}kód();kód();//ez is kommentkód();/*és ez is*/kód();

Ezekről nemnagyon lehet többet mondani, az elsőhöz még annyit hozzátennék, hogy nemmindig komment, hanem a fordítónak is lehet átadni adatokat vele.Például ha egy programba az első sor (amejk a program kulcszóval kezdődik) elé beírjuk akövetkező kódot, akkor a programunk nem nyit DOS-os ablakot, vagyis láthatatlan lesz:

{$APPTYPE GUI}Ez néha jól is jön :)Azért jó kommentezni a kódokat, mert ha majd 2 év múlva megnézed, nem biztos, hogytudni fogod, mi mire jó benne.Ja és ha nem akarod a notepad++-t használni, van az FPC-nek egy saját szerkesztője, amiparancssoros felületű, nem túl kényelmes, de legalább nem kell parancssorba pötyögni afordító beállításait.Ez az FPC saját IDE-je, vagyis integrated developer environment asszem, magyarul integráltfejlesztési környezet.Ha el akarod indítani, akkor itt a helye: C:\FPC\2.2.2\bin\i386-win32\fp.exePersze lehet hogy a startmenü->allprogramsban is van egy FPC IDE bejegyzés.

• A crt unit

Mint mondtam, gyakorlati dolgokkal folytatom, úgyhogy nézzük, mi minden van a crt unitban(a teljesség igénye nélkül):

readkey()

Függvény.Visszatérési érték tipusa:char.Ez a függvény billentyűleütésre várakozik, és ha lenyomsz egy gobot akkor visszatéregy char tipusú értékkel, amiben a lenyomott billentyű található.Egyszerre csak egy billentyűt tud érzékelni, de azért hasznos.Egyébként amíg várakozik, nem történik semmi, a program futása szünetel,úgyhogy csak akkor érdemes meghívni, ha már le van nyomva egy billentyű, eztpedig a keypressed() függvénnyel ellenőrizhetjük.Itt egy példa (a c nevű változónk tipusa char):

if (keypressed()) thenbeginc:=readkey;end elsebeginc:='~';end;

Ez a kódrészlet arra jó, hogy ha le van nyomva egy billentyű, akkor a c nevűváltozóba beleírja, hogy melyik, ha pedig nincs lenyomva billentyű, akkor a cértéke '~' karakter lesz.

keypressed()

Visszatérési értékének tipusa boolean, és arra jó, hogy ha le van nyomva bármelyikbillentyű, akkor TRUE értékkel tér vissza, ha pedig nincs lenyomva billentyű, akkorFALSE-val.

textcolor(color:integer)

A továbbiakban kiírandó szöveg szinét állítja be.Vagyis ha meghívjuk ezt az eljárást valamilyen színkóddal, akkor onnantól fogva awrite() és a writeln() eljárás olyan színnel fog írni.Persze amit eddig kiírtunk, annak nem változik meg a szine.Sajnos csak 16 féle színt használhatunk parancssorban, és minden színhez tartozikegy integer szám, ezt kell paraméterben átadni az eljárásnak.A színkódok:

0 - fekete1 - Kék2 - Zöld3 - Türkiz4 - Piros5 - Lila6 - Barna7 - Világosszürke8 - Sötétszürke9 - Világoskék10 - Világoszöld11 - Világostürkiz12 - Világospiros13 - VilágosLila14 - Sárga15 - Fehér

Egyébként ha egy színkódhoz hozzáadsz 128-at, és beállítod szövegszínnek, a kiíírtszöveg villogni fog, + magadott szinű lesz.

textbackground(color:integer)

Ezzel az eljárással a szöveg háttérszinét lehet változtatni, ugyanúgy, mint atectcolor()-ral a szöveg szinét, de itt csak az első 8 színt használhatjuk.

clrscr()

Ez az eljárás annyit csinál, hogy letörli a szöveges (gy.k.:parancssor) képernyőt.Vagyis teleírja szóközökkel, a jelenlegi háttérszínnel.

gotoxy(x:integer;y:integer)

Ezzel az eljárással "ugrálhatunk" a szöveges képernyőn.Mint azt illik tudni, alapból a szöveges képernyő 25 sorból áll, és minden sorban 80karakter van alapból.A gotoxy()-nak pedig megadhatjuk, hogy hanyadik sorba(y), és a soron belülhanyadik karakterre (x) szeretnénk rakni a szövegkurzort.Vagyis attól fogva a write() és a writeln() oda fog írni.

delay(s:integer)

Megadott mikroszekundumra (ezredmásodpercre) felfüggeszti a program futását.Amíg az eljárás fut, semmi nem történik, ezért programok lassítására ishasználható.

sound(hz:integer)

A gép belső hangszóróján megadott frekvenciájú hangot hallat.De csak csipogni tud.A sípolást a nosound() eljárás maghívásával lehet leállítani.

textmode(mode)

Beállít egy szöveges módot.Ezeket a konstansokat lehet megadni:

BW80 - fekete-fehér, 80 oszlop, 25 sorCO40 - színes, 40 oszlop, 25 sorCO80 - színes, 80 oszlop, 25 sorBW40 - fekete-fehér, 40 oszlop, és 25 sor

readln(string)

Egy sor szöveget lehet vele beovasni a parancssorból, a megadott string (vagy más)tipusú változóba.

random(max:integer)

A visszatérési értéke egy integer, ami véletlenszerű, de paraméterben meg lehetadni, hogy max mennyi legyen.Vagyis ez egy véletlenszám-generátor, bár elég bizonytalan a működése.Mielőtt használnánk a programban, meg kell hívnunk a randomize() függvényt, ezinicializálja, vagyis beüzemeli.

Na szerintem ennyi elég is, a write() és writeln eljárásokat azért nem írtam ide, mert úgyistudjuk, mire valóak.És most adok feladatot:Készíts egy olyan programot, ami el tudja tárolni tetszőleges számú személy nevét,telefonszámát, foglalkozását, és e-mail címét.És ezeket az adatokat parancsokkal lehessen olvasni és módosítani.Sok sikert.

• File-kezelés

Gyakran szükséges elmenteni néhány adatot, hogy a program legközelebbi indításkor isemlékezzen rá.Ilyenkor szokás az adatokat kiírni fájlba.Most a szöveges fájlok kezelésével fogunk foglalkozni.A szöveges fájlok kezeléséhez van egy külön változótipus, a TEXT.Legalább egy ilyen változót létre kell hoznunk a fájlkezeléshez.Ha szeretnénk valamit kezdeni egy fájllal, előszöris hozzá kell rendelnünk egy TEXT tipusúváltozóhoz.Ezt az assign() eljárással tehetjük meg.Ennek az eljárásnak az első paramétere egy TEXT tipusú változó, amibe az eljárás beltölti afájlt, a második paraméter pedig string tipusú, és a fájl elérési útját kell benne megadnunk.Az elérési út lehet teljes (pl. 'C:\mappa\file.txt'), vagy lehet relatív (pl 'mappa/file.txt' vagy'file.txt').A relatív elérési útnál mindig az aktuális könyvtárhoz (parancssorból ismerős lehet ) képestkell megadnunk a fájl elérési útját.Ha ezzel megvagyunk, meg kell nyitnunk a fájlt.Ezt 3féleképpen lehet:

olvasásra: reset(fájlváltozó)írásra: rewrite(fájlváltozó)hozzáírásra: append(fájlvátozó)

Mindegyik módhoz tartozik egy eljárás.Ha ezel megvagyunk, olvashatjuk vagy írhatjuk is a fájlt.Természetesen ha egy fájlt olvasásra nyitottunk meg, nem tudunk bele írni, és ez fordítva isigaz.Ha egy fájlt írásra nyitunk meg, az egész tartalma törlődik, és csk az lesz benne, amitbeleírunk.Ha nem szeretnénk kitörölni egy fájl tartalmát, akkor hozzáfűzére nyissuk meg, és akkor abeleírt szöveg hozzá fog fűződni az eddigi tartalmához.A fájlokat is a writeln() és a readln() eljárásokkal írhatjuk és olvashatjuk.Mégpedig úgy, hogy (ez mindkettőre vonatkozik) első paraméternek a fájlváltozónk nevétadjuk meg, második paraméternek pedig egy string tipusú változót, aminek a tartalmát awriteln() a fájlba írja, vagy a mibe a readln() beolvassa a fájl egy sorát.Persze ha a fájl végére értünk, és még mindig olvasni szeretnénk belőle, error lesz, ezértmielőtt olvasnánk egy fálból, mindig nézzük meg, van-e tovább.Ezt az EOF(fájlváltozó) függvénnyel tehetjük meg, aminek a visszatérési értéke csak akkorTRUE, ha a fájl végére értünk.Most pedig jöjjön egy példa:

program file_pelda;uses crt;varmyfile:TEXT;s,filename:string;beginwriteln('fájlnév:');readln(filename);assign(myfile,filename);rewrite(myfile);writeln('kilépéshez írd be az exit keraktersorozatot');repeatreadln(s);writeln(myfile,s);until s='exit';close(myfile);end.

És persze a végén le kell zárni a fájlt a close() eljárással, ekkor kerül ki a fájl ténylegesen amerevlemezre.Egyébként ha egy fájlt írásra (vagy hozzáfűzésre) nyitsz meg, és nem létezik, létrejön.Na erről ennyi elég.

• Animáció

Most az animációkészítés, vagyis naggyából a játékírás következik.Az a lényeg, hogy a programnak csak akkor legyen vége, ha egy olyan esemény történik, amikilépteti.Ez naggyából annyit jelent, hogy az egész program fő része egy repeat-until ciklus.Valahogy így írható le szavakkal:1. Kirajzolunk mindent a képernyőre2. Megnézzük, van-e billentyűzetlenyomás, egérkattintás, stb, ha van feldolgozzuk3. Szükség szerint megváltoztatjuk a változók értékét, ha szükséges, beállítjuk, hogy lépjenki4. várakozunk (delaz())4. Mindent letörlünk a képernyőről (ez a lépés bizonyos esetekben kihagyható)5. Ha nem kell kilépnünk, az első lépéstől megismételjük az egészet

Ez persze csak azoknál a mozgalmas animációknál (pl játékok) érvényes, ahol folyamatosanváltozik a kép.Mert pl egy szövegszerkesztőnél fölösleges lenne hogy másodpercenként 100szor újrarajzoljaa képet.És másik alapszabály, hogy minden olyan "tényt" el kell tárolnunk változókban, amit másbólnem tudunk kiszámítani, pl dolgok kordinátáit a képernyőn, stb.Nos, most lássunk egy konkrét példát.Most egy szöveget fogunk jobbra-balra mozgatni a parancssorban:

program animacio;uses crt;varx:integer;szoveg:string;elore,szunet:boolean;key:char;

beginclrscr();writeln('kérem a szöveget:');readln(szoveg);writeln('space:szünet. Q:kilépés');delay(2000);repeatgotoxy(x,12);write(szoveg);if (keypressed()) thenbeginkey:=readkey();

end elsebeginkey:='~';

end;if (key=' ') then

beginif (not(szunet)) thenbeginszunet:=TRUE;

end elsebeginszunet:=false;

end;end;if (not(szunet)) thenbeginif (x<2) thenbeginelore:=TRUE;

end;if (x>70) thenbeginelore:=FALSE;

end;if (elore) thenbeginx:=x+1;

end elsebeginx:=x-1;

end;end;delay(50);clrscr();

until key='q';end.

Na ez csak egy példa, lehet még kísérletezgeni.És adok feadatot!:Csinálj egy ehhez hasonló animációt, de a szöveg ne jobbra-balra menjen, hanem "kockaalakban".Vagyis jobbra-le-balra-fel-jobra-le-balra-fel...Soksikert.

• Grafika - alapok

Eddig a programjaink csak a parancssor segítségével tudtak kommunikálni a külvilággal, demost megmutatom, hogyan lehet grafikus inerfészt használó (GUI) programokat csinálni a

wingraph unit segítségével.A unit innen tölthető le: wingraph_for_FPC_2.2.2.zipA wingraphhonlapja: http://math.ubbcluj.ro/~sberinde/wingraph/main.htmA legjobb ha a letöltött zip teljes tartalmát kimásoljuk a munkakönyvtárunkba, ugyanoda,ahol az a forráskód található, amiben majd használni szeretnénk a unitot.A továbbiakban ezt a kódot fogjuk elemezni:

{$APPTYPE GUI}program winablak;uses wingraph,wincrt,winmouse;var gd,gm:smallint;

x,y,oldal:integer;beginSetWindowSize(500,500);gd:=d8bit;gm:=mCustom;InitGraph(gd,gm,'Ablaknev');setrgbpalette(1,0,200,0);setcolor(1);x:=1;y:=500;oldal:=1;repeatline(250,250,x,y);if (oldal=1) thenbeginy:=y-1;end;if (oldal=1) and (y<2) thenbeginoldal:=2;end;if (oldal=2) thenbeginx:=x+1;end;if (oldal=2) and (x>498) thenbeginoldal:=3;end;if (oldal=3) thenbeginy:=y+1;end;if (oldal=3) and (y>498) thenbeginoldal:=4;end;if (oldal=4) thenbeginx:=x-1;end;

if (oldal=4) and (x<2) thenbeginoldal:=1;end;delay(20);cleardevice();until (keypressed());CloseGraph();end.

Az a baj vele, hogy néha nyit ablakot, néha meg nem, és olyankor "runtime error 201"hibaüzenettel tér vissza. Ezért úgy fordítsuk le, hogy elindítjuk az FPC IDE-t, és azon belülnyissuk meg a kódunkat a file->open menüponttal, és nyissuk meg az options->compilermenüpontot (fent). Az előjövő "ablakban" kattintsunk a "generated code" fülre, és az ablakbal oldalán levő területen tegyük inaktívvá a "range checking" opciót, vagyis kattintsunk a"Range checking" szöveg mellett lévő kis x-re, hogy eltűnjön. Ez után klikk az OK gombra,aztán a fordításhoz válasszuk a compile->compile menüpontot (fent). Ha kész a fordítás,megjelenik a "press any key to continue" felirat, úgyhogy nyomjunk meg 1 gombot, és alefordtott program futtatásához válasszuk a run->run menüpontot (felül).Ekkor nyílik egy gyönyörű windows ablak, van benne egy animáció (fordítsd le és meglátod :), majd billenytyűleütésre bezáródik.Mielőtt rajzolnánk valamit a képernyőre (egy ablakba), "be kell üzemelni", vagyis inicializálnikell a wingraphot.Ezt az InitGraph() eljárással tehetjük meg, aminek van három paramétere.Az első a színmélység, vagyis azt mutatja meg, hány színnel tudunk majd rajzolni.Itt (a wingraph unitban levő) konstansokat adhatunk meg, a fontosabbak ittvannak:

Konstans neve JelentésD1bit 2 féle szín

D4bit 16 szín

D8bit 256 szín

Detect A Detectgraph() függvént használja aszínmélység megállapításához

HercMono D1bit

VGA D4bit

SVGA D8bit

Az initgraph() második paramétere a használni kívánt felbontás, itt megadhatunkkonstansokat is, de be lehet állítani tetszőlegesen is, a setWindowSize() eljárással.Ha "kézzel" állítjuk be a felbontást, akkor az initraph másodikparaméterének mCustom-nakkell lennie.Itt vannak a megadható felbontások:

Konstans neve Jelentés

m320x200 320 x 200 pixel

m640x200 640 x 200 pixel

m640x350 és így tovább...

m640x480m720x350m800x600m1024x768m1280x1024

mDefault alapértelmezett méret, amit a windows admeg

mMaximized teljes képernyős ablak, a startmenüteltakarja, de van fejléce bezárógombbal

mFullScr teljes képernyő, ablakfejléc nélkül

mCustom ezt akkor használjuk, ha az ablakunk méretéta setWindowSize() eljárással adjuk meg

HercMonoHi ugyanaz, mint az m720x350

VGALo m640x200

VGAMed m640x350

VGAHi m640x480

Az initgraph harmadik paramétere egy string, az ablakunk címsorában szereplő szövegetadhatjuk meg vele.Az első két paraméter megadásakor ügyeljünk arra, hogy ne közvetlenül a használni kívántkonstansunk nevét írjuk az eljárás paraméterének helyére, hanem integer tipusú változókhozrendeljük hozzá az adott konstansok értékét, és azokat a változókat adjuk át paraméterbenaz eljárásnak.Ha nem így csináljuk, nem fog lefordulni.Ha a setWindowSize() eljárást használjuk a felbontás (ablakméret) beállítására, azInitGraph() második paraméterében átadott változó értéke legyen mCustom(valtozo:=mCustom;).Ha már van ablakunk, be kell állítani a használandó színt is.

A színkezelés wingraphban úgy működik, hogy van egy paletta, amin van (asszem:) 255 féleszín.Minden színnek van egy száma, és minden színnek külön beállíthatjuk a vörös (Red), zöld(Green), és kék (Blue) ősszetevőket.Ha egy színnek mind a három összetevője a maximumon van, akkor a szín fehér lesz, ha pedigminden összetevője a minimumon van, akkor fekete lesz.Egy szín összetevőit a setRGBpalette() eljárással tudjuk megváltoztatni, az első paraméter abeállítandó szín száma, a további három paraméterben pedig a szín R,G, és B összetevőinekmennyiségét adhatjuk meg.Minden összetevőből maximum 255 lehet.

Ha egy színnel rajzolni szeretnénk, akkor be kell állítanunk a színt rajzolószínnek, ezt asetColor() eljárással tehetjük meg, aminek egy paramétere van, amivel a használni kívántszín számát adjuk meg. Persze csak olyan színeket állíthatunk be ezzel az eljárással, amiknekelőzőleg beállítottuk az összetevőit a setRGBpalette() eljárással.

Na, ha már nyitottunk ablakot (az InitGraph megívása után már nyílik is az ablak), ésbeállítottuk a színt, rajzolhatunk is valamit.Ehhez vannak eljárások, amelyek különböző alakzatokat raknak ki a képernyőre.A fontosabb rajzoló eljárásokat ide összegyűjtöm:

Eljárás neve leírása

line(x1,y1,x2,y2:integer)

Egyszerű, egyenes vonalakat rajzolhatunkvele.Az első két paraméter a vonal egyik végénekaz x és y kordinátája, a két másodkparaméter meg a vonal másik égének akordinátáit adja meg.

PutPixel(x,y:integer) Egy pixelt lehet vele kirajzolni aképernyőre, a megadott kordinátákra.

rectangle(x1,y1,x2,y2:integer)Téglalapot lehet vele rajzolni, a balfelső ésjobbalsó sarkának lehet megani akordinátáit.

circle(x,y:integer;r:integer) Rajzol egy kört, a kör középpontját az elsőkét paraméterben megadhatjuk.

Ezek az eljárások a hozzájuk tartozó alakzatokat mindig az aktuális színnel rajzolják, amit asetColor() eljárással állítottunk be.

A képernyőt le is lehet törölni (teljesen feketére), a cleardevice() eljárásal, de majd késsőbbmeglátod hogy ez nem ajánlatos, mert nagyobb alkalmazásoknál villogni fog a képernyő, ésaz nagyon idegesítő dolog.

Az animációkészítésre vonatkozó dolgokat már leírtam, ezek érvényesek itt is, de méghozzátenném, hogy nem muszály túl gyakran újrarajzolni a képernyő képét, elég akkor is, havalami megváltozott.

Ha pedig már nincs szükségünk a grafikus ablakunkra, be is zárhatjuk a closegraph()eljárással.De persze akkor is bezáródik az ablak, ha a program leáll.

Egyébként ha wigraphos alkalmazást írunk, a crt unit helyett használjuk a wincrt unitot, eztis beleraktam a wingraphot tartalmazó zip-be.Ez azért jobb, mert akkor is érzékeli a billentyűzetet, ha a grafikus ablak aktív, mert nem aparancssorablakba várja a bilentyűleütéseket.

Most pedig adok feladatokat:1. Csinálj egy animációt, ahol véletlen méretű, kordinátájú és színű körök keletkeznek,nagyobbodnak (véletlenszerű méretig), majd eltűnnek, és újak keletkeznek.2. Csinálj egy "képernyővédő" animációt, ami teljes képernyőn fut, és véletlenszerű helyzetű,

méretű, és szinű vonalakat rajzoljon, amik lefelé csúsznak a képernyőn, majd eltűnnek.

• Dupla-pufferes grafika

Mint már leírtam, nagyobb alkalmazásoknál villog a képernyő ha folyton letöröljük azegészet.Ha megírtad az előbbi feladatokat, láthatod, mit jelent ez. Szeritem nagyon idegesítő.Most nézzük, hogyan lehet ezt kiküszöbölni.Ennek az az oka, hogy animáció készítésekor eddig mindig letöröltük a teljes képernyőt arajzolás és pár ezredmásodperc várakozás után.Aztán meg megint újrarajzoltuk az egészet, másképp, aztán kezdődhet előlről, vagy kilépés.A képernyő letörlésével nem volna baj, csak az a probléma, hogy ilyenkor a wingraph unitszépen végigmegy minden pixelen, és feketére változtatja a szinét.És ez meg is látszik a képernyőn. Igaz hogy nem tart sokáig, csak néhány századmásodpercig,de a számítógépnél az nagyon is sok idő. De a legfőbb baj nem az, hogy letörli, hanem az,hogy közvetlenül a képernyőt törli le.Az lenne az ideális, ha a rajzoló utasítások nem közvetlenül a képernyőre rajzlnának, hanema memóriába, egy kétdimenziós tömbbe (minden eleme egy rekordpéldány, r,g,b elemekkel), ami a képernyőt jelképezné.Aztán amikor befejeztük a rajzolást, az egész 2D tömb tartalmát pixelenként kimásolnánk aképernyőre, és akkor nem lenne fekete villanás.És akkor már nyugodtan letörölhetnénk a képernyőt, mert csak a 2D-s tömb tartalmatörlődne, a képernyőn ottmaradna a kép.

Mindez szép és jó is, csak meg is kéne valósítani. Úgyhogy majd folytatom.