Lineáris és objektumorientált programozási alapismeretek. Varga Zsolt

Lineáris és objektumorientált programozási alapismeretek Varga Zsolt

2006

A modulfüzet alapadatai SZAKMACSOPORT

Informatika

SZAKMA

Multimédiafejlesztő

MODUL

Lineáris és objektumorientált programozási alapismeretek

2

Bemeneti követelmények ·

Számítástechnikai és multimédia alapismeretek modul teljesítése

·

Integrált irodai programcsomag használata modul teljesítése

·

Internet felhasználói ismeretek modul teljesítése

·

Multimédia szabványok modul teljesítése

·

Számítógépes grafika modul teljesítése

·

Hagyományos és elektronikus kiadvány szerkesztés modul teljesítése

·

Mozgókép és hangszerkesztés

A modul célja A hallgató a lineáris és objektumorientált programozási alapismeretek modul elvégzése után képes legyen valamely magas szintű programnyelven, objektumorientált programnyelven és valamely szkirpt nyelven történő problémamegoldásra. Ismerje és alkalmazza a programozással kapcsolatos alapfogalmakat, használja az alapvető vezérlőszerkezeteket, ciklikus programozási megoldásokat és alapvető algoritmusokat, képes legyen kezelni a különböző multimédia asseteket. Ismerje és használja a mozgókép és hangszerkesztéshez kapcsolódó szakkifejezéseket magyarul és angolul A modul időtartama 60 óra

A modul során elsajátított kompetenciák ·

Aritmetikai, logikai és bitműveletek alkalmazása

·

Nyelvi elemek rendeltetésszerű használata

·

Lineáris programozási módszerek alkalmazása

·

Moduláris programozási technikák alkalmazása

·

Objektumorientált programozási technikák alkalmazása

·

Eseménykezelés

·

Multimédia assetek kezelése

·

Navigációs sémák programozása

·

Interaktivitás programozása

A modulban alkalmazott értékelési módszerek

2

·

Önellenőrzés (kompetenciánként)

·

Egyéni gyakorlat (kompetenciánként)

·

Részteljesítés (a modul során)

·

Modulzáró vizsga

A modul témakörei

Sorszám (eredet)

Témakör

Oldalszám

Időtartam (órában)

1

Aritmetikai, logikai és bitműveletek alkalmazása

5

8

2

Nyelvi elemek rendeltetésszerű használata

33

10

3

Lineáris programozási módszerek alkalmazása

64

15

4


101

3

5

Objektumorientált programozási technikák alkalmazása

114

13

6

Eseménykezelés

151

2

7

Multimédia assetek kezelése

158

4

8


173

2

9


183

3

3

Aritmetikai, logikai és bitműveletek alkalmazása Bevezetés Tisztelt Hallgató! Azzal az elhatározással készült ez a modulfüzetet, hogy megkedveltesse Önnel a programozást, és egyszerűbb programokat Ön is el tudjon készíteni. A lineáris programozás talán az egyik legnehezebb feladat, nem elegendő hozzá pár nap vagy pár hét, esetleg néhány hónap tanulás. Ahhoz, hogy teljes mértékben elsajátítsa a programozás tudományát; felkészülésre, érési időre van szükség, és persze rengeteg gyakorlásra. Javasoljuk, hogy úgy készüljön fel a modulfüzetet használva, hogy az egyes fejezeteket olvassa el, a fejezetek végén lévő feladatokat végezze el, majd válaszoljon az „önellenőrzés” kérdéseire. Kivétel nélkül mindegyikre. Itt ellenőrizheti a megszerzett tudást, hogy sikerült-e megértenie, elsajátítania a kitűzött célokban megjelölt ismereteket, készségeket. Ha valamelyik kérdésre nem sikerül válaszolnia, akkor lapozzon vissza, és keresse meg a kérdéshez tartozó a választ. A tanulási feladatok elvégzése után a hallgató: · Ismerni fogja a programozás rövid történetét · Ismerni fogja az alapvető aritmetikai műveleteket · Ismerni fogja a Boole-algebra alapvető kritériumait, igazságtábláit · Ismerni fogja az alapvető bitműveleteket · Meg tud oldani logikai kifejezéseket Rész célkitűzések 1. Bevezetés a programozási nyelvek történetébe 2. Aritmetikai alapismeretek 3. Relációs műveletek: összehasonlítás 4. Logikai függvények 5. Bitműveletek: forgatás

1. Bevezetés a programozási nyelvek történetébe Kezdetben a számítástechnika korszakának elején (1950-es évek) elsősorban a hardvernek tulajdonítottak nagyobb jelentőséget, hiszen akkoriban sokkal nehezebb volt a számítógép összeállítása és üzemeltetése, mint manapság. Akkoriban csak a hozzáértő szakemberek férhettek hozzá a számítógépekhez és pont ezért nem az volt a cél, hogy felhasználóbarát programokat írjanak. A technológia fejlődésével a hardver egyre megbízhatóbbá és olcsóbbá vált, ami fokozatosan eljutott egyre több kisebb céghez és mára már a hétköznapi emberekhez is. Ezzel a felhasználók köre megváltozott és a profik helyett már a 2-3 éves gyerekek is játszhatnak egyszerűbb nekik szóló számítógépes játékokat, nézhetnek mesefilmet a monitoron. Tanárok, orvosok, titkárnők, pékek, esztergályosok, portások és szinte mindenki joggal várja el, hogy saját különböző céljaikra a lehető legkényelmesebben tudja felhasználni, a legkevesebb tanulással. Mivel a számítógép hardvere csupán egy halom vas és műanyag, ami önmagától semmi értelmes dologra nem képes, a fent említett hatalmas felhasználói igényeket a programoknak (szoftvereknek) kell biztosítani. A számítástechnika története során tehát a hangsúly áthelyeződött a hardverről a szoftverre. Mára a szoftvergyártás (vagyis a programozás) jelentős iparággá nőtt. A programfejlesztő művészek korszaka véget ért és ma már szoftverfejlesztő iparosok léptek a helyükbe. 1950-es évek elején készült el Neumann János tervei alapján az EDVAC nevet viselő számítógép, amely az első Neumann-elvek alapján épített gép volt. Innen kezdődik a programozási nyelvek története. Kezdetben a programozási nyelvek nagyon közel álltak a gépi problémamegoldás logikájához, a programozás tulajdonképpen nem volt más, mint a gépnek adott utasítások sorozatának leírása, amely a gép nyelvén történt. Az első programok megírása igen sok időt vett igénybe, nem beszélve arról, amikor a programot javítani, módosítani kellett. A ’60-as években egyre több számítógép került a nagyvállalatokhoz, ahol már nemcsak a számítások elvégzése volt az igény, hanem más, nem csak számolást igénylő feladatot is meg szerettek volna oldani. A hosszú, nehéz munkával készített programok igen gyorsan elavultak, és máris lehetett hozzákezdeni a következő írásához. Tehát új, gyorsabb, egyszerűbb programfejlesztési módszerekre volt szükség. Ebben az időben jelentek meg az első magas szintű programozási nyelvek, amelyek az emberi gondolkodáshoz közelebb álló logika alapján próbálták a problémákat megközelíteni. A fejlesztések, kutatások eredményeképpen új programozási módszerek, technikák, filozófiák jelentek meg. Megjelentek az általános célú és a specializált programozási nyelvek, a ’70-es évek elején új módszerként jelentkezett a strukturált programozás. A ’90-es évekre komoly teret nyertek a számítógépek az élet valamennyi területén. Komoly igény volt arra, hogy a szoftverpiac követni tudja az egyre szélesebb körű igényeket, tehát új

4

5

eszközökre volt szükség, amelyek segítségével a programozók gyorsan tudnak hatékony és megbízható alkalmazásokat írni. A gyors programfejlesztés céljait egy az emberi gondolkodáshoz közel álló módszer teszi lehetővé, ugyanakkor a programnak nem szabad hatékonyságát elveszítenie, tehát minél elemibb egységekből kell felépíteni. Mindkét igényt kielégítette az objektumorientált programozási technika, amely a valódi tárgyakhoz hasonlóan képes kezelni a rendszer absztrakt elemeit. Azaz a programozónak rendelkezésére állnak az előre definiált programelemek, amelyekből összeállíthatja a működőképes programot, természetesen az egyes elemek tulajdonságait a programozó tetszése szerint módosíthatja. Az évek során igen sok programozási nyelv alakult ki, amelyeket szemléletük, fontosabb jellemzőik alapján négy generációba soroltak.

Első generációs programozási nyelv Az első programozási nyelv a gépi kód volt. Ennek a nyelvnek az utasításait a számítógép képes volt közvetlenül, minden átalakítás nélkül végrehajtani, értelmezni. A problémákat nagyon precízen kellett megfogalmazni, lépésekre bontani. Emellett a nyelv erősen gépfüggő volt, hiszen minden gépen más és más utasításokat használt, az adott problémát minden géptípus esetén másképpen kellett leírni, megfogalmazni, alkalmazkodva a számolóegység sajátosságaihoz. Hátrányai mellett néhány előnyt is illik megemlíteni: · A leggyorsabb programot eredményezi, mivel nem tartalmaz felesleges utasításokat. · Az egyes utasítások egységes (egy vagy kétcímes) formában vannak leírva. Példa egy gép kódú utasításra: 0B0A 0C0E 0D00

(Az első négy helyen az utasítás, majd az első memóriacím, és ezt követi a második memóriacím.) A gépi kódú lehetőségekhez képest komoly előrelépést jelentett az Assembly nyelvek megjelenése, amelyek tulajdonképpen segédeszközt jelentettek a gépi kódú utasítások egyszerűbb megfogalmazásában. Az egyes gépi kódú utasításokhoz egy-egy mneomnikus kódot rendeltek hozzá, a tárcímeket pedig a memória kezdetéhez viszonyított relatív címekkel számították. Szintén újdonságnak számított, hogy az egyes memóriacímeket egy-egy szimbolikus névvel lehetett helyettesíteni.

A számítógépek alkalmazási területének bővülése szükségessé tette a programok fejlesztési idejének csökkentését, azaz felmerült az igény, hogy a programokat minél gyorsabban írják meg a programozók. A gépi kód és az assembly nehézkessége, géphez igazodása miatt nem volt erre alkalmas. A 60-as évek elején jelentek meg az első magas szintű programozási nyelvek. Az új nyelvek struktúrája már nem a számítógép sajátosságaihoz, hanem a problémához igazodott, a programozóknak itt már nem kellett a gépi végrehajtással foglalkoznia. A magas szintű programozási nyelvek 1:N típusú nyelvek, azaz egyetlen magas szintű programnyelvi utasítás több gépi kódú utasítást reprezentál. Természetesen a magas szintű nyelven írt programokat is le kell fordítani - az Assembly-hez hasonlóan - de komoly előny, hogy ezeknél a nyelveknél már sokkal kisebb a hibalehetőség, a forrásprogram sokkal áttekinthetőbb. Néhány II. generációs programnyelv: ·

ALGOL

·

COBOL

·

BASIC

BASIC A BASIC nyelv kialakulása a programozási nyelvek fejlődésének bölcsőjéhez vezet vissza, amikor a magyar származású Kemény János és munkatársa, Thomas Kurtz elhatározták, hogy kidolgoznak egy olyan programozási nyelvet, amelynek segítségével a programozás könnyen oktatható és tanulható. A köztudatban a BASIC nyelv a kezdő programozók nyelveként vált ismertté. A fontosabb változatok a QUICK BASIC, GFA BASIC, MS-BASIC, és a Pascal elemet is tartalmazó VISUAL BASIC. A változatok közül egyedül a VISUAL BASIC-et tekintjük strukturált programozási nyelvnek, a programblokkok és eljárások, függvények kezelése miatt.

Harmadik generációs programozási nyelvek

Egy összeadás Assembly nyelven: ADD X, Y

Az ADD szócska az összeadásra (addition) utal, az X és Y pedig memóriacímeket szimbolizálnak. Tehát az Assembly egy olyan alacsony szintű programozási nyelv, amelynél a művelet és a tárcím szimbolikusan megadható. Természetesen, ha egy Assembly programot szeretnénk futtatni, azt mindig meg kell előznie egy átalakítási, fordítási műveletnek, amikor az Assembly utasításokat gépi utasításokká alakítjuk át. A fordítóprogramok „compiler” típusúak voltak. Az Assembly legtöbb utasítása egyetlen gépi utasítást reprezentált, azaz az Assembly 1:1 típusú nyelv.

6

Második generációs programozási nyelvek

A második generáció programozási nyelvei már lényegesen függetlenebbek voltak a gépi logikától, mint az első generációs nyelvek, az elkészített programokat többféle gépen is használni lehetett. Azonban a nyelvek többsége egy-egy problémacsoport megoldására specializálódott, ami a programok fejlesztése, javítása során igen komoly akadályokat jelentett. A 60-as évek derekán kíséreltek meg először olyan programozási nyelvet fejleszteni, amely rendelkezik az előző nyelvek jó tulajdonságaival, emellett többféle problémacsoport megoldására alkalmas, univerzális. Az új korszakot a procedurális programozási szemlélet és az adatok struktúrájának hangsúlyozása jellemezte.

7

A nyelveket három csoportra oszthatjuk: ·

általános célú, magas szintű nyelvek

·

objektumorientált nyelvek

·

specializált nyelvek (Egy-egy speciális feladat ellátására fejlesztették ki őket)

Az általános célú programozási nyelvek családjába tartozó nyelvek széleskörűen alkalmazhatók a gazdasági számításoktól a rendszerprogramozási fejlesztésekig, széles a lehetőségek skálája. Néhány ismertebb, szélesebb körben elterjedt programozási nyelv: ·

PL/1

·

APL

·

PASCAL

·

Modula-2

·

ADA

·

C

PASCAL A PASCAL nyelv volt az első igazi és legteljesebb körű megvalósítása a strukturált szemléletű programozás elveinek.

A C nyelv: A rendszerprogramozás fejlődése során mérföldkőnek tekinthetjük az 1972-ben megjelent C nyelvet. Megalkotója Dennis Ritchie, aki eredetileg a UNIX rendszerek fejlesztőeszközének

szánta. Később különleges hatékonyságát és sokoldalú felhasználási lehetőségét látva más operációs rendszerekhez kidolgozták a C nyelvű fordítóprogramokat. A nyelv különlegessége, hogy egyesíti magában a hardver közeli programozás és a magas szintű nyelvek előnyeit, ilyen módon jól kihasználhatjuk a hardver adta lehetőségeket – javul a futási idő – mégis gyorsan tudunk új programokat írni, mivel logikájában a magas szintű nyelvek formáját követi a C is. A Pascal-hoz hasonlóan viszonylag kevés utasítást tartalmaz, a legtöbb műveletet előre definiált függvények segítségével oldja meg. A C nyelv támogatja az alprogramok készítését, de csak a függvény típusú modulokat ismeri. Az eljárásokat visszatérési érték nélküli függvényként definiálhatjuk. Lehetőség van rekurzív alprogramok készítésére is. A C nyelvet 1989-ben fogadta el az Amerikai Szabványügyi Hivatal. Ekkor jelent meg az ANSI-C, az első szabványos C fordító. A későbbi változatok ennek lehetőségeire építkeztek. A C nyelvet ma is széles körben használják, első számú alkalmazási területe a rendszerprogra-

Niklaus Wirth professzor, a zürichi Műszaki Főiskola oktatója dolgozta ki a nyelvet a 70-es években, és Blaise Pascal francia matematikus-filozófusról nevezte el.

mozás. A mai követelményeknek megfelelő C változatok a C++, az objektumorientált lehetőségekkel bővített C nyelv, és a Concurent C, a párhuzamos folyamatok programozását segítő eszköz.

Wirth professzor az ALGOL programozási nyelv alapján definiálta a PASCAL szabályait, a cél egy az ALGOL-hoz hasonló, de általános célú programozási nyelv elkészítése volt.

Objektumorientált programozási nyelvek

A PASCAL általános célú programozási nyelv, amelyet elsősorban az oktatásban, a műszaki-tudományos számítások területén és a komplex programrendszerek fejlesztése során alkalmaznak elterjedten.

Az utóbbi években kezdett széleskörűen elterjedni egy új szemléletű programozási technika, az objektumorientált programozás, amely az elődeinél egyszerűbbé, hatékonyabbá, biztonságosabbá teszi a programkészítési munkát.

Szabad formátumú nyelv, mely viszonylag kevés utasítást tartalmaz. A programok szerkezete kötött, szigorú előírások vonatkoznak rá. A PASCAL programok blokkokból épülnek fel, a blokkok a Begin foglalt szóval kezdődnek és az End foglalt szóval érnek véget.

Az objektumorientált programozási nyelvek absztrakt adattípusokkal és a hozzájuk tartozó előre definiált algoritmusokkal segítik a programozó munkáját. Az objektumorientált nyelvek az adatokat és az őket kezelő eljárásokat, függvényeket egységbe foglaltan ún. objektumként kezelik.

Minden utasítás végére „ ;”-t (pontos vesszőt) kell tenni. Az utolsó End után „ .”-t (pontot). Megjegyezném, hogy az utolsó End előtti utasítás végére nem kötelező „;”-t tenni, de ajánlott, hogy nehogy elkerülje a figyelmünket és egy javítás/módosítás alkalmával hibát vétsünk. A PASCAL nyelv támogatja a moduláris programozást, függvények és eljárások definiálhatók a function és a procedure foglalt szavak segítségével. A függvények, eljárások egymásba ágyazhatók, sőt a nyelv támogatja a rekurziót (önmagát meghívó alprogramokat) is. A PASCAL erősen típusos nyelv. A programban használni kívánt változókat a főprogram előtt elhelyezkedő deklarációs részben fel kell tüntetni. A PASCAL fordítók compiler típusú fordítók. A programok szabályos, szigorú, egyértelmű felépítése miatt a nyelv az oktatás kedvelt programozási nyelve. A PASCAL nagyon jó alapot biztosít más programozási nyelvek tanulásához, a strukturált programozás alapelveinek megértéséhez.

8

Az objektumorientált programozás lényege, hogy a programozás során felhasznált elemeket a nyelv előre definiálja, és különböző tulajdonságokkal ruházza fel. Amikor a programozó használni szeretné az egyik elemet, csak a tulajdonságait kell egyéni ízlésére – illetve a feladatnak megfelelő elvárások szerint – beállítania. Ez a programozási technika sokkal közelebb áll az emberi gondolkodáshoz, mint a procedurális programozás. Az objektumorientált programozás elterjedésével sok új nyelv jött létre, amelyek tiszta objektumorientált nyelvek, más technikát egyáltalán nem támogatnak. Sok nyelvet kibővítettek az objektumorientált technika alkalmazásának lehetőségével, ezek az ún. vegyes nyelvek. Tisztán objektumorientált nyelvek: SmallTalk, Eiffel Kibővített nyelvek: Turbo Pascal, Borland C++ (3.1-től része a TVISION)

9

Vegyes nyelvek Turbo Pascal A Turbo Pascal 5.5 verziójától kezdve támogatja az objektumok létrehozásának és kezelésének lehetőségét. A 6.0 verzióba már került egy előre definiált objektumrendszer – TVISION – is, amely a szöveges felületű programok készítése során használható fel hatékony segédeszközként. Vele olyan külalakú programok készíthetők el, mint pl. a Turbo Pascal keretrendszer. Borland C++ A C++ elnevezés a hagyományos C nyelv objektumorientált lehetőségekkel bővített változatát jelenti. A Borland C++ 3.1 verzió már támogatja az objektumorientált technika alkalmazását. Hasonló környezetet és objektumrendszert biztosít, mint a Turbo Pascal 6.0. Rendszer- és fordítóprogramok fejlesztése: A programfordítók fejlesztéséhez olyan magas szintű programozási nyelvre van szükség, amely hatékonyan támogatja az alacsony szintű programozás és az operatív tár közvetlen kezelését egyaránt, lehetővé teszi a bitenkénti műveletek végzését, mégis rendelkezik a magas szintű nyelvek előnyeivel.

Önellenőrzés

?

1. Milyen programnyelv generációkat ismer? ........................................................................................................................................................... ........................................................................................................................................................... 2. Hányadik generációba tartozik a Turbo Pascal? ........................................................................................................................................................... 3. Ki definiálta a Pascal programozási nyelv alapjait? ........................................................................................................................................................... 4. Milyen jellemzői vannak az első generációs programnyelveknek? ...........................................................................................................................................................

Ilyen nyelvek: B, C, BCPL, Pascal.

Negyedik generációs programozási nyelvek (1978-tól) A XX. század második felében a számítástechnika forradalmi változáson ment keresztül. A Neumann elvek megjelenése és az első memóriában tárolt gépi nyelvű program lefuttatása után alig ötven évvel már információs rendszerek, központilag vezérelt számítógép hálózatok programozása, döntéshozást támogató rendszerek fejlesztése a célunk. Nyilvánvaló, hogy ilyen jellegű munkák elvégzésére a hagyományos programozási nyelvek által biztosított eszközök nem megfelelőek. Meg kell említenünk a nyelvek nyilvánvaló előnyei mellett néhány rossz tulajdonságot is. A program hatékonyságának növekedésével egyenes arányban nő a program hardverigénye – elsősorban memória – igénye is, a lefordított program méretéről nem is beszélve.

........................................................................................................................................................... ........................................................................................................................................................... 5. Milyen jellemzői vannak a második generációs programnyelveknek? ........................................................................................................................................................... ........................................................................................................................................................... ...........................................................................................................................................................

E nyelvek sajátosságai közé tartoznak a programkódot generáló modulok, amelyek rendszerint képernyő - és listaformátumokat állítanak elő. A többprocesszoros rendszerek programozását lehetővé tevő nyelvi elemek is ennél a generációnál jelentek meg. Napjaink nyelvi eszközei forradalmi átalakuláson mennek keresztül. A JAVA nyelv filozófiája, a platformfüggetlen (értsd: processzorfüggetlen!) nyelv megvalósításával azonos.

6. Milyen jellemzői vannak a harmadik generációs programnyelveknek?

Egy igen fontos jellemzője a negyedik generációs (4GL) programnyelveknek, hogy a programnyelv készítői rájöttek arra, hogy egy program majd 80%-ban hasonlít egy másikhoz. Azaz minden programban van valami közös. (Ablak, nyomógomb, címke, jelölő négyzet, választó körök, beviteli mező más néven szerkesztőmező, etc…) És amiben eltérnek, csak azt kell leprogramozni. A képernyőhöz, a nyomtatási listákhoz (jelentésekhez) tervező modulok állnak rendelkezésre melyekkel igen gyorsan lehet látványos eredményt elérni.

...........................................................................................................................................................

Ilyenek pl: a Delphi, Visual BASIC, Visual C, Visual FoxPro, Clarion.

........................................................................................................................................................... ...........................................................................................................................................................

7. Írjon ide 3 darab III. generációs programozási nyelvet! ........................................................................................................................................................... 8. Írjon ide 3 darab IV. generációs programozási nyelvet! ...........................................................................................................................................................

Felhasznált irodalom: http://zeus.nyf.hu/~etelka/prognyelvfejl.doc

10

11

Válaszok 1. Milyen programnyelv generációkat ismer? I., II., III., IV. (azaz első, második, harmadik és negyedik generációs nyelveket) Amiket jelölhetünk 1GL, 2GL, 3GL, 4GL (Generation Language) 2. Hányadik generációba tartozik a Turbo Pascal? III. generációba tartozik a Turbo Pascal 3. Ki definiálta a Pascal programozási nyelv alapjait? Niklaus Wirth professzor, a zürichi Műszaki Főiskola oktatója dolgozta ki a nyelvet a 70-es években, és Blaise Pascal francia matematikus-filozófusról nevezte el. 4. Milyen jellemzői vannak az első generációs programnyelveknek? Az első programozási nyelv a gépi kód volt. Ennek a nyelvnek az utasításait a számítógép képes volt közvetlenül, minden átalakítás nélkül végrehajtani, értelmezni. A problémákat nagyon precízen kellett megfogalmazni, lépésekre bontani, minden géptípus esetén másképpen kellett leírni, megfogalmazni. Nem volt hordozható. Előnyei: · ·

A leggyorsabb programot eredményezi, mivel nem tartalmaz felesleges utasításokat. Az egyes utasítások egységes (egy vagy kétcímes) formában vannak leírva.

2. Aritmetikai alapismeretek Mielőtt bemutatnám a Turbo Pascal programozási nyelvet, először definiálni kell a nyelv jelkészletét. A Turbo Pascal az ASCII karakterkészletet használja. Egy karaktert egy bájton tárol. A számítástechnikai alapismeretek modulnál már ismertetésre kerültek a számrendszerek, így hát most ebben a modulfüzetben csak ismétlés gyanánt pillantanánk a kulisszák mögé.

A bináris és hexadecimális számok A tízes számrendszerbeli számokat a számítógép közvetlenül nem tudja használni ezért át kell váltani kettes számrendszerbeli számokká. Mivel a számítógépben lévő logikai áramkörök nem tudják másként értelmezni az adatokat, csak azt tudják megvizsgálni, hogy egy adott helyen lévő jel, feszültség 0 vagy 1, azaz 0 V (volt1) vagy nem 0 V (például 5 V). Ezt számokkal helyettesítve csak azt tudja elönteni, hogy 0 vagy 1 és ez nem más, mint a kettes (bináris) számrendszer két számjegye. A bit (binary digit) egy kettes számrendszerbeli számot jelent, melynek értéke 0 vagy 1 lehet. A memóriából kiolvasható legkisebb érték a byte (bájt). A tízes számrendszerbeli számok átváltását kettesbe egy példán keresztül mutatnám be. Az átváltani kívánt tízes számrendszerbeli szám legyen a 69. Mindig a cél számrendszer alapszámával kell osztani, míg nullát nem kapunk és a maradékokat alulról felfelé olvasva megkapjuk a cél számrendszerbeli számot.

5. Milyen jellemzői vannak a második generációs programnyelveknek? Az új nyelvek struktúrája már nem a számítógép sajátosságaihoz, hanem a problémához igazodott, a programozóknak itt már nem kellett a gépi végrehajtással foglalkoznia.

69 maradék:

34 maradék:

A maradékok viszszaolvasási iránya

Természetesen a magas szintű nyelven írt programokat is le kell fordítani – az Assembly-hez hasonlóan - de komoly előny, hogy ezeknél a nyelveknél már sokkal kisebb a hibalehetőség, a forrásprogram sokkal áttekinthetőbb. 6. Milyen jellemzői vannak a harmadik generációs programnyelveknek? A procedurális programozási szemlélet és az adatok struktúrájának hangsúlyozása jellemezi. 7. Írjon ide 3 darab III. generációs programozási nyelvet! Például: Turbo Pascal, Borland C++, Modula-2 8. Írjon ide 3 darab IV. generációs programozási nyelvet! Például: Delphi, Visual C, Visual BASIC, Visual FoxPro, Clarion for Windows

2

=

34

/

2

=

17

/

2

=

8

/

2

=

4

/

2

=

2

/

2

=

1

/

2

=

0

0 17

maradék:

1

maradék:

0

maradék:

0

maradék:

0

maradék:

1

8 4 2 1

A maradékokat lentől felfelé olvasva 1 0 0 0 1 0 1 –et kapunk. Ez a kettes számrendszerbeli szám egyenlő a tízes számrendszerbeli 69-cel.

1

12

/

1

A volt a feszültség mértékegysége

13

A kettes számrendszerbeli számok átváltását tízesbe egy példán keresztül mutatnám be.

Összeadás a kettes számrendszerben

Végezzük el az alábbi műveleteket a bináris számok körében:

Legyen a bináris szám a következő: 1 0 0 1 1 0 1 1

1 0 0 1 1 1 1 0 + 0 1 0 0 0 0 1 1 1 1 1 0 0 0 0 1

A szám átváltása a következő módon végezhető el: 1

0

0

1

1

0

1

1

7

6

5

4

3

2

1

2

2

2

2

2

2

2

20

1*27

+ 0*26

+ 0*25

+ 1*24

+ 1*23

+ 0*22

+ 1*21

+ 1*20

Lássuk a megoldás menetét: = 155

A példából is látható, hogy a bináris szám helyén lévő kettő hatványainak megfelelő helyi értékeit adtuk össze a decimális szám kiszámításához. Keresni kellett egy olyan számrendszert, amit mi emberek is jól megértünk és a számítógép által használt kettes számrendszerrel jól párhuzamba vonható. Ez a számrendszer a tizenhatos (hexadecimális) számrendszer. Ez egy eléggé tömör számábrázolás könnyedén átváltható kettesbe és vissza, mert minden hexadecimális számjegynek négy bináris számjegy felel meg és viszont. Íme a táblázat, melyből jól látható, hogy egyetlen hexadecimális (tizenhatos) számrendszerbeli számjegyhez négy darab bináris (kettes) számrendszerbeli számjegyre van szükség: Tízesben 0 1 2 3 4 5 6 7

Kettesben 0000 0001 0010 0011 0100 0101 0110 0111

Tizenhatosban 0 1 2 3 4 5 6 7

Tízesben 8 9 10 11 12 13 14 15

Kettesben 1000 1001 1010 1011 1100 1101 1110 1111

Tizenhatosban 8 9 A B C D E F

Egy bájtba (8 bit) beírható legkisebb szám a 0 és a legnagyobb számjegy esetében, ha minden bitje 1, akkor a legnagyobb szám a következő: 1111 1111 = 128+64+32+16+8+4+2+1 = 255

Látható, hogy egyetlen bájton 0 és 255 közötti számok ábrázolhatók. Az ASCII karakterek is egyetlen bájton kerülnek tárolásra. Egy bájton 256 (28) féle különböző állapot tárolható, így a táblázat is 256 elemet tartalmaz. 1. FELADAT Váltsa át a következő számokat tízesből kettes számrendszerbe: 127, 254, 170, 192. 2. FELADAT Váltsa át a következő számokat kettesből tízes számrendszerbe: 10101111, 11001010, 00111010, 11110000.

14

Ugyanúgy járunk el, mint a tízes számrendszernél, azaz jobbról balra haladva adjuk össze a számjegyeket a helyi értékeknek megfelelően. Ha átvitel keletkezik, akkor azt a magasabb helyi értéken lévő számoszlophoz hozzáadjuk. 1 1 1 0 0 1 + 0 1 0 0 1 1 1 0

1 1 0 0

1 1 1 0 0 1 1 0 0 1

Akkor a megoldás menete a következő: 0+1=1, ezt leírjuk a jobboldali számoszlop alá. A következő két szám összege (jobbról balra a második számoszlop) 1+1=2, ami a kettes számrendszerben 10 számjegyekből áll. Innen a 0-t leírjuk és az 1-est az előrébb lévő számoszlophoz hozzáadjuk. Most már 1+1+0=2. Most is ugyanúgy járunk el, mint az előbbiekben, azaz a 0-t leírjuk és az egyest az előrébb lévő oszlophoz hozzáadjuk. Ott most ismét 1+1+0=2, tehát a megoldás menete ismert. Ugyanúgy, mint az előbb. Balról jobbra a 3. oszlopban 1+0+0=1, ezt leírjuk és nincs átvitel. Az első két oszlopban csak 0+1=1, illetve 1+0=1 szerepel. Itt nincs különösebb probléma, az 1-eseket leírjuk. Kivonás a kettes számrendszerben

Ez már egy kicsit összetettebb művelet. Az alábbi példán bemutatásra kerül, hogy a kivonás az összeadásra vezethető vissza. Végezzük el az alábbi műveleteket a bináris számok körében: 1 0 0 1 1 1 1 0 - 0 1 0 0 0 0 1 1 ? ? ? ? ? ? ? ?

A megoldás menete: Kisebbítendő: Kivonandó: Különbség:

1 0 0 1 1 1 1 0 - 0 1 0 0 0 0 1 1 0 1 0 1 1 0 1 1

Első lépés: A kivonandó minden bitjét negálnunk kell (a NEM logikai függvénnyel), azaz ahol 1-es van oda 0-t kell írnunk és ahol 0 van oda 1-est kell írnunk. Negálás: NEM 0 1 0 0 0 0 1 1 1-es komplemens: 1 0 1 1 1 1 0 0

Így megkapjuk a szám 1-es komplemensét. Ebből a kettes komplemensét úgy tudjuk előállítani, hogy a kapott eredményhez, hozzáadunk 1-et. 1-es komplemens: 2-es komplemens:

+

1 0 1 1 1 1 0 0 1 1 0 1 1 1 1 0 1

A kapott eredményt, azaz a 2-es komplemenst kell hozzáadni az eredeti szám kisebbítendőjéhez, majd az első számjegyet le kell hagyni. Ez a számjegy fog informálni bennünket arról,

15

hogy az eredmény pozitív, vagy negatív. A maradék nyolc számjegy lesz a két szám különbsége. Nézzük akkor a fenti példán keresztül: Kisebbítendő: 2-es komplemens: Az eredmény:

1 0 0 1 1 1 1 0 + 1 0 1 1 1 1 0 1 1 0 1 0 1 1 0 1 1

Az eredmény a félkövér betűvel szedett szám. Jól látszik, hogy a legelső (az utolsó átvitel) számjegy az 1-es (dőlten) nem tartozik a kivonás eredményéhez. Ez informál minket, hogy a kapott eredmény pozitív szám. Amennyiben ez a számjegy 0 lett volna, akkor az eredmény negatív szám lenne. 1. FELADAT Váltsa át az eredeti számokat 10-es számrendszerbe és számolja ki a különbséget. Így ellenőrizze le, hogy a kettes számrendszerben kapott eredmény hibátlan-e.

Önellenőrzés

?

1. Végezze el a következő számok összeadását a kettes számrendszerben: 1 0 0 1 1 1 1 0 + 0 1 0 1 0 0 1 1

1 0 1 0 1 1 1 0 + 0 1 0 1 1 0 1 1

1 0 1 1 1 1 1 1 + 0 1 0 0 0 0 1 1

A megoldás menetét írja ide a lapra:

1 0 0 1 1 0 0 0 + 0 1 1 1 1 0 0 1

1 0 0 1 0 0 0 0 + 0 1 0 0 0 1 0 1

1 0 0 1 1 1 1 1 + 0 0 0 0 1 1 1 1

2. Végezze el a következő számok kivonását a kettes számrendszerben: 1 0 0 1 1 1 1 0 - 0 1 0 0 0 0 1 1

2. FELADAT Keresse meg az Interneten majd írja ide a lapra, hogy mit jelent a komplemens szó.

1 0 0 1 0 1 1 0 - 0 1 0 0 1 0 1 1

........................................................................................................................................................... ...........................................................................................................................................................

1 1 1 1 1 1 1 1 - 0 1 0 1 0 0 1 1

3. FELADAT Keressen az Interneten vagy az ajánlott irodalomban másféle megoldásokat a kettes számrendszerbeli számok összeadására és kivonására.

16

0 1 1 0 1 0 1 1 - 1 1 1 1 1 1 1 0

17

Válaszok

3. Relációs műveletek: összehasonlítás

1. Végezze el a következő számok összeadását a kettes számrendszerben:

Jelentése

Példa

=

Egyenlő

A=B

>

Nagyobb

A>B

<

Kisebb

A
>=

Nagyobb vagy egyenlő

A>=B

<=

Kisebb vagy egyenlő

A<=B

<>

Nem egyenlő

A<>B

Összehasonlító operátor

1 0 0 1 1 1 1 0 + 0 1 0 1 0 0 1 1 1 1 1 1 0 0 0 1 1 0 1 0 1 1 1 0 + 0 1 0 1 1 0 1 1 1 0 0 0 0 1 0 0 1 1 0 1 1 1 1 1 1 + 0 1 0 0 0 0 1 1 1 0 0 0 0 0 0 1 0

Pl., ha A=5 és B=3, akkor az A<=B, HAMIS az A > B, IGAZ és az A<>B is IGAZ

1 0 0 1 1 0 0 0 + 0 1 1 1 1 0 0 1 1 0 0 0 1 0 0 0 1

4. Logikai függvények

1 0 0 1 0 0 0 0 + 0 1 0 0 0 1 0 1 1 1 0 1 0 1 0 1 1 0 0 1 1 1 1 1 + 0 0 0 0 1 1 1 1 1 0 1 0 1 1 1 0

2. Végezze el a következő számok kivonását a kettes számrendszerben:

18

Az összehasonlító operátorok két értéket hasonlítanak össze, és az IGAZ vagy a HAMIS logikai értéket adják eredményül.

1 0 0 1 1 1 1 0 - 0 1 0 0 0 0 1 1 (1) 0 1 0 1 1 0 1 1

(pozitív eredmény)

1 0 0 1 0 1 1 0 - 0 1 0 0 1 0 1 1 (1) 0 1 0 0 1 0 1 1


1 1 1 1 1 1 1 1 - 0 1 0 1 0 0 1 1 (1) 1 0 1 0 1 1 0 0


0 1 1 0 1 0 1 1 - 1 1 1 1 1 1 1 0 (0) 0 1 1 0 1 1 0 1

(negatív eredmény)

A formális logika, mint tudomány, a matematika egy külön ága. Kialakulásában komoly szerepe volt néhány neves matematikusnak, mint Augustus De Morgan vagy George Boole. Az általuk kidolgozott szabályokat és törvényszerűségeket összefoglalóan Boole-algebrának hívják. Az ebben szereplő logikai változók nem számjegyek, hanem olyan eseményeknek tekinthetjük, amelyek vagy bekövetkeznek vagy nem. Ha bekövetkeznek, akkor értéke IGAZ (TRUE), ha nem, akkor értéke HAMIS (FALSE). De maradjunk az egyszerűbb szemléltetésnél, ha IGAZ, akkor 1 (egy), ha HAMIS, akkor 0 (nulla). A logikai változókkal műveletet is végezhetünk adott bemenetek függvényében, változhat valamilyen kimeneti változó. Az ilyen összefüggéseket logikai függvényeknek nevezzük. Hogy jobban megértsük a logikai változók értékadását, nézzünk erre egy egyszerű példákat. Ha azt kérdezem, hogy esik-e az eső vagy azt, hogy süt-e a nap vagy azt, hogy tud-e úszni a kedves Olvasó, akkor minden kérdésre adható legegyszerűbb válasz az IGEN vagy a NEM. Ha ezek logikai tartalmát tekintjük, akkor IGAZ vagy HAMIS értéket kaphatnak. Jelöljük „A”-val és „B”-vel az állításokat. Legyen az „A” állítás a következő: esik az eső. Ennek értéke csakis IGAZ vagy HAMIS lehet. Legyen a „B” állítás a következő: süt a nap. Ennek is az értéke IGAZ vagy HAMIS lehet. Akkor már ismerjük is a jelöléseket és az értelmezésüket. Itt megkülönböztetünk egyváltozós, illetve több változós logikai függvényeket.

19

Két változó esetén a függvény igazságtáblázata a következő:

4.1 Egyváltozós logikai függvények

Az egyváltozós logikai függvényeknek csupán egyetlen bemeneti változója van. Ennek függvényében változik a kimeneti változó értéke.

A

B

A TB

Több ilyen függvény is létezik, de itt most csak a számunkra fontosakat szeretném ismertetni, és ez pedig a NEM ( NOT) a logikai tagadás. A függvény a bemeneti változó tagadott értékét adja a kimeneten. Természetesen az IGAZ érték tagadottja a HAMIS, a HAMIS érték tagadottja pedig az IGAZ.

0

0

0

0

1

0

1

0

0

Jelölése sokféle lehet, (aminek egyrészt nyomdatörténeti oka is van,) mint ezt látni fogjuk a későbbikben bemutatásra kerülő többváltozós függvényeknél is.

1

1

1

┐A

A !A

NEM

A

NOT

A

Mindegyike az „A” állítás tagadását jelöli. A függvények bemenetét/kimenetét ún. igazságtáblázatokkal szokták szemléltetni. Egy ilyen NEM ( NOT) logikai függvény igazságtáblája a következő:

A

┐A

0

1

1

0

4.2 Kettő, illetve többváltozós logikai függvények

Az itt ismertetésre kerülő kétváltozós logikai függvények értelemszerűen kiterjeszthetőek többváltozós függvényekké. Így terjedelmi okokra hivatkozva az alábbi példákat, két változóval fogom ismertetni. A kétváltozós logikai függvényeknél a kimenet értéke két bemeneti változó értékének a függvénye. Az egyváltozós függvényeknél is említettem, hogy az ott említett függvényeken kívül több is létezik, így itt is csak a legfontosabbak kerülnek említésre. Vegyük sorra ezeket a függvényeket részletesen, hiszen ezek képezik a logikai tervezés alapjait. Az ÉS (AND) kapcsolat

Az ÉS kapcsolat legegyszerűbb megfogalmazása a következő: az ÉS kapcsolat csak abban az esetben ad igaz értéket, ha egyidejűleg minden bemeneti érték (változó) IGAZ. Ezt úgy is megfogalmazhatjuk, hogy az ÉS kapcsolat mindenképpen HAMIS értéket ad, ha bármelyik bemeneti változó értéke HAMIS. E függvény jelölése is többféle lehet:

20

A AND B

B

0

1

0

0

0

1

0

1

A

Mindkét igazságtáblából ugyanaz olvasható ki, csak egy picit más a felépítése. A baloldali már ismerős. A baloldali 2 oszlop a bemenetet jelenti, a függőleges vastag vonal jobb oldalán lévő oszlop a kimenetet jelenti. Látható, hogy csak akkor IGAZ a kimenet értéke, ha minden bemenet „A” és „B” is IGAZ. A jobb oldali egy kicsit szokatlan elrendezésű, de nézzük az értelmezését. Az első oszlopban áll az „A” változó értéke. Az első sorban áll a „B” változó értéke. A metszéspontokból kiolvasható az eredmény. Például: Ha „A” értéke 1 és a „B” értéke 0, akkor az eredmény a két bemeneti érték mettszéspontjából kiolvasható, hogy 0, tehát HAMIS.

Ami azt jelent, hogy az „A” állítás, mint bemeneti érték (baloldali oszlop) esetén mi lesz a kimeneti érték (jobboldali oszlop). Ha a bemenet értéke 1, akkor a kimenet az ellenkezője, azaz 0 és ugyanez az 1, mint bemeneti érték esetén a kimeneti érték logikai 0 lesz. Ha az „A” állítás az, hogy esik az eső, akkor ennek az ellenkezője természetesen az, hogy nem esik.

A ÉS B

ÉS

ATB

A VAGY (OR ) kapcsolat

A logikai vagy kapcsolat eredménye akkor IGAZ, ha valamelyik bemeneti változó értéke Megfordítva: a VAGY kapcsolat csak és csakis abban az esetben ad HAMIS értéket, ha egyidejűleg minden bemeneti változó értéke HAMIS.

IGAZ.

A VAGY függvény igazságtáblázata:

A

B

AvB

0

0

0

0

1

1

1

0

1

1

1

1

Itt is látható, hogy csak abban az esetben bemeneti érték HAMIS, azaz 0.

VAGY

B

0

1

0

0

1

1

1

1

A

HAMIS

a

VAGY

függvény eredménye, ha minden

Az antivalencia (XOR) kapcsolat

Az antivalencia – vagy ismertebb nevén a KIZÁRÓ-VAGY ( EXCLUSIVE -OR) – kapcsolat, abban az esetben ad IGAZ értéket, ha csak is az egyik változó értéke IGAZ, a másikak pedig HAMISak. Gyakorlatilag ez azt jelenti (két változó esetén), hogy a két változó nem egyenlő, tehát antivalens.

21

Jelölésére a következőket szokták használni:

A

B

A KVAGY B

2. példa:

A

XOR

B

Oldjuk meg a következő ÉS kapcsolatot két bájt között?

A KIZÁRÓ-VAGY függvény igazságtáblázata: ÉS

A

B

AXORB

0

0

0

0

1

1

1

0

1

1

1

0

XOR

B

A

0

1

0

0

1

1

1

0

1 0 0 1 1 0 1 1 1 0 0 1 0 0 0 1 ? ? ? ? ? ? ? ?

A feladat megoldása a következő. A felső bájt legyen „A” a második legyen „B”. Egymás alatti biteket párba állítva keressük ki az ÉS igazságtáblából az eredményt és írjuk a kérdőjelek helyére. Vagy egyszerűen csak oda írjunk 1-est, ahol mindkét számjegy 1-es. Az így kapott eredmény: 1 0 0 1 0 0 0 1 lesz. 3. példa:

Az igazságtáblából is leolvasható, hogy csak akkor IGAZ az eredmény, ha csakis az egyik bemeneti változó értéke IGAZ és bármely más esetben HAMIS a végeredmény. Itt megemlíteném, hogy a KIZÁRÓ VAGY jó a titkosírásra, rejtjelezésre is. Mert, ha egy bájtot kapcsolatba helyezünk egy másikkal, majd a kapott eredményt ismét KIZÁRÓ VAGY- ba helyezzük ugyanavval a bájttal, akkor visszakapjuk a kiinduló állapotot, az első bájtot. Erre egy konkrét példát a következő oldalakon a 3. példánál olvashatnak. KIZÁRÓ VAGY

Legyen egy bájtunk amit titkosítani ( KIZÁRÓ VAGY-ba helyezni) szeretnénk egy „jelszó” bájttal. Majd gondolatban küldjük el egy barátunknak és mondjuk meg neki, hogy milyen bájttal titkosítottuk. Kérjük meg, hogy a „jelszó” bájttal ő is kódolja el XOR függvénnyel, mire ő megkapja az eredeti, kiinduló bájtunkat. Erre a feladatra már hivatkoztam a KIZÁRÓ-VAGY tárgyalásánál. Nézzük a megoldást: Először adjuk meg az alapadatokat, a titkosítandó bájtot és a jelszót.

4.3 Példák a logikai függvények alkalmazására

A példák bemutatásánál feltételezem, hogy a számítástechnikai alapismeretek tananyag elsajátítása után már tisztában van a bájt a bit fogalmával, valamint az egyéb alapvető matematikai kompetenciákkal. Itt csak néhány, (talán érdekes) példát szeretnék bemutatni. Amennyiben e példák megértése során nehézségekbe ütközik, akkor kérjen segítséget instruktorától, tanárától. Illetve keressen hasonló példákat vagy feladatokat az Interneten, használja a keresőprogramokat, pl. a http://www.google.co.hu -t. 1. példa: Milyen logika értéket fog felvenni a „C” logikai változó? Legyenek a következő alapadatok: A = 1, B = 0 C = NEM(A VAGY B) Itt először a zárójelben lévő kapcsolatot oldjuk meg és azután a zárójelen kívülieket. Látható, hogy a NEM a zárójel előtt áll közvetlenül. Tehát a „zárójelet” tagadja. A megoldás a következő: először is behelyettesítjük az A és a B értékét a megfelelő helyekre. Ekkor a következőt kapuk: C = NEM(1 VAGY 0) A zárójelben lévő kapcsolat értéke (kikeresve a VAGY igazságtáblázatból) logikai 1. Mivel ez van a zárójelben, a tagadás erre vonatkozik. Ezt is kikeresve a NEM igazságtáblázatából megkapjuk az eredményt. A logikai 1 tagadása logikai 0 lesz. Tehát, kijelenthetjük, hogy a „C” logikai változó értéke logikai 0, vagyis az eredmény HAMIS.

22

A titkosítandó bájt: 1 0 0 1 1 0 1 1 A jelszó bájt: 1 0 1 0 1 1 1 1 Írjuk őket egymás alá: A titkosítandó bájt: A jelszó, amivel XOR-ba helyezzük: Az eredmény, a titkos bájt: Az eredmény, azaz a titkos bájt: A jelszó, amivel ismét XOR-ba helyezzük: Az eredmény, az eredeti bájt:

1 0 0 1 1 0 1 1 1 0 0 1 0 0 0 1 0 0 0 0 1 0 1 0 0 0 0 0 1 0 1 0 1 0 0 1 0 0 0 1 1 0 0 1 1 0 1 1

Kijelenthetjük, hogy ha egy logikai értéket (pl. bájtot) kétszer ugyanavval az értékkel (pl. bájttal) logikai XOR-ba helyezünk, akkor visszakapjuk az eredeti értéket (pl. bájtot). 4. példa: Vajon mi lesz az eredménye egy bitnek, ha kétszer tagadjuk? Legyen az A logikai változó értéke 1 (egy). Ha ezt tagadjuk ( NEM), akkor 0-t kapunk. De mi lesz, ha ezt a 0-t is meg tagadjuk? Akkor 1-et kapunk. Kijelenthetjük, hogy ha valamit kétszer tagadunk, akkor ugyanazt kapjuk eredményül. Vegyünk egy hétköznapi példát, hogy „nem nem tudok írni”, tehát tudok írni.

23

5. példa, egy érdekesség: Melyik VAGY-ot használjuk a hétköznapi életben? A MEGENGEDŐ VAGY-ot vagy a KIZÁRÓ VAGYOT? Legyen az „A” állítás, hogy moziba megyünk. Ami lehet IGAZ vagy HAMIS. Legyen a „B” állítás, hogy sörözni megyünk. Ami szintén lehet IGAZ vagy HAMIS. De e kettő együtt persze nem lehet IGAZ, azaz a moziban nem sörözünk. De az is HAMIS eredményt adna, ha sehova sem mennénk. Tehát a „Sörözni VAGY moziba menjünk?” kérdés alapján jól érezhető, hogy a hétköznapi életben a KIZÁRÓ VAGY-ot használjuk. 6. példa:

Önellenőrzés

?

1. Kiknek a nevéhez fűződik a Boole-algebra? ........................................................................................................................................................... 2. Milyen értékeket vehetnek fel a logikai változók? ...........................................................................................................................................................

Mire használható még a KIZÁRÓ VAGY függvény? Ha ugyanazt a számot ugyanazzal KIZÁRÓ VAGY -ba helyezzük, akkor tulajdonképpen lenullázzuk. Például az Assembly-ben a következő utasítással tudunk egy regisztert nullázni. XOR AX,AX

Mivel az AX egy regiszter és önmagával helyezzük kizáró vagyba, így nem kell külön a memórát megcímezni és onnan behozni egy adatot az AX regiszterbe mint, ha azt írnánk, hogy MOV AX,0

akkor ezt tennénk, ami lassabb, mint a kizáró vagyos példa. Legyen az AX tartalma a következő: 10011010, akkor önmagával a kizáró vagyba helyezésnél az eredmény a következőképpen nézne ki. XOR

10011010 10011010 00000000

1. FELADAT Nézzen utána az Interneten, hogy milyen egyszerű áramkörrel valósítható meg a NEM a VAGY és az ÉS logikai függvény. Rajzolja le ide a lapra.

3. Írjon egy hétköznapi példát egy logikai kifejezésre? ........................................................................................................................................................... ........................................................................................................................................................... ........................................................................................................................................................... 4. Mik a logikai függvények? ........................................................................................................................................................... 5. Hány változós logikai függvények léteznek? ........................................................................................................................................................... ........................................................................................................................................................... 6. Mi a NEM logikai függvény és mit tesz a bemeneti változójával? ........................................................................................................................................................... 7. Hány bemeneti változója van a NEM a VAGY és az ÉS logikai függvénynek? NEM:

.............................................. VAGY: .................................... ÉS: ..........................................

8. Hogyan jelölik a NEM a VAGY és az ÉS logikai függvényeket?

2. FELADAT Titkosítsa el az „Alma” szót a „Cica”-val, majd ismét. (A megoldáshoz használja az ASCII táblát a karakterenkénti titkosításhoz.)

24

NEM:

...............................................................................................................................................

VAGY:

...............................................................................................................................................

ÉS:

...............................................................................................................................................

9. Mikor van igaz kimenete az XOR függvénynek? ...........................................................................................................................................................

25

10. Oldja meg a következő feladatot:

A=1 B=0 C=0 D = NEM(A és NEMB) VAGY C

D = .................................................................................................................................................... 11. Oldja meg a következő feladatot:

A=1 B=0 C=1 D = NEM(NEM(A és B) VAGY NEMC

Válaszok 1. Kiknek a nevéhez fűződik a BOOLE-ALGEBRA? Augustus De Morgan vagy George Boole. 2. Milyen értékeket vehetnek fel a logikai változók? IGAZ vagy HAMIS , azaz 0 vagy 1 éréket vehetnek fel a logikai változók. 3. Írjon egy hétköznapi példát egy logikai kifejezésre? Ma délután moziba fogok menni. (Ami lehet IGAZ is és HAMIS is.) 4. Mik a logikai függvények? A logikai változókkal műveletet is végezhetünk adott bemenetek függvényében, változhat valamilyen kimeneti változó értéke. Az ilyen összefüggéseket logikai függvényeknek nevezzük. 5. Hány változós logikai függvények léteznek? Egy és többváltozós logikai függvények léteznek.

D = ................................................................................................................................................... 12. Váltsa át 10-es számrendszerből kettesbe a következő két számot és helyezze őket ÉS kapcsolatba.

6. Mi a NEM logikai függvény és mit tesz a bemeneti változójával? Negálja a bemeneti értéket. Azaz, ha 0 a bemenet értéke, akkor 1 lesz a kimenet és, ha 1 a bemenet értéke, akkor 0 lesz a kimenet értéke.

A = 138 B = 144

7. Hány bemeneti változója van a NEM a VAGY és az ÉS logikai függvénynek? A NEMnek 1, az ÉSnek és a VAGYnak több 8. Hogyan jelölik a NEM a VAGY és az ÉS logikai függvényeket? NEM:

┐A,

VAGY: AvB

ÉS:

A ÉS B = ..........................................................................................................................................

9. Mikor van igaz kimenete az XOR függvénynek? Ha csak az egyik bemenő változója IGAZ.

13. Váltsa át 10-es számrendszerből kettesbe a következő két számot és helyezze őket VAGY kapcsolatba.

10. Oldja meg a következő feladatot: D=0

ATB

A = 108 B = 44

11. Oldja meg a következő feladatot: D=0

A VAGY B = ....................................................................................................................................

13. Váltsa át 10-es számrendszerből kettesbe a következő két számot és helyezze őket VAGY kapcsolatba. A v B = 01101100 v 00101100 = 01101100

26

12. Váltsa át 10-es számrendszerből kettesbe a következő két számot és helyezze őket ÉS kapcsolatba. A T B = 10001010 T 10010000 = 10000000

27

SHR, SHL

5. Bitműveletek: a forgatás

A harmadik forgatási lehetőség, amikor az adat kicsúszó bitje szintén a carry flagbe íródik, de a másik oldalról becsúszó bit értéke minden esetben 0.

ROR, ROL A következő bitművelet a forgatás. Lehetőség van ugyanis a byte vagy word2 tartalmának a forgatására többféle módon. Ami közös mindegyik megoldásnál, hogy a byte vagy word széléről kicsúszó bit mindig beíródik a carry flagbe3. A szó szerinti forgatást a ROR (ROtate Right) és a ROL (ROtate Left) utasítások végzik. Mivel a Pascal csak a shl (SHift Left, forgatás balra) és shr (SHift Right, forgatás jobbra) műveleteket támogatja, ettől függetlenül ismertetnem kell az összes megoldást, melyeket az Assembly programozási nyelvben használatos mnemonikokkal4 írok le. A ROR működése: 01100101

forgatás előtt:

01100101

forgatás után:

10110010

forgatás után:

11001010

Hasonló módon működik az RCR illetve az RCL utasítások, de itt a forgatott adatot megtoldja egy bittel a carry flag. Tehát mint a byte kilencedik bitje működik, ugyanis a kiforduló bit a carry flagbe kerül és a carry flag előző értéke fordul be a byte másik oldalán. Az RCR utasítás működése:

01100101

forgatás előtt:

01100101

forgatás után:

00110010

forgatás után:

11001010

carry értéke: 0

carry értéke: 1

Az SHL nagyon jól használható 2 hatványaival való szorzásra, az SHR pedig kettő hatványaival való osztásra. SAR, SAL Egy byte vagy word forgatására még egy lehetőség van, amikor a jobbra forgatásnál a signum flag értéke íródik az adat bal szélére. A jobb szélső bit forgatáskor szintén a carry-be íródik. A művelet fordítottja azonos az SHL működésével. A SAL működése:

Az RCL utasítás működése:

signum értéke forgatás előtt: 0 forgatás előtt: forgatás után: carry értéke: 1

01100101 00110010

carry értéke forgatás előtt: 0


signum értéke forgatás előtt: 1

a byte forgatás előtt:

01100101


01100101

forgatás után:

00110010

forgatás után:

11001010

forgatás előtt: forgatás után: carry értéke: 1

carry értéke: 1 mivel a byte jobb szélén kicsúszó bit értéke 1.

carry értéke: 0 mivel a byte bal szélén kicsúszó bit értéke 0.




01100101


01100101

forgatás után:

10110010

forgatás után:

11001011

carry értéke: 1 mivel a byte jobb szélén kicsúszó bit értéke 1.

4

forgatás előtt:

A SAR működése:

RCR, RCL

3

Az SHL utasítás működése:

A ROL működése:

forgatás előtt:

carry értéke: 1 mivel a byte jobb szélén kicsú- carry értéke: 0 mivel a byte bal szélén kicsúszó bit értéke 1. szó bit értéke 0.

2

Az SHR utasítás működése:

carry értéke: 0 mivel a byte bal szélén kicsúszó bit értéke 0.

forgatás előtt:

01100101

forgatás után:

11001010

carry értéke: 0

01100101 10110010

1. FELADAT Váltsa át a következő számokat kettes számrendszerbe:

?

24, 48, 68, 92, 168 SHR és SHL utasítással forgassa el őket. Váltsa vissza őket tízes számrendszerbe. Figyelje meg, hogy tényleg szorzás és osztás művelete történt-e velük.

A byte = 8bit, a word = 16 bit Átviteljelző bit a státuszregiszterben Három betűs utasítások

28

29

Önellenőrzés

?

1. Milyen bitműveletek léteznek? ........................................................................................................................................................... ........................................................................................................................................................... 2. Mi lesz a bájt értéke ROR művelet esetén, ha a bájt, amit forgatni szeretnénk: 10101100? És mi lesz a carry bit értéke? ........................................................................................................................................................... ........................................................................................................................................................... ........................................................................................................................................................... 3. Mi lesz a bájt értéke RCL művelet esetén, ha a bájt, amit forgatni szeretnénk: 10101100? És mi lesz a carry bit értéke, ha forgatás előtt 1 (egy)?

Válaszok 1. Milyen bitműveletek léteznek? ROR, ROL, RCR, RCL, SHR, SHL, SAR, SAL 2. Mi lesz a bájt értéke ROR művelet esetén, ha a bájt, amit forgatni szeretnénk: 10101100? És mi lesz a carry bit értéke? A bájt értéke a következő lesz: 01011000 és a carry bit értéke 0 lesz, mert a jobb szélén kicsúszó bit értéke 0 (nulla). 3. Mi lesz a bájt értéke RCL művelet esetén, ha a bájt, amit forgatni szeretnénk: 10101100? És mi lesz a carry bit értéke, ha forgatás előtt 1 (egy)? A bájt értéke a következő lesz: 01011000 és a carry bit értéke 1 lesz, mert a bal szélén kicsúszó bit értéke 1 (egy). 4. Mi lesz a bájt értéke SHR művelet esetén, ha a bájt, amit forgatni szeretnénk: 10101100? És mi lesz a carry bit értéke? A bájt értéke a forgatás után 01010110 lesz. A carry flag értéke 0 (nulla) lesz, mert az csúszott ki a jobb oldalon.

........................................................................................................................................................... ........................................................................................................................................................... ...........................................................................................................................................................

5. Mi lesz a bájt értéke SAR művelet esetén, ha a bájt, amit forgatni szeretnénk: 10101100? És mi lesz a carry bit értéke, ha a signum bit értéke 1 (egy)? A bájt értéke a forgatás után 11010110 és a carry flag értéke 0 lesz, mert az csúszott ki a jobb oldalon. Az első (baloldali) bit a signum flag értéke lett.

4. Mi lesz a bájt értéke SHR művelet esetén, ha a bájt, amit forgatni szeretnénk: 10101100? És mi lesz a carry bit értéke? ........................................................................................................................................................... ........................................................................................................................................................... ........................................................................................................................................................... 5. Mi lesz a bájt értéke SAR művelet esetén, ha a bájt, amit forgatni szeretnénk: 10101100? És mi lesz a carry bit értéke, ha a signum bit értéke 1 (egy)? ........................................................................................................................................................... ........................................................................................................................................................... ...........................................................................................................................................................

30

31

Nyelvi elemek rendeltetésszerű használata Bevezetés Mielőtt a programozást elkezdenénk, előtte természetesen el kell tudni indítani a fejlesztőrendszert, amiben majd begépeljük a programunkat, majd lefuttatjuk és minimálisan meg kell ismernünk a fejlesztőrendszer használatát. Az IDE5 a turbo.exe programmal indul, amelyet általában a TP nevű alkönyvtárban találunk meg. Ez a program segít abban, hogy a programunkat begépeljük, megszerkesszük, javítsuk, elmentsük, megnyissuk, futtassuk, etc. Azaz megírjuk, kifejlesszük, kialakítsuk saját programjainkat. De előbb nézzük, hogy a hallgató mire lesz képes a tanulási feladatok elvégzése után: A tanulási feladatok elvégzése után a hallgató: · El tudja indítani a Turbo Pascal fejlesztőrendszert · Képes lesz egy egyszerű Pascal program megírására · Ismerni fogja a Pascal program felépítését · Futtatni tud majd egy Pascal programot · El tudja menteni és betölteni az általa írt programot · Ki tud majd lépni a fejlesztőrendszerből Rész célkitűzések 1. A fejlesztőrendszer (IDE) elindítása 2. Az első program begépelése, mentése, bezárása, megnyitása, futtatása 3. A Turbo Pascal program felépítése 4. Az program nyelvi elemeinek ismertetése 5. Egyszerű programpéldák

5

Integrated Development Environment = Integrált Fejlesztői Környezet

33

1. A fejlesztőrendszer (IDE) elindítása Mielőtt leírnám, hogy hogyan kell elindítani a Turbo Pascal fejlesztőrendszert, feltételezem, hogy az Ön számítógépére már telepítve van. Ha a programot DOS operációs rendszerből indítjuk el, akkor tegyük a következőt: Lépjünk be a C:\TP könyvtárba a C:\>cd tp

Önellenőrzés

?

1. Hogyan tudja elindítani a Turbo Pascalt DOS alól? ........................................................................................................................................................... ...........................................................................................................................................................

paranccsal. Majd gépeljük be a „ turbo” szót és üssünk [ENTER]-t. C:\TP>turbo [ENTER]

A program indítása előtt javaslom, hogy indítsunk el valamilyen billentyűzet-átdefiniáló programot, hogy az ékezetes magyar magánhangzókat is tudjuk használni. Ezeket a karaktereket úgy is elérhetjük, hogy a baloldali Alt billentyűt nyomva tartva a jobboldali numerikus billentyűzeten begépeljük a karakter ASCII 6 kódját. Pl. az á - 160, é – 130, í – 161, … A többi karakter kódját megtalálja a kódlapnak megfelelő ASCII kódtáblában. Érdemes egy egérkezelő programot is elindítani. A fejlesztőrendszer használatát sok esetben megkönnyíti, ha van egerünk. Amennyiben a Turbo Pascalt windows alól kívánjuk elindítani és nehézségekbe ütközik a programindítással kapcsolatban, akkor kérjen segítséget oktatójától. Terjedelmi okokra hivatkozva, itt nem áll módomban az összes windows alóli indítási beállítás ismertetése. Nézzük, hogy hogyan lehet elindítani a Turbo Pascalt Windows95, Windows98, Windows Me alól. Start menü/Futtatás (Ami természetesen elérhető a Win+R billentyűkombinációval is az összes MS Windows operációs rendszerből.) Ha a fenti operációsrendszerek valamelyikét használjuk, akkor a futatáshoz a „command” parancsot kell begépelnünk és „Enter”-t ütni vagy „Ok”-ra klikkelni. Ha NT alapú rendszert használunk (Windows NT 4.0 vagy Windows 2000 vagy XP vagy enek valamelyik utódját Pl. Longhorn vagy Vista), akkor a „cmd” parancsot kell begépelnünk a DOS parancssori ablak elindításához. Az alapvető DOS-kezelő parancsokat itt nem ismertetném. Javaslom, hogy keressen DOS-ról szóló könyveket vagy nézzen utána az Interneten. Természetesen nem ez az egyedüli megoldás a különböző rendszerekben. Ha sikerült elindítani egy DOS parancs ablakot, akkor a DOS-nál ismertetett módon már elindítható a Pascal. (Javaslom a közvetlen útvonalváltást, a biztonság kedvéért a „cd tp” helyett a „cd \tp”-t, feltéve, hogy abba a könyvtárba lett telepítve a TP.). Ha valamilyen windows operációsrendszerből indítjuk a Pascalt, akkor az egérkezelő programot és a karakter átdefiniáló programot nem kell külön elindítanunk, mert az operációs rendszer ezt a szolgáltatást nyújtja nekünk. Megjegyzés: az ablakos és a teljes képernyős módok közötti váltásra a baloldali Alt+Enter szolgál. 6

American Standard Code for Information Interchange

34

2. Hogyan tudja elindítani a Turbo Pascalt Windows9x alól? ........................................................................................................................................................... ........................................................................................................................................................... 3. Hogyan tudja elindítani a Turbo Pascalt WindowsNT alapú rendszerek alól? ........................................................................................................................................................... ........................................................................................................................................................... 4. Windows alatt milyen billentyűkombinációval tud váltani az ablakos és a teljesképernyős módok között? ........................................................................................................................................................... 5. Hogyan lehet ékezetes magyar magánhangzókat használni, ha DOS alatt indította el a Turbo Pascalt? ........................................................................................................................................................... ........................................................................................................................................................... 6. Hogyan lehet a billentyűzeten nem lévő, illetve ékezetes ASCII karaktereket használni a Turbo Pascalban? Írjon konkrét példát, pl. ami egy keret megrajzolásához használható! ........................................................................................................................................................... 7. Milyen programokat érdemes elindítani, ha DOS alól indítja a fejlesztőrendszert és miért? ...........................................................................................................................................................

35

Válaszok

?

1. Hogyan tudja elindítani a Turbo Pascalt DOS alól? Lépjünk be a C:\tp könyvtárba a C:\>cd tp paranccsal. Majd gépeljük be a „turbo” szót és üssünk entert. pl: (C:\tp>turbo [ENTER]). 2. Hogyan tudja elindítani a Turbo Pascalt Windows9x alól? Win+R (futtatás), be kell írni a command parancsszót majd ENTER-t ütni. A kapott DOS parancsablakban már csak el kell indítani a Turbo Pascalt a DOS-nál ismertetett módon. pl. be kell lépni a TP alkönyvtárba a cd \tp paranccsal és begépelni a turbo-t, majd ENTER.

2. Az első program begépelése, mentése, bezárása, megnyitása, futtatása A fejlesztőrendszer indítása után a képernyő felső részén látjuk a menüpontokat, amelyeket úgy érhetünk el, hogy az Alt billentyűt lenyomva tartva a kiválasztandó menüpontnak a kezdőbetűjét begépeljük, vagy a menüpontra az egérrel kattintunk.

Menü sor Egérrel itt lehet bezárni az ablakot

3. Hogyan tudja elindítani a Turbo Pascalt WindowsNT alapú rendszerek alól? Win+R (futtatás), be kell írni a cmd parancsszót majd entert ütni. A kapott DOS parancsablakban már csak el kell indítani a Turbo Pascalt a DOS-nál ismertetett módon. pl. be kell lépni a TP alkönyvtárba a cd \tp paranccsal és begépelni a turbo-t, majd ENTER. 4. Windows alatt milyen billentyűkombinációval tud váltani az ablakos és a teljesképernyős módok között? (bal) Alt+Enter 5. Hogyan lehet ékezetes magyar magánhangzókat használni, ha DOS alatt indította el a Turbo Pascalt? (bal) Alt+ASCII kód a numerikus billentyűzeten. Pl: á - Alt+160, é – Alt+130, … vagy billentyűzet átdefiniáló programot kell használni 6. Hogyan lehet a billentyűzeten nem lévő, illetve ékezetes ASCII karaktereket használni a Turbo Pascalban? Írjon konkrét példát. (pl. ami egy keret megrajzolásához használható.) (bal) Alt+ASCII kód a numerikus billentyűzeten. Az ASCII táblából ki kell keresni a megfelelő keret vagy vonal karakterkódot. 7. Milyen programokat érdemes elindítani, ha DOS alól indítja a fejlesztőrendszert? · Billentyűzet átdefiniáló ·

Egérkezelő

Az ablak sorszáma

Méretező ikon

NONAME00.PAS, a pas fájlunk neve. (Még nincs mentve)

Gördítősávok Kurzor poziciója

Státusz sor, a rövid súgóval

Ablak átméretezése egérrel

1. kép - A Turbo Pascal fejlesztőrendszere

Nézzük át a legfontosabb menüpontokat, melyeket használni fogunk az első programunk elkészítéséhez. Terjedelmi okokra hivatkozva, nem áll módomban az összes menüpont ismertetése. Amennyiben a program nem úgy indul, hogy lehetőségünk legyen a programunk begépelésére egy ablakkeretben (általában kék háttérrel, NONAME00.PAS címmel), akkor tegyük a következőket egy üres ablak keret előkészítéséhez: Az Alt+F billentyű lenyomása után (a + azt jelenti, hogy az Alt billentyűt lenyomva tartjuk és lenyomjuk hozzá az F billentyűt, ezt nevezik billentyűkombinációnak), nyomjuk le az N billentyűt. Ezzel kiválasztottuk a Fájl (adatállomány) menü New (új) alpontját. Persze a menüt az F10-es billentyűvel is elérhetjük és a kurzormozgató nyilakkal is navigálhatunk a kívánt menüpontra, majd Enterrel indítjuk a menüfunkciót. Természetesen egérrel is kattinthatunk a kívánt menüpontra.

2. kép – A File menü

Kérhetünk több ablakot is ahova a programjainkat fogjuk begépelni (Alt+F,N). Ekkor az F6 illetve a Shift+F6 billentyűkkel (itt most a Shift billentyűvel kell lenyomni az F6-ot az

36

37

előbbiekben ismertetett módon) válthatunk a megnyitott ablakok között. Az F6-tal előrefelé a Shift+F6-tal visszafelé lépkedhetünk.

látható, mint a többi körül, akkor az az alapértelmezett (default) nyomógomb. Funkciója ugyanaz mint itt az IDE-ben.

A következő fontos lépés, hogy adjunk nevet a programunknak. A programablak felső széle közepén olvasható, hogy még nincs neve: NONAME00.PAS vagy NONAME01.PAS. A „NONAME” név után egy sorszám áll. Először 00 majd 01 és így tovább. A mentéshez nyomjuk le az F2-es billentyűt. Ez ugyan a mentés és nem a mentés másként, mivel még nincs neve a programunknak (NONAMExx.PAS), így el kell neveznünk és ezért jelenik meg a „Save File As” ablak. Itt a „Save file as” szerkesztőmezőben villog a kurzor, ahova begépelhetjük a programunk nevét. A példában az „ELSO” nevet gépeljük be.

A következő ujjgyakorlatunk a programunk bezárása lesz. Itt nem a keretrendszer bezárására gondolok (mert az is egy program) hanem az általunk írt/írandó program ablak bezárására. Az ablak bal felső sarkánál lévő kis téglalapra kattintva tehetjük meg vagy az Alt+F3 billentyűkombinációval. A megnyitáshoz használjuk az F3-as gyorsbillentyűt és adjuk meg a megnyitni kívánt program nevét (vagy a fájllistából válasszuk ki), majd üssünk Enter-t. Az IDE-ből való kilépéshez használhatjuk az Alt+X vagy a File menü / Exit parancsát. Egy kis segítség a program szerkesztéséhez:

Egysoros szerkesztőmező

Nyomógomb

·

Karakter törlése Delete és a Backspace (viszanyíl az Enter fölött)

·

Sor beszúrása Ctrl+N

·

Sor törlése Ctrl+Y

·

Felülírás mód ki-, bekapcsolása az Insert billentyűvel

·

A keretrendszer alsó sorában (státuszsor) olvashatjuk a legfontosabb forróbillentyűket. (F1 Help, F2 Save, F3 Open, …)

Könyvtár lista

Hát akkor, íme a várva várt pillanat, készítsük el az első programunkat. Gépeljük be a következő sorokat: Program elso_programom;

Információ sáv

Uses Crt; Begin WriteLn(’Hello világ!’);

3. kép - Fájl mentése

End.

A programunk neve maximum 8 karakter lehet. Alfanumerikus, azaz betű és számjegy karaktereken kívül még a következő karaktereket használhatjuk: ^

$

~

!

#

%

&

-

{

}

(

)

4. kép - Az első programunk az IDE-ben

Az, hogy a fenti példaprogramban néhány szó félkövér betűvel van szedve, néhány pedig nem, ne zavarja meg a kedves Olvasót, hanem formázás nélkül, sorok végén Entert ütve, a beljebb kezdődő részeknél ajánlott 2 szóköz vagy egy TAB használata. Nézzék csak meg a jobboldali képernyőrészletet.

@

Ha nem adunk meg más kiterjesztést, akkor alapértelmezetten PAS lesz a kiterjesztés. Ha azt szeretnénk, hogy ne az aktuális könyvtárba mentse a programunkat, akkor meg kell adnunk a teljes elérési útvonalat (pl.: c:\prg\elso.pas) vagy a könyvtárlista segítségével a kurzormozgató nyilakkal és az Enterrel is odanavigálhatunk, ahova menteni kívánjuk. Figyeljük meg, hogy a dialógus doboz elemeit a a TAB billentyűvel járhatjuk körbe. A Shift+TAB-bal ugyezt a körbejárást az ellenkező irányba tehetjük meg. Figyeljük meg, hogy a nyomógombok közül az OK gomb betűinek a színe fehér és a többié nem. Ez azt jelenti, hogy ő az alapértelmezett nyomógomb. Az alapértelmezett (default) nyomógomb szerepe az, hogy akárhol vagyunk a párbeszédablakban (pl. a szerkesztőmezőben vagy a könyvtárlistában) és Entert ütünk, akkor az a gomb megnyomódik. Tehát nem kell a TAB-bal odanavigálnunk, hogy egy Enterrel aktiváljuk, hanem bárhol állva üthetünk Entert. Természetesen ugyanez megfigyelhető a Windows alatt is, ha egy nyomógomb körül erősebb fekete szegély

38

Íme az első programunk! Most már csak le kell futtatnunk. Ehhez a Run (fuss) menüpont Run alpontját kell kiválasztanunk (Alt+R,R). Amint látható a menüpontban ugyanaz történik a Ctrl+F9-es gyorsbillentyű (forróbillentyű) használatakor is. 5. kép - A program futtatása

39

Ha hibajelzéssel találkozunk, akkor javítsuk ki a hibát és futtassuk le újból a programot. Javasolnám a gyakori mentést az F2-es billentyűvel. Így, ha „elszállna a gép”, akkor sincs akkora baj, mert a lemezünkön van a nemrég mentett programunk, amit még felhasználhatunk.

Önellenőrzés

Nézzük meg az eredményt! Tulajdonképpen nem sokat látunk a Ctrl+F9 lenyomása (a program lefutása) után, maximum egy villanást a képernyőn. Miért is van ez? A programunk lefutott és azonnal visszatért a fejlesztőrendszerbe. De akkor hogyan nézhetjük meg a programunkat? Használjuk az Alt+F5 vagy az Alt+W,U billentyűket user screen (felhasználói képernyő), hogy megnézzük mi is történt.

1. Hány karakterből állhat egy pascal program neve?

Értelmezzük az első programunkat: Program elso_programom;

........................................................................................................................................................... 2. Milyen karaktereket használhat a program (fájl) nevében? ...........................................................................................................................................................

{programfej}

A Program foglalt szóval jelezzük a programunk kezdetét, ami után megadjuk a programunk nevét. (Figyeljük meg, hogy minden programutasítás után „;” áll. A program utolsó sora, az End után a „.” áll). A program neve egy szimbolikus név, a program azonosítója, amit alfanumerikus karakterek és az aláhúzás jel „_” kombinációjával adhatunk meg. Szóközt ne használjunk a névben, helyette az aláhúzás jel javasolt!

3. Hogyan tudja elérni a menüt? (Háromféle módot írjon!)

A forrásprogramban a {kapcsos zárójelek} közé zárt szöveget a Pascal fordítója nem veszi figyelembe, így a megjegyzéseinket e jelek közé írhatjuk. Javaslom, hogy használjunk minél több megjegyzést a program kódjának az egyéb szövegel való kiegészítéséhez, hogy a későbbiekben ne kelljen újból értelmeznünk, és mint egy rejtvényt megfejtenünk a saját programunkat. A modulfüzet példáiból jól fognak látszani a megjegyzések, és tapasztalni fogja a kedves Olvasó, hogy ezek mennyire megkönnyítik a programok értelmezését, olvashatóságát.

4. Hogyan lehet sort törölni a programszerkesztő ablakban?

A következő két sor az {Deklarációs rész}

A Turbo Pascalban unit-nak (egység, csomag) nevezik azokat a programokat, amelyek lehetővé teszik függvények, eljárások alkalmazását. A Crt nevű unit ezek közül az egyik. Amennyiben használni szeretnénk valamelyik unit eljárásait, függvényeit, az uses szó után meg kell adnunk az unit nevét. (Pl. Dos , ha fájlkezelést vagy Graph, ha grafikát is szeretnénk programozni.) A következő utasítások Begin – End (kezd – vég) páros közé vannak zárva. A példaprogramunkban csak egy egyszerű képernyőre való kiírást kértünk. Begin WriteLn(’Hello világ!’);

........................................................................................................................................................... ...........................................................................................................................................................

........................................................................................................................................................... 5. Mi a státuszsor és mit tartalmaz? ........................................................................................................................................................... ...........................................................................................................................................................

Uses Crt;

?

{Maga a programtörzs}

End.

A WriteLn kiírja a képernyőre a zárójelben megadott szöveget – amit aposztrófok között kell megadni – és sort emel. A párja a Write eljárás, ami kiírja a szöveget, és nem emel sort.

6. Hogyan adjuk meg a főprogram kezdetét és végét? ........................................................................................................................................................... 7. Mire való a WriteLn utasítás és miben tér el a Write utasítástól? ........................................................................................................................................................... ........................................................................................................................................................... 8. Mit adhatunk meg az Uses után? Írjon konkrét példát! ........................................................................................................................................................... ........................................................................................................................................................... ...........................................................................................................................................................

40

41

Válaszok 1. Hány karakterből állhat egy pascal program neve? 8 (azaz nyolc, mert a DOS-ban is nyolc karakterből állhat egy fájl neve.) 2. Milyen karaktereket használhat a program (fájl) nevében? Alfanumerikus, azaz betű és számjegy karaktereken kívül még a következő karaktereket használhatjuk: ^ $ ~ ! # % & - { } ( ) @ 3. Hogyan tudja elérni a menüt? (Háromféle módot írjon!) Alt+a menü piros betűje vagy F10-zel a menüsort vagy egérrel 4. Hogyan lehet sort törölni a programszerkesztő ablakban? Ctrl+Y 5. Mi a státuszsor és mit tartalmaz? Egy egysoros információs sor az IDE legalsó sorában. Arra szolgál, hogy a leggyakrabban használt gyorsbillentyűket a helyzetnek megfelelően kiírja. Egy egysoros help (súgó) sor. Ha épp a menüben tallózunk, akkor is láthatjuk, hogy a különböző menüpontokhoz más és más segítséget ír. Ez a súgónak egy gyors és egyszerű megjelenési módja. 6. Hogyan adjuk meg a főprogram kezdetét és végét? A „Begin … End.” párossal Begin … ide jön a főprogram … End.

7. Mire való a WriteLn utasítás és miben tér el a Write utasítástól? Amit a zárójelbe írunk azt kiírja a képernyőre és sort emel, míg a Write szintén kiírja, de a kiírás után nem emel sort. 8. Mit adhatunk meg az Uses után? Írjon konkrét példát! A Turbo Pascalban unit-nak (egység, csomag) nevezik azokat a programokat, amelyek lehetővé teszik függvények, eljárások alkalmazását. A Crt nevű unit ezek közül az egyik. Amennyiben használni szeretnénk valamelyik unit eljárásait, függvényeit, az uses szó után meg kell adnunk az unit nevét. (Pl. Dos , ha fájlkezelést vagy Graph, ha grafikát is szeretnénk programozni.)

42

3. A Turbo Pascal program felépítése Az előzőekben már láthattuk, hogy mit kell tennünk, egy egyszerű program elkészítéséhez. Most nézzük meg, hogy mit is jelentenek azok az utasítások, kulcsszavak amiket eddig használtunk és megnézzük, hogy miket lehet még használni. A programozás azt a folyamatot jelenti, amikor a feladatot a számítógép számára érthető formában írjuk le. A programozás eredményeként létrejön a program. A program legkisebb funkcionális egysége az utasítás. A program, olyan utasítások sorozatából áll, amely a meghatározott feladatot tartalmazza. A leírás nyelvét programozási nyelvnek nevezzük. Mivel a számítógép csak a gépikódú utasításokat tudja feldolgozni ezért szükség van egy fordítóprogramra, ami átalakítja a magasszintű programunkat gépikódúra, azaz lefordítja számára. Ez a program a fordítóprogram (compiler). A programozási nyelveknek is, mint minden más nyelvnek is pontosan meghatározott szabályai vannak (nyelvtana van), amit szintaxisnak nevezünk. Szintaktikai hibáról akkor beszélünk, ha vétünk-e szabály ellen. Például, ha egy zárójelet nem zárunk be vagy egy pontosvesszőt nem teszünk az utasítás végére. Szemantikai hibáról, akkor beszélünk, amikor a nyelv szabályai ellen nem vétünk, azaz szintaktikailag helyes, de programunk nem azt csinálja amit szeretnénk. Azaz a program hiba nélkül lefut, de egy képletet másként számol, mint ahogy azt mi szerettük volna. Például a zárójeleket rossz helyre vagy egyáltalán nem tettük ki, holott szükséges lett volna. Vagy a kör kerülete helyett a területét számolja ki. Minden Pascal program a következő három részből épül fel: · · ·

Program fej Deklarációs rész Program törzs

A program fej egyszerűen a Program kulcsszó és az utána álló névből áll. Már összetettebb rész a deklarációs rész (később részletesen kerül ismertetésre). A mintaprogramban az Uses Crt; tartozik ide és a programtörzs, ami a „Begin – End” párosból áll. Minden program elkészítése, (mint más dolgok elkészítése is) természetesen a probléma megfogalmazásával kezdődik. Ha sikerült megfogalmazni, akkor a tervezéssel folytatódik. A tervezési módszertanok közül az utóbbi időben igen elterjedni látszik az SSADM, a Strukturált Rendszerelemzési és Tervezési Módszertan. A tervezésnél már kiderül, hogy megéri-e elkészíteni a programot vagy sem. Egy jó terv alapján szinte már gyerekjáték elkészíteni a jó programot. Ha elkészült a program, akkor a teszteléssel folytatódik. Amikor a programozó maga teszteli bemenő teszt adatokkal és ellenőrzi, hogy jól dolgozik-e a program, akkor ezt alfa-tesztnek hívják. Amikor már mások is tesztelik a programot, akkor azt a szakaszt béta-tesztnek hívják. Számtalanszor lehet hallani, vagy olvasni, hogy megjelent az XY program bétája. Nos ez is egy tesztelésre szánt program. 43

A kulcsszavak bemutatásával a Pascal program szerkezete: Program fej: PROGRAM programneve; Deklarációs rész: USES

a használandó unitok felsorolása;

LABEL cimkék deklarációja, felsorolása; CONST konstansok felsorolása; TYPE

típusok deklarációja, felsorolása;

VAR

változók deklarációja, felsorolása;

PROCEDURE eljárásneve( paraméterek ); { lokális deklarációk} BEGIN

{a subrutin utasításai} END;

A leggyakrabban használt típusok a következők: · · · ·

Integer Real Char String

BEGIN

{a subrutin utasításai} Függvénynegve := utasítás; {a függvény visszatérési értéke} END;

A főprogram: BEGIN {A főprogram törzsének utasításai} END. Kezdjük talán a legfontosabbal, a változók deklarálásával. A változódeklaráció arra szolgál, hogy előre megmondjuk a programnak, hogy milyen változókat fogunk használni a program során. A Pascalban minden változót előre kell deklarálni, amit a Var kulcsszó vezet be. Nem úgy, mint egyes nyelvekben, hogy amikor először használatba vesszük a változót és értéket adunk neki, akkor jön létre és máris használhatjuk. Itt kérem szépen, előre kell deklarálni! A változó nem más, mint névvel azonosított memóriaterület, aminek típusa van. A típus arra szolgál, hogy megmondja, hogy a használandó memóriaterületet milyen módon fogjuk használni, értelmezni. A Var kulcsszót követően írjuk a változó nevét, melyet kettősponttal elválasztva a típusát adjuk meg. 44

ami csak egész számot tárolhat –32768 és +32767 között valós szám 2.939*10-39 és 1.701*1038 között egyetlen, valamilyen ACSII kódtábla szerinti karakter maximum 255 karakterből álló szövegfüzér, idézet

·

Boolean - logikai változó, amelynek értéke csak IGAZ (TRUE) vagy HAMIS (FALSE) lehet Akkor nézzünk egy kicsit bonyolultabb programot, mint az „első” mintaprogram volt. Program masodik; Uses Crt; Var i,j : integer; x : real; Begin i := 2; j := 6; x := i * j + 3; WriteLn(x); ReadLn;

FUNCTION függvényneve (paraméterek):visszatérési típus; {lokális deklarációk}

-

End.

{program fej} {Unitok felsorolása} {Változók deklarálása} {Program törzs kezdete} {Kezdeti értékadások} {Kifejezés értékének megadása} {az x váltzóba. Az x legyen egyenlő a …} {Az x változó értékének kiírása} {Vár az ENTER leütésére} {Program vége}

Ez a program már összetettebb, mint az előző. De nézzük mit is csinál. A Program fejet már nem kell elmagyaráznom. A következő részét, az unitok deklarálását, azaz a modulok hozzáépítését a programunkhoz, azt sem. Az új rész a változók használata. A Var után három változót deklaráltunk. Ebből kettőnek a típusa egész szám, azaz integer. Az általa felvehető értékek –32768 és +32767 közé esnek, mint ez a fentebbi listából is látszik. Az x típusa valós számként lett meghatározva, ezért ő képes nem csak egészet, hanem tizedes értéket is tárolni. A főprogramban két értékadás következik. Az i:=2; és a j:=6;. A „ :=” jel jobb oldalán álló érték kerül a bal oldalon álló változó által azonosított memóriaterületre. Az x := i * j + 3; is egy érték adó utasítás, de a jobb oldalon egy kifejezés áll. Ennek a kifejezésnek az értéke kerül az x változóba. De lássuk, hogy mi is az a kifejezés és hogyan értékelődik ki. A „:=” jel jobb oldalán álló karakterek közül az „i” a „j” és a „3” az operandusok és a „*” a „+” jel az operátorok, azaz amik az operandusokon valamilyen operációt hajtanak végre. Az operandusok és az operátorok együttesen kifejezés alkotnak. A kifejezés értékének a típusa megmondja, hogy milyen típusú maga a kifejezés. Pl. a „3>5” éréke logikai eredményt ad, ezért a kifejezés típusa is logikai vagy a ’Gipsz ’ + ’Jakab’ szöveges kifejezés. Ezért a típusa is szöveges. De lássuk csak, hogy mennyi is lesz az eredmény a fenti kifejezésnél. Vajon mennyi lesz? Egy kicsit becsapós, ugye? Itt is, mint a matematikában, vannak elsőbbségi 45

szabályok amiket be kell tartani egy kifejezés kiértékelésénél. Ebben a példában először a szorzás értékelődik ki, majd az összeadás. Azaz behelyettesítjük az i és j változó helyére az értékeit, majd ezeket összeszorozzuk, és az eredményhez hozzáadjuk a 3-at. Tehát az x értéke az x:=2*6+3, azaz 15 lesz, amit a következő sorban a WriteLn(x) eljárás ki is ír a képernyőre majd sort emel, mint azt már tudjuk. De vajon mit csinál a ReadLn; eljárás? Így önmagában nem csinál mást, mint vár egy Enter leütésére, hogy a programunk a képernyőről ne szaladjon el, hanem el lehessen olvasni a kiírt eredményt és amikor végeztünk, akkor az Enter lenyomásával tovább fut, ebben az esetben véget ér a program, azaz visszatér az őt hívó programba, itt az IDE-be. Itt jön az a probléma, hogy ha nem mi futtatjuk a programot, akkor mások honnan tudják, hogy Enter-t kell ütni, vagy mit kell tenni. Ezért minden programot úgy kell elkészíteni, hogy mások is tudják használni anélkül, hogy az alapvető kezelési műveleteket el kellene magyarázni nekik. Most bővítsük a programunkat úgy, hogy az i és j értékeket a billentyűzetről olvassuk be. Program harmadik; Uses Crt; Var i,j : integer; x : real; Begin ClrScr; Write(’Add meg az i értékét: ’); ReadLn(i);

{Program fej} {Beépülő modulok} { felsorolása} {Változók deklarálása} {egész típusok} {valós típusok} {Program törzs kezdete} {Képernyőtörlés} {Szöveg kiírása a képernyőre} {Az i változó értékének} {bekérése billentyűzetről} Write(’Add meg az j értékét: ’); {Szöveg kiírása a képernyőre} ReadLn(j); {A j változó értékének} {bekérése billentyűzetről} x := i * j + 3; {Az x értékének megadása} WriteLn(’Az x értéke = ’,x); {Az x értékének kiírása} WriteLn(’Üss ENTER-t a kilépéshez.’) {Szöveg kiírása a képernyőre} ReadLn; {Várakozás az ENTER-re} End. {Program vége.}

Remélem, érzi a kedves Olvasó, hogy a megjegyzések jó szolgálatot tesznek a program olvashatóságában. Lássuk, mi is történik ebben a programban. A program fej és deklarációs része ugyanaz, mint az előzőé. A program törzsben van némi változás. Az első a ClrScr; utasítás, ami a Clear Screen rövidítése, azaz a képernyő törlése. Ha maradt valami a képernyőn, akkor is a programunk tiszta lappal indulhat útjára, mert az első utasítás a képernyőtörlés.

szövegnek tekinti és ebben az esetben csak megjeleníti a képernyőn a kurzor aktuális pozíciójától kezdve. A ReadLn(i); bekér a billentyűzetről egy értéket, amelyet majd az i változó által azonosított memóriaterületre helyezi el. Az i változónak így adhatunk értéket a program futása közben. Ugyanez történik a következő két sorban is, csak ott a j változónak kérjük be az értékét. Az értékadás már ismerős. A WriteLn(’Az x értéke = ’,x); egy kicsit eltér a megszokottól. Itt kombinálva van a szöveg kiírás, ami ’’ jelek között van és az érték kiírás. Ha jól megnézzük a zárójelek közötti részt, akkor a szöveges kiírandó rész után vesszővel van elválasztva az x változó, aminek az értékét kell kiírni a képernyőre és nem az x karaktert. Megjegyezném, hogy a Write és WriteLn zárójelei közé több paramétert is meg lehet adni, csak vesszővel kell elválasztani. Ezek után egy üzenet következik, hogy tájékoztassuk a felhasználót a program kezeléséről, majd várakozik az Enter leütésére. Ezzel véget is ért a programunk. A fenti példaprogramok már a kezdeti sikerélményeken túlnyúlnak. Ha sikerült a fenti részeket a gyakorlatban elvégeznie és sikerült megértenie a program működését, akkor is előfordulhat, hogy egy egyszerűnek tűnő programot a fordító nem fordít le, mert hibát jelez. Figyeljünk oda, hogy minden utasítás végére tegyünk pontos vesszőt. Ha fordítás közben hibát jelez, akkor az IDE segít abban, hogy a hiba helyét megtaláljuk. Azaz a kurzort a hiba helyére vagy közelébe viszi és így könnyebben rátalálunk a hibára. Legtöbb esetben a pontosvessző hiánya szokott gondot jelenteni a kezdő programozóknak. A keretrendszer ebben az esetben a következő sor elejére viszi a kurzort és így egy kicsit nehezebben találjuk meg, hogy mit is kell javítanunk. Szerencsére a programablak bal felső sarkában egy piros hátterű szövegben kiírja, hogy mit hiányol és nagy pontossággal el is találja. Ha pontosvesszőt, akkor azt írja ki, hogy nem talál egy vagy több pontosvesszőt. 1. FELADAT Írjon programot, mely a kör kerületét és területét számítja ki. A program kérje be a sugár értékét. 2. FELADAT Írjon programot, mely egy téglatest felszínét és térfogatát számítja ki. A program kérje be a három él hosszát. 3. FELADAT Keresse meg az Interneten vagy az ajánlott irodalomjegyzék könyveiben, hogy a WriteLn vagy a Write által kiírt értéket miért írta ki az eredményt normál alakjában. Hogyan lehet úgy kiíratni egy számot, hogy az a szám természetes formában jelenítse meg? Pl: 15.35, azaz két tizedessel. (Ez természetesen a későbbiekben ismertetésre kerül majd.)

A következő sor a WriteLn eljárás. Ami a ’’ jelek (aposztrófok) között van, azt a szöveget kiírja a képernyőre. Amit ’’ jelek közé teszünk, azt nem értelmezi, hanem ún. felhasználói

46

47

Önellenőrzés

?

1. Mit jelent a programozás?

Válaszok

...........................................................................................................................................................

1. Mit jelent a programozás? A programozás eredményeképpen létrejön a program.

2. Milyen elemekből épül fel a Turbo Pascal program?

2. Milyen elemekből épül fel a Turbo Pascal program? · Program fej

........................................................................................................................................................... 3. Mi a változó? ........................................................................................................................................................... 4. Milyen fontosabb változó típusok vannak a Pascalban? És milyen értéket tárolhatnak? ........................................................................................................................................................... ...........................................................................................................................................................

·

Deklarációs rész

·

Program törzs

3. Mi a változó? Egy névvel azonosított memóriaterület, melynek típusa van, ami azt határozza meg, hogy hogyan, milyen módon fogjuk a memóriában tárolt értéket használni. 4. Milyen fontosabb változó típusok vannak a Pascalban? És milyen értéket tárolhatnak? A leggyakrabban használt típusok a következők: ·

Integer

- ami csak egész számot tárolhat –32768 és +32767 között

·

Real

- valós szám 2.939*10 -39 és 1.701*1038 között

...........................................................................................................................................................

·

Char

- egyetlen, valamilyen ACSII kódtábla szerinti karakter

...........................................................................................................................................................

·

String

- maximum 255 karakterből álló szövegfüzér, idézet

·

Boolean

- logikai változó, amelynek értéke csak IGAZ (T RUE) vagy HAMIS (FALSE) lehet

........................................................................................................................................................... 5. Mi a kifejezés? Mi határozza meg a kifejezés típusát? ........................................................................................................................................................... ........................................................................................................................................................... 6. Milyen elemekből épül fel a deklarációs rész? ........................................................................................................................................................... ........................................................................................................................................................... ...........................................................................................................................................................

5. Mi a kifejezés? Mi határozza meg a kifejezés típusát? Operandusok és opárotorok együttesen kifejezést alkotnak. A kifejezés eredményének a típusa mondja meg, hogy milyen típusú a kifejezés. 6. Milyen elemekből épül fel a deklarációs rész? · USES · LABEL · CONST · TYPE · VAR · PROCEDURE · FUNCTION

........................................................................................................................................................... ...........................................................................................................................................................

48

49

Azonosítók

4. A program nyelvi elemeinek ismertetése Az előző fejezetben egy-egy mintaprogramon keresztül röviden ismertetésre kerültek a változók és deklarálásuk módja. Ismertetésre került dolgok már korántsem elegendőek ahhoz, hogy komolyabb programokat tudjunk írni, de kellő alapot biztosítanak a nagyobb programjaink elkészítéséhez. Nézzük hát a nyelv jelkészletét, majd a nyelvi elemeket egy kicsit részletesebben.

A változóknak, a konstansoknak, a típusoknak, az eljárásoknak, a függvényeknek, az unitoknak és a programnak, a rekordban szereplő mezőknek is nevet kell adni, hogy hivatkozni lehessen rájuk. Ezeknek a neveknek egyedieknek kell lenniük. Bármilyen hosszúak lehetnek, de csak az első 63 karaktert azonosítja a TP. Az azonosító azt jelenti, hogy a nevével az általa azonosított Pascal elemet tudjuk vele elérni. Az azonosító neve utaljon a bennük tárolt tartalomra. Mint pl: sugar; a_oldal; b_oldal.

A nyelv jelkészlete

A foglal szavakat nem szabad azonosítóként használni!

A TP7 az ASCII karakterekből csak a következőket használja: ·

Betűk: A..Z és a..z az angol ABC betűi.

·

Számok: 0..9

·

Hexadecimális számok: 0..9 A..F vagy a..f

·

Szóköz (ASCII 32) és az összes ASCII vezérlőkarakter pl. az Enter (#13#10)

A helyes megadásuk: betűvel vagy „_” (aláhúzás) jellel kezdődnek, nem tartalmaznak szóközt, de következhet betű vagy szám vagy „_” jel. A kis és nagybetűket itt sem különbözteti meg a Pascal.

Egyszerű speciális szimbólumok: + - * / = . , : ; ’ ^ _ @ $ # < > [ ] ( ) { }

Számok

A következő karakterpárok szintén speciális szimbólumok: := <= >= <> ..

(*

A számok egész és valós típusúak lehetnek, valamint decimális és hexadecimális.

*)

Az egész számok megadása egyszerűen történik, ahogy leírjuk. Csak a negatív számoknál szükséges jeleznünk az előjelet egy „-” jellel. Pl: 5, -5, de megengedett a +5 használata is.

A foglalt szavak A foglalt szavak a Pascal nyelv utasításai és a deklarációkat bevezető kulcsszavak. absolute and array begin case const div do downto else

end external file for forward function goto if implementation in

inline interface interrupt label mod nil not of or packed

procedure program record repeat set shl shr string then to

type unit until uses var while with xor

A program sorai A Pascalban az utasítások leírásának nincsenek kötött merev szabályai, mivel egy utasítást akár több sorban is leírhatunk, illetve egyetlen sorban több utasítás is lehet. A lényeg, hogy az utasítás végén a „;” szerepeljen, kivéve az utolsó End utáni „.” (pontot).

7

TP: Turbo Pascal

50

Helyesen pl: u_neve, u_cím1, u_cim2, u_irszam, u_szuldatum Helytelenül pl: r/3, x.25, b*c, mivel ezek a „/” a „.” (pont) és a „*” karaktereket tartalmazzák.

A valós szám a következő részekből épül fel: ·

előjel

-

·

egészrész

1

·

tizedespont

.

·

törtrész

456

·

kitevő

E+04

Azaz: –1.456E+04 A szám jelentése a következő: -1.456 * 104, azaz 14560. A –45.678E-6 a következőt jelenti: -0.000045678.

Sztringek A sztring egy karakterfüzér. Azaz ASCII karakterek egymás melletti sora, amiket ’-ok (aposztrófok) közé kell tenni. Pl: ’Gipsz Jakab’ – ami egy 11 karakterből álló sztring, beleértve a szóközt is. Az ’’ egy 0 karakterből álló sztring, amit üres sztringnek nevezünk. Lehetőség van az ASCII karakterek közvetlen megadására is, de ezeket általában csak a vezérlő karaktereknél szokták használni. Ebben az esetben a „#” (hashmark, kettőskereszt, kertléc, börtönablak, és még sorolhatnám a különböző elnevezéseit) után a karakter ASCII-kódja szerepel.

51

Ilyen sztring pl. a #13#10, ami az Enternek felel meg. Mert tudniillik az Enter az nem más mint egy „kocsi vissza+sor emelés” karakter párból áll. Így ennek megadása is ennek megfelelően történik. Azaz a kocsi vissza az #13-as karakter és a soremelés a #10-es karakter. Egy másik példát hadd említsek, az a duda. Ha pl. a „WriteLn(#7)”, azaz a #7-es karakter kerül kiíratásra, akkor az megszólaltatja a számítógép hangszóróját egy duda erejéig. Ez általában hibajelzésre szokták használni, vagy valamilyen figyelemfelkeltő funkciója van, ha pl. egy hosszabb programfutási feladat véget ért.

Címkék A címke egy számokból álló sor. 0..9999. Természetesen a bevezető 0 itt is értelmetlen. A TP-ben engedélyezett a címkének az azonosítóval való jelölése. A címkéket a goto utasításnál használjuk, vele közvetlenül ugorhatunk egy megadott programrészre. Ez azonban ellenkezik a strukturált programozási szemlélettel. A TP-ben használható címkék: ide, oda, eleje, kozepe, vege, 33, 44.

Operandusok A kifejezésekben lévő változókat, konstansokat, függvényeket operandusoknak nevezzük. Legyen a következő kifejezés: x + y * 2 +cos(30) / 3.14 Ebben a kifejezésben az x, y, 2, cos(30), 3.14 tagok az operandusok.

Operátorok A kifejezésekben lévő változókat, konstansokat, függvényeket összekapcsoló műveleti jeleket operátoroknak nevezzük. Legyen a következő kifejezés: x + y * 2 - cos(30) / 3.14 Ebben a kifejezésben az +, *, -, / jelek tagok az operátorok. Az operátorok az aritmetikai műveleti jelek (+,-,*,/, etc…) a logikai műveleti jelek (and, or, not, …) és a relációjelek (<,>,<>,<=, …). Az operátoroknak, mint műveleti jelek közötti precendiája (végrehajtási sorrendje) van. Precedencia szintje Első Második Harmadik Negyedik

Operátor @, not *,/,div,mod,and,shl,shr +,-,or,xor =,<,>,<=,>=,in

Elsőbbségi szabály A kifejezések kiértékelésénél három precedencia szabályt kell figyelembe venni: · Ha két különböző precedenciájú operátor között van az operandus, akkor a magasabb precedenciájú operátorhoz tartozik, tehát először az a művelet kerül végrehajtásra · Ha két azonos precedenciájú operátor között van az operandus, akkor a tőle balra álló operátorhoz tartozik és az a művelet kerül végrehajtásra. · Ha a művelet zárójelezve van, akkor a zárójelben lévő műveletek kiértékelésének van nagyobb prioritása.

52

Kifejezések Operandusok és operátorok együttesen kifejezéseket alkotnak. Már említésre kerültek, hogy különböző típusú kifejezések léteznek. mint pl: aritmetikai, logikai, karakteres, …

Operátorok csoportosítása Aritmetikai operátorok Az összeadás, kivonás, szorzás, osztás (+,-,*,/) gondolom senkinek sem jelen különösebb problémát. De vajon mi lehet a maradék két operátor a mod és a div? nos egész számok esetén nem értelmezett az osztás művelete. Ott el kell dönteni, hogy az osztás egészrész eredményére vagyunk kíváncsiak vagy az osztás maradákára. A div az egész osztás operátora, a mod a maradék képzés operátora. Pl: 10 div 3 = 3 és a 10 mod 3 = 1. Azaz a 10-ben a 3 megvan 3-szor, és a maradék 1. Egyoperandusú aritmetikai operátorok az előjelek. Pl: +10 vagy –5. Bitenkénti operátorok A bitenkéni logikai műveleteket csak egész típusú operandusokon lehet végrehajtani. Ilyen operátorok a következők. not, and, or, xor, shl és az shr. Például a 52 or 110 = 126. Ha átszámoljuk bináris számrendszerbe és elvégezzük az or logikai függvény műveletét, majd visszaváltjuk az eredményt decimálisba, akkor 126-ot kapunk. Vagy léptessük a biteket kettővel balra: 12 shl 2 = 48. Mert az shl művelet 2-vel való szorzást jelent. Ha kétszer léptetünk balra, akkor azt kétszer kell szorozni. Váltsuk át a 12-t bináris alakba majd léptessük az shl-lel kétszer és váltsuk vissza tízesbe. Ugyanígy járunk el, ha az 56 shr 2 = 14. Logikai operátorok A boolean operátorok: not, and, or, xor Relációs, összehasonlító operátorok =

egyenlő

<>

nem egyenlő

<

kisebb

>

nagyobb

<=

kisebb egyenlő

>=

nagyobb egyenlő

Pl: · (3 >= 5) HAMIS · (5 > 5) HAMIS · (5>=5) IGAZ, mert nem nagyobb, hanem az 5 egyenlő 5 rész teljesül. · (5>=3) IGAZ, mert itt a nagyobb jel ad logikai IGAZ értéket

53

@ (Pointer) operátor A pointer operátor egyoperandusú operátor. Pl: @a vagy a p^ A @ bármilyen típusú operandus címét jelenti a memóriában. A fenti példában az „a” változó címét jelenti.

A függvényekről tudni kell, hogy amit a zárójelei közé írunk azoknak a változóknak, mint bemeneti változóknak veszi az értékét, és velük végzett műveletek után visszaadnak valamilyen értéket. Matematikai függvények · Abs(x)

abszolút érték (az x abszolút értékét adja vissza)

A ^ jelet pointer esetén lehet használni. A fenti példában a p^ a pointer által mutatott objektumot jelenti.

· ArcTan(x)

arkusztangens

· Cos(x)

radiánban megadott érték koszinusza

Sztring operátorok

· Exp(x)

exponenciális

A sztringeknél csak az összefűzést (a konkatenálást) használhatjuk, de az összefűzött sztring mérete sem lehet 255 karakternél hosszabb.

· Frac(x)

valós típusú kifejezés tört részét adja vissza

· Int(x)

valós típusú kifejezés egészrészét adja vissza

Pl: ’Gipsz’ + ’ ’ + ’Jakab’. Itt 3 sztringet fűzünk össze, melyből a középső egy szóközt tartalmaz. Így az eredmény: ’Gipsz Jakab’ lesz. De lehetett volna ASCII karakterként is hozzáfűzni. Pl: ’Gipsz’ + #32 + ’Jakab’.

· Ln(x)

természetes alapú logaritmus

· Odd(x)

ha az egész típusú kifejezés páratlan, akkor TRUE8 , különben FALSE9 értéket ad vissza

Halmaz műveleti operátor A TP-ben a halmazokkal is végezhetünk műveleteket. Ilyen műveletek a következők:

· Pi

a PI értékét adja vissza

· Random

véletlen számot generál, ha nem adunk határt, akkor 0 és 1 közötti értéket generál

· Randomize

a véletlen szám generátornak kezdőértéket ad

+ a halmazok egyesítése *

a halmazok metszete

-

halmazok különbsége

· Round(x)

a valós típusú kifejezést a legközelebbi egészre kerekíti

Precedencia a következő:

· Sin(x)

a radiánban megadott szinuszt adja vissza

Először a „*” hajtódik végre majd utána az „+” és a „–”.

· Sqr(x)

négyzet

· Sqrt(x)

négyzetgyök

· Trunc(x)

valós típusú kifejezés nulla felé kerekített egész részét adja vissza úgy, hogy levágja a tizedestört részt

Halmazműveletek: Itt csak röviden térnék ki a halmazműveletek ismertetésére. Az A és B halmaz metszetének (közös részének) elemei azok az elemek, melyek A-nak és B-nek is elemei, tehát közösek. Az A és B halmaz egyesítésének azok az elemei, melyek elemei A-nak is és B-nek is. Azaz a teljes elemkészlet, de a közös elemeket csak egyszer tartalmazza.

Megszámlálható típusokra használható függvények (a System unitban) · Dec(x)

csökkenti az x értékét eggyel. Megfelel az x:=x-1 kifejezésnek.

· Dec(x,n)

csökkenti az x értékét n-nel, megfelel az x:=x-n kifejezésnek

A halmazok különbségének azok az elemei A és B halmaz esetén, ha A-B különbség esetén, amelynek minden eleme az A halmaznak, de nem elemei a B-nek. Azaz az első halmaznak elemei, de nem elemei a másodiknak.

· Inc(x)

növeli az x értéket eggyel. megfelel az x:=x+1-nek

Megjegyzések

· Inc(x,n)

növeli az x értékét n-nel, megfelel az x:=x-n kifejezésnek

A programban bárhol elhelyezhetők a megjegyzések. Megjegyzést kétféle módon írhatunk. Az egyik a {kapcsos zárójel} közé írt szöveg a másik a (*az összetett karakterből álló*) megjegyzés. {de megengedett az (*ilyen típusú megjegyzés*) használata is.} Viszont az {ilyen típusú megjegyzés {nem megengedett}} és (*ez (*sem*) engedett*) meg.

· Ord(x)

a sorszámozott kifejezés sorszámával tér vissza

· Pred(x)

a sorszámozott típus előző sorszámával tér vissza

· Succ(x)

a sorszámozott típus következő sorszámával tér vissza

· Chr(x)

az x kódnak megfelelő ASCII karakterrel tér vissza

Szabványos függvények használata A szabványos függvények használatához nem szükséges egyéb unit meghívása, mint pl a CRT, mert ezek a függvények benne vannak a SYSTEM unitban, amit a TP minden különösebb deklaráció nélkül a rendelkezésre bocsát.

54

8 9

IGAZ HAMIS

55

Sztring kezelő függvények

Olvasás a billentyűzetről

· Concat(s1,s2,…)

karakterláncokat fűz össze

· Copy(s,index,count)

az s karakterlánc, az indexben megadott sorszámú karaktertől count darab karaktert másol

· Delete(s,index,count)

az s sztring az indexben megadott pozíciójától count darabot töröl

· Insert(source,s,index)

source karakterláncot az s sztring indexben megadott pozíciójától beszúrja

· Length(s)

az s sztring hozzát adja meg

· Pos(substr,s)

az s karakterláncban megkeresi a substr sztringet és a pozícióját adja meg

· Str(x,s)

x egész típusú kifejezés értékét konvertálja az s sztringbe

· Str(x:w:d,s)

x valós típusú kifejezés értékét konvertálja (alakítja át) w mezőszélességgel és d tizedek számával s sztringbe

· UpCase(ch)

A ch kisbetű karaktert nagybetűssé alakítja át

· Val(s,v,code)

Az s karakterláncot konvertálja a v típusának megfelelő numerikus értékké. Ha a sztringben érvénytelen karakter fordul elő, akkor a code változóba kerül annak pozíciója, egyébként 0 lesz az értéke.

Írás a képernyőre

·

WriteLn(argumentum lista)

A Write a kurzor pozíciójától kiírja az argumentumban szereplő értékeket és nem emel sort, míg a WriteLn a kiírás után sort emel. Azaz a kurzort a következő sor elejére helyezi a kiírás után. Write(paraméter: n: m), ahol n a mezőszélesség és m a tizedes jegyek száma.

10

A változók numerikus, karaktes és string (karakterlánc) típusúak lehetnek. Pl. logikai nem. Példa: ReadLn(fizetes); A program ennél a sornál megáll, a leütött karakterek a képernyőn is megjelennek, és az Enter leütéséig szerkeszthetők. Majd a változóba bekerül a megfelelő típusú érték. Ha a beírtak nem felelnek meg a változó típusának, akkor a program futási hibával leáll (I/O hiba lép fel). Karakteres, karakterlánc típusú változók olvasásakor a Read használata kellemetlen félreértéseket okozhat, használjuk a ReadLn eljárást. A Read eljárás a billentyűzet pufferból kiolvassa a változónak megfelelő értéket, de nem törli a puffert, míg a ReadLn eljárás olvasás után törli a puffert. Azaz az Enter billentyű nem bennmarad bent a billentyűzet pufferében. 1. FELADAT Kösse össze a kifejezéseket a hozzájuk tartozó típúsokkal:

Numerikus

3>4 ’Gipsz’ + #32 + ’Jakab’

Az argumentumok 10 lehetnek: szöveg ’’-ok (aposztrófok) között, változó nevek, konstansok, aritmetikai kifejezések, logikai kifejezések és függvényhívások.

Pl: 0.005 5.0000000000E-03 vagy 15.6

Read(v1 [,v2...]) ReadLn(v1 [,v2...])

3+4

A példaprogramnál már ismertetésre került a WriteLn és a Write eljárás. Write(argumentum lista)

· ·

’3+’ + ’4’

Alapvető input és output műveletek

·

A Pascal nyelvben nincs input utasítás, a billentyűzetről a változókba a Read és a ReadLn eljárások segítségével olvashatunk be.

Szöveges

’4 / 2’ 6*8

Logikai

’5’ + ’ darab’ A <= B

1.5600000000E+01

paraméterek, bemenő értékek

56

57

Önellenőrzés

?

Válaszok

1. Írjon ide 5 darab Pascalban használt foglalt szót.

1. Írjon ide 5 darab Pascalban használt foglalt szót.

...........................................................................................................................................................

Begin, End, Else, Mod, Div, Shl, Shr, Xor, With, While, Uses, Procedure, …

2. Írjon le 3 azonosítót.

2. Írjon le 3 azonosítót.

...........................................................................................................................................................

VezetekNeve, KeresztNeve, Varos, Utca, Kerulet, Terulet, Magassag, …

3. Milyen részekből épül fel egy valós szám?

3. Milyen részekből épül fel egy valós szám?

...........................................................................................................................................................

Például a -1.456E+04 · előjel

........................................................................................................................................................... 4. Milyen módon kell megadni a string típusú változó értékét? ...........................................................................................................................................................

-

·

egészrész

1

·

tizedespont

.

·

törtrész

456

·

kitevő

E+04

5. Mi az operandus?

4. Milyen módon kell megadni a string típusú változó értékét?

...........................................................................................................................................................

Aposztrófok között kell megadni, például:

6. Mi az operátor?

VezNeve := ’Kovács’;

...........................................................................................................................................................

5. Mi az operandus? A kifejezésekben lévő változókat, konstansokat, függvényeket operandusoknak nevezzük.

7. Mi a kifejezés?

6. Mi az operátor? A kifejezésekben lévő változókat, konstansokat, függvényeket összekapcsoló műveleti jeleket operátoroknak nevezzük.

........................................................................................................................................................... ........................................................................................................................................................... 8. Milyen módon csoportosíthatjuk az operátorokat? ........................................................................................................................................................... ...........................................................................................................................................................

58

7. Mi a kifejezés? Az operandusok és operátorok együttes halmaza kifejezést alkotnak. 8. Milyen módon csoportosíthatjuk az operátorokat? Aritmetikai, bitenkénti, logikai, relációs, pointer, sztring, halmazműveleti operátorok

59

Begin

5. Egyszerű programpéldák

ClrScr; Write(’A henger sugara = ’);

1. PÉLDAPROGRAM

ReadLn(sugar); Write(’A henger magassága = ’);

A program kérjen be három számot és írja ki az átlagukat valamaint az összegüket.

ReadLn(magassag); Program atlag_es_osszeg;

terfogat := sugar * sugar * 3.14 * magassag;

Uses

felszin := 2 * sugar

Crt;

* 3.14 * magassag + 2 * sugar * sugar * 3.14;

WriteLn(’----------------------------------------’);

Var

WriteLn(’A henger felszíne = ’, felszin:10:2);

a, b, c, atlag, osszeg : Real;

WriteLn(’A henger térfogata = ’, terfogat:10:2);

Begin

WriteLn;

{Üres sorok beszúrása}

ClrScr;

WriteLn;

Write(’a= ’);

WriteLn(’Nyomd meg az ENTER-t a kilépéshez.’);

ReadLn(a);

ReadLn;

Write(’b= ’);

End.

ReadLn(b); Write(’c= ’); ReadLn(c);

1. FELADAT

osszeg := a + b + c;

Írja meg ugyanezt a programot úgy, hogy a PI értékét konstansként tárolja. Ebben az esetben a programunk eleje valahogy így fest:

atlag := osszeg/3; WriteLn(’----------------------------------------’); WriteLn(’A három szám összege = ’, osszeg:10:2);

Program atlag_es_osszeg;

WriteLn(’A három szám átlaga = ’, atlag:10:2);

Uses

WriteLn;

{Üres sorok beszúrása}

WriteLn;

Crt; Const

WriteLn(’Nyomd meg az ENTER-t a kilépéshez.’); ReadLn; End.

pi = 3.14; …

A programunk törzsének egy részlete pedig így: terfogat := sugar * sugar * pi * magassag;

2.PÉLDAPROGRAM

felszin := 2 * sugar

* pi * magassag + 2 * sugar * sugar * pi;

Készítsünk programot, mely kiszámolja egy henger felszínét és térfogatát. A program kérje be a henger sugárának értékét és a henger magasságát. Program atlag_es_osszeg; Uses Crt; Var Sugar, magassag, felszin, terfogat: Real;

60

61

Önellenőrzés

Válaszok

1. Milyen változókat deklarálna, ha egy kocka felszínét és térfogatát kiszámító programot kellene készítenie?

1. Milyen változókat deklarálna, ha egy kocka felszínét és térfogatát kiszámító programot kellene készítenie?

...........................................................................................................................................................

a_oldal, felszin; terfogat

...........................................................................................................................................................

2. Milyen típusúnak választaná meg a fenti változókat és miért?

2. Milyen típusúnak választaná meg a fenti változókat és miért?

Real, mert a kocka oldala, felszíne vagy térfogata nem minden esetben egész szám, így olyan típust kell választani, amely valós értékeket is felvehet.

...........................................................................................................................................................

3. Mit eredményez a WriteLn paraméter nélküli meghívása?

...........................................................................................................................................................

Sort emel. Utána a kiírás a karakteres képernyő következő sorában kezdődhet.

3. Mit eredményez a WriteLn paraméter nélküli meghívása?

4. Írjon programrészletet, mely bekér 10 számot és kiírja a legkisebbet és a legnagyobbat.

...........................................................................................................................................................

Program min_max;

........................................................................................................................................................... 4. Írjon programrészletet, mely bekér 10 számot és kiírja a legkisebbet és a legnagyobbat. Program min_max; Uses Crt; Var

Begin …

Uses Crt; Var min, max, szam, i : Integer; Begin … {Egyéb programutasítások} min := 0; max := 0; For i:=1 To 10 Do Begin WriteLn(’Add meg a(z) ’,i,’. számot’: ); ReadLn(szam) If szam < min Then {a minimum érték felvétele} min := szam; If szam > max Then {a maximum érték felvétele} max := szam; End; WriteLn(’A legkisebb szám: ’, min); WriteLn(’A legnagyobb szám: ’, max); … {Egyéb programutasítások} End.

… End.

62

63

Lineáris programozási módszerek alkalmazása 1. A Pascal nyelv utasításai Bevezetés Képzeljenek el egy robotot. Egy teljesen egyszerű, emberszabású robotot, melynek alapvető utasításokat adhatnak. Legyen az a feladat, hogy olyan utasításokat adjanak ennek a robotnak, hogy menjen el egy telefonfülkéhez és hívjon fel valakit. Ez a robot csak elemi utasításokat ért meg. A mi programjaink is csak elemi utasításokból épül fel. Ezeknek az elemi utasításoknak a jól megszervezett egymásutánisága, ismételt végrehajtása, bizonyos feltételek szerinti végrehajtása eredményezi a strukturált programozást. Lássuk hát, hogy mi minden szükséges az ilyen programok elkészítéséhez. A tanulási feladatok elvégzése után a hallgató: · Ismerni fogja, és használni tudja majd az alapvető strukturális utasításokat · Ismerni fogja, és használni tudja majd a Pascal nyelv adattípusait · Képes lesz összetettebb programokat írni Rész célkitűzések 1. A Pascal nyelv utasításai 2. A Pascal nyelv adattípusai 3. Példaprogramok 4. Rendezések

Az utasításokat egyszerű és struktúrált utasításokra csoportosíthatjuk. Az alábbi ábrán látható a csoportosítás, (félkövéren szedve a konkrét utasítás). Utasítás

Egyszerű

Üres

Struktúrált

Blokk

Feltételes

Ciklus

With

Értékadó Goto Eljáráshívás

If

For

Case

While Repeat

6. ábra - az utasítások csoportosítása

Az egyszerű utasítások Üres utasítás Az üres utasítás a „;” (pontosvessző). Akkor használjuk, ha még nem készült el egy eljárás vagy függvény, de a helyét meg szeretnénk adni. Javaslom, hogy a használatát kerüljük. Értékadó utasítás A baloldalon csak egy változó állhat, a jobboldalon egy kifejezés, konstans, változó. Azaz baloldal := jobboldal ; Például: x := a + b * c; De ugyanúgy érvényes a következő forma is: x := x + 3; Mit is jelent ez, hiszen ez matematikailag sántít egy kicsit. Minden esetben, először a jobboldali kifejezés értékelődik ki, majd amikor megvan az eredmény, akkor kapja meg a baloldali változó. Azaz, ha kezdetben az x értéke mondjuk 3 volt, akkor a jobboldali kifejezés 3+3, azaz 6 lesz a végeredmény. Így az x új értéke már 6 lesz. Aritmetikai értékadás Az aritmetikai értékadásnál a változó numerikus értéket vesz fel. Logikai értékadás A logikai (boolean) értékadásnál a változó logikai értéket vesz fel. A baloldalon Boolean típusú változónak kell állnia. A jobboldalon lehet logikai változó, konstans, vagy kifejezés, aminek eredménye logikai. Pl: i := a <= b;

64

65

Goto utasítás A goto egy feltétel nélküli ugróutasítást tesz lehetővé. A strukturált programozásnál teljesen el lehet hagyni a goto utasítást (és ez erősen javasolt is). Eljáráshívás

Akkor legyen az utasítások sorozata a következő: 1. Emeld fel a bal lábad 2. Nyújtsd ki a bal lábad 3. Dőlj előre 10 fokot (így előre esik és a bal lábára helyeződik a súly)

Az eljárást a nevével és az aktuális paramétereivel hívjuk meg. Ezzel később részletesen is foglalkozunk majd.

4. Egyenesedj ki

A gyakorlatban igen javasolt a képernyőre való kiírást megkönnyíteni vagy keretrajzolást leegyszerűsíteni. Ezért magunknak kell készíteni egy kiíró eljárást.

6. Nyújtsd ki a jobb lábad

Pl: kiir(10,15,’Hello’,zold,kek) Ami azt jelenti, hogy a 10. sor 15. oszlopába kiírjuk a ’Hello’ szöveget zöld színnel és kék háttérrel. keret(5,5,20,20,dupla)

Ami például azt csinálja, hogy a duplavonalas keretet rajzol a képernyőre az 5,5-ös koordinátától a 20,20-asig. Ezek a koordináták a bal felső sarkát jelentik és a jobb alsót. Remélem észrevette a kedves Olvasó, hogy ezek az eljárásnevek magyarul vannak írva. Ezek nem léteznek a pascalban, ezeket mi magunknak kell leprogramoznunk, hogy használhassuk őket.

5. Emeld fel a jobb lábad 7. Dőlj előre 10 fokot (így előre esik és a jobb lábára helyeződik a súly) 8. Egyenesedj fel …. Nos ezeket az utasításokat kell ismételni, amíg a telefonfülkéhez nem ér. … (kanyart és egyéb akadályokat most ne is vegyünk figyelembe). Ezeket csoportba foglalva járásnak is hívhatnánk. Akkor most mit tegyen? 9. Emelje fel a jobb kezét 10. Fogja meg a kilincset 11. Nyissa ki az ajtót (azaz, ha megfogta a kilincset, akkor húzza maga felé az ajtót) 12. Engedje el a kilincset

Struktúrált utasítások A blokk utasítás

13. Lépjen be

A blokk utasításnak ott van szerepe, ahol olyan utasítások, amelyik csak egyetlen utasítást tudnak végrehajtani, azoknál a „Begin – End” veszi át azt az egy utasítást, és amit közéjük írunk azokat egy blokként, csoportba foglalva, természetesen egymás után hajtja végre.

15. Tegye a füléhez

Feltételes utasítások No, mondhatnám, hogy a modulfüzet elején már annyiszor említett strukturált programozás tárgyalásának itt vesszük kezdetét. A következő részek fogják az alapjait képezni a strukturált programozásnak. Vagyis azok a programok, amelyek szekvencia, szelekció és az iterációból épülnek fel, azokat strukturált programoknak hívjuk. Hogy mit is jelentenek ezek a szavak? A szekvencia sorozatot, utasítások egymás után való végrehajtását jelenti. A szelekció kiválasztást, bizonyos programrészeknek valamilyen feltételhez kötődő végrehajtását jelenti és végül az iteráció, ami azt jelenti, hogy vannak olyan programrészek, amiket egy feltételnek megfelelően többször kell végrehajtani, azaz ismétlést jelent. Nézzük a bevezetőben leírt robot vezérlését, akinek a feladata az, hogy menjen a telefonfülkéhez és hívjon fel valakit. Azt, hogy „menj hívd fel a Bandit” nem működik, mert nem fogja megérteni. Akkor mit ért meg a robot? Alapvető mozgásra vonatkozó utasításokat megért, mint pl.: emeld fel a bal lábad, tedd előrébb, hajolj előre 10 fokot, (persze a jobb lábára is hasonló utasításokat fog megérteni), emeld fel a balkezed, emeld fel a jobb kezed, fogj a balkezeddel, fogj a jobb kezeddel, és így tovább. Nos, akkor ilyen alapvető utasításokkal kellene rábeszélni a robotot, hogy menjen és telefonáljon.

66

14. Emelje fel a kagylót 16. Dobjon be pénzt 17. Tárcsázzon 18. Várjon, amíg kicseng 19. Ha nem veszik fel, akkor mit tegyen? 20. Tegye le a kagylót 21. Ismételje meg az egészet a 14. parancstól a 20.-ig 22. Ha felvették, akkor ne ismételje meg, hanem beszéljen. 23. Ha harmadszorra sem vették fel, akkor tegye le a kagylót és távozzon … és még egy csomó utasítás adhatunk neki, de ennyiből is láthatjuk, hogy mennyi mindenre kell gondolni, egy jó program megírásakor. Nézzük csak, hogy milyen strukturális elemeket tartalmaz ez a néhány sor. Tartalmaz egymás után végrehajtandó utasításokat, ez a szekvencia. Tartalmaz ciklikusan végrehajtandó utasításokat, ez az iteráció és tartalmaz feltételesen végrehajtandó utasításokat, ez a szelekció. Itt talán jól érzékelhető a magas szintű utasítás és az alacsony szintű utasítás közötti különbség. Az alacsony szintű (gépközeli) utasítás nagyon aprólékosan megfogalmazott részlet, egyetlen, további részekre már nem bontható utasítása. A példában lehet ez a jobb láb felemelésénél az egyes mozgató mechanikai elemek vezérlése, mint például az egyik izmot helyette67

sítő hidraulikus elem. Ha azt parancsoljuk a robotnak, hogy az A2-es hidraulikáját húzza öszsze 3 centit, akkor ez egy tovább már nem bontható elemi utasítás. Ha azt parancsoljuk neki, hogy emelje fel a jobb lábát, akkor ez egy rengeteg apró, elemi utasításokból álló csoportba foglalt utasítás. Az előbbi az alacsony szintű, az utóbbi a magas szintű utasítás. Láthatjuk, hogy mennyivel egyszerűbb magas szintű programnyelven programozni, mint alacsony szinten. Magas szinten is rengeteg apróságra kell odafigyelni, de alacsony szinten ennél lényegesen jobban kell ismerni a hardvert, és sokkal, de sokkal több utasítást kell megadnunk, ugyanannak a feladatnak az elvégzéséhez. Ilyen egyszerű az egész. Láthatja a kedves Olvasó, hogy nem is akkora ördöngőség. Még egy példát hadd mutassak be Önöknek a jobb megértés kedvéért. E példa bemutatásával már egész érthetővé válik a strukturált programozás szemlélete. A következőkben a Jackson-féle programtervezési módszert is jól be lehet majd mutatni, természetesen csak a legfontosabb részleteit, hogy az ismeretek felhasználásával a programjainkat majd könnyebben tudjuk meg tervezni. Nézzük akkor egy hétköznapi példán bemutatva a Jackson-féle módszert. A példában feltételezem, hogy ön egy férfi, ha nem, akkor kérem, hogy képzelje el a példa erejéig. Képzeljék el, hogy egy bálban van. Ön előtt áll tíz szép hölgy, akik arra várnak, hogy felkérje őket egy táncra. Ha sorban mindegyik hölggyel táncol egyet, akkor ezt szekvenciának hívhatjuk. Ha valamilyen feltételnek megfelelően választ ki egy (vagy néhány) hölgyet, például szőke, hosszú hajú, szemüveges, kékruhás legyen és, ha csak egyetlen hölgy felel meg a feltételeknek, akkor csak vele táncol. Ha egy sem, akkor most nem fog táncolni senkivel sem. Ezt nevezzük szelekciónak, azaz kiválasztásnak. Ha egy hölggyel többször is táncol, akkor azt nevezhetjük iterációnak (ismétlésnek). Az iterációnak is valamikor vége szakad. Ez ebben az esetben, amikor véget ér a zene. Tehát itt is van valamilyen feltétel. Persze később látni fogjuk, hogy annak is fontos szerepe van, hogy az a feltétel mikor következik be, az elején vagy a végén. Ezt a következő oldalakon lesz részletesen bemutatva.

A 2. ábrán jól látható a szekvencia Jackson-féle jelöléssel. A jelölés lényege a következő. Van maga a program, ami kisebb részekre (modulokra) van lebontva. Ezek a részek az ábrán az „1. utasítás” „2. utasítás” és a „3. utasítás”-sal vannak reprezentálva. Ezeknek a végrehajtása balról jobbra történik úgy, hogy mindegyik utasítás (kivétel nélkül) végre lesz hajtva egymás után. Ezek felelnek meg az előző fejezetekben bemutatott mintaprogramoknak, ahol a program minden sora egymás után végre lett hajtva. Nézzük meg ugyanezt a szekvenciát folyamatábrával. A folyamatábránál elindulunk a legfelső „Start”-nál és a nyilak mentén végighaladunk egészen a „Stop”-ig. Start

1. utasítás

A folyamatábrán is jól látszik, hogy a 3 képzeletbeli utasítása program indulását követően, egymás után végrehajtódik. Tehát a szekvencia jól szemléltethető a folyamatábrával is. Nézzünk erre egy Pascal szerű példát: Program szekvencia_minta;

{Program fej}

Uses

{Unitok deklarálása}

2. utasítás

Crt;

3. utasítás

Stop 8. ábra - Szekvencia folyamatábrával

{Program kezdés}

1. utasítás;

{1.út. végrehajtása}

2. utasítás;


3. utasítás;


End.

{Program vége}

Gondolom, hogy a szekvencia megértésével nem nagyon lehet gondja a kedves Olvasónak.

A szelekció Először Jackson-féle ábrázolással nézzük meg a szelekciót.

Akkor hát, kedves Olvasó máris megismerkedett a strukturált programozás rejtelmeivel és bátran kijelenthetjük, hogy azok a programok, melyek e három építőelem tulajdonságait magukon hordozzák, strukturált programoknak hívjuk.

Program

Feltétel lista:

A szekvencia

F1

1. utasítás

Program

{Képernyő unit}

Begin

F2

2. utasítás

F3

3. utasítás

9. ábra - Szelekció Jackson féle jelöléssel

1. utasítás

2. utasítás

3. utasítás

7. ábra – Szekvencia Jackson-féle jelöléssel

F1 : 1. feltétel leírtása F2 : 2. feltétel leírtása F3 : 3. feltétel leírtása

Ez az ábra szinte ugyanolyan, mint az előző, azzal a különbséggel, hogy a dobozkák jobb felső sarkainál apró köröcskék jelentek meg. Ez jelzi, hogy szelekcióról van szó. Ez azt jelenti, hogy nem mindegyik utasítás hajtódik végre, hanem csak azok, amelyek megfelelnek valamilyen feltételnek. A feltételeket a köröcskék fölötti F1, F2, F3 feltételekkel kel jelölni és a

A Jackson-féle programtervezési módszer dobozokkal szemlélteti a különböző utasításokat.

68

69

lap szélén valahol egy feltétel listában részletezni kell, hogy melyik F(szám) milyen feltételt jelent.

Egy picit összetettebb a következő if szerkezet megvalósítása. Ennek lényege az, hogy ha a feltétel nem teljesül (HAMIS), akkor egy másik utasítást kell végrehajtani (ez a különben ág).

Most egy kicsit bonyolultabb a helyzet, mint a szelekciónál, mert meg kell különböztetnünk többféle programelágazást. Azaz a fenti ábrából az is jól látszik, hogy nem minden programutasítás hajtódik végre, csak azok, amelyek valamilyen feltételnek eleget tesznek. Ezeket a feltételeket természetesen logikai típusúnak kell megválasztani, hogy jól eldönthető legyen az, hogy IGAZ vagy a HAMIS.

Ismét tegye a ceruzáját a startra. Most haladjunk a nyíl irányába, és képzeletben értékeljük ki a logikai feltételt. Most legyen IGAZ, akkor jobbra haladjunk tovább. Az 1. utasítás kerül végrehajtásra. Majd a programrészlet vége következik a stoppal.

Nézzük akkor a szelekció műveletének a Pascalban történő megvalósítását és ugyanakkor a folyamatábrával való szemléltetését. Nem feltétlen szükséges ismerni az összes folyamatábra elemet. Amelyek a megértéshez kellenek, azok ismertetésre kerülnek majd a mellékelt magyarázatnál. If utasítás Az if utasítás magyarra fordítva ha-nak felelne meg, azaz akkor hajtódik végre egy programrészlet, ha valamilyen feltétel teljesül. Nézzük a mellékelt feltételes elágazás magyarázatát: Tegyük a ceruzánkat a startra. Induljunk el vele lefelé a logikai feltétel felé. A programunk eddig a részig végrehajt néhány utasítást, amit itt a mellékelt ábrán nincs feltüntetve. Azaz a programunk utasítás végrehajtása elérkezik a logikai feltétel

Kezdjük el ismét a folyamatot. Ismét tegyük a ceruzánkat a startra. haladjunk a nyíl irányába és most ismét értékeljük ki képzeletben a logikai feltételt. Most legyen az értéke HAMIS. Ebben az esetben a 2. utasítás lesz végrehajtva.

Látható, hogy a feltétel akár IGAZ vagy akár HAMIS, a programunk akkor is végrehajt valamilyen utasítást. Akkor most nézzük meg, hogy hogyan kell ezt a Turbo Pascalban megadni. … Begin … If feltétel Then

…

1. utasítás

Begin

Else

…

2. utasítás ; If feltétel Then Utasítás;

… End.

kiértékeléséhez. Eldönti, hogy az igaz-e vagy hamis-e és ennek megfelelő irányba folytatja út10. ábra - Feltételes elágazás ját. Ha igaz a feltétel, akkor az utasítás végrehajtódik, ha nem, akkor nem. Akkor az utasítás végrehajtása nélkül folytatja útját a program vagy véget ér az utasítások sora. Nézzük meg ugyanezt a programrészletben is. A Begin után áll „…” jelzi, hogy oda valamilyen utasításokat kell képzelni. Ezután következik az If szerkezet melyben egy feltétel áll. Magyarra fordítva ez azt jelenti, hogy ha a feltétel igaz, akkor hajtsd végre az utasítást. Majd ismét „…” következik, jelezve ezzel, hogy még következnek utasítások a programban. Majd a program végét jelentő End zárja a programot.

70

11. ábra - Feltételes elágazás különben ággal

{ Ha feltétel Akkor} {

az 1. utasítás hajtódjon végre }

{ Különben} {

az 2. utasítás hajtódjon végre }

… End.

Lássunk egy konkrét programrészletet példát: … Begin … If a > b Then WriteLn(’Az A nagyobb mint a B.’) Else

{ Ha a > b Akkor} {

1. szöveg kiírása }

{ Különben}

WriteLn(’A B nagyobb mint az A.’); {

2. szöveg kiírása }

… End.

Figyeljük meg, hogy a pontosvessző az Else-t követő utasítás végén áll. Azért van ez így, mert az If programszerkezet ott ér véget és nem az If és Else között.

71

A most következő többszörös elágazás megvalósítható az If Then Else utasítások egymásba ágyazásával is, valamint a Case Of szerkezettel is. A többszörös elágazást egy példa bemutatásával kezdjük. Írjunk egy olyan programot, ami a napszaknak megfelelően köszön. Kérdezze meg, hogy hány óra van és ennek megfelelően döntse el, hogy jó reggelt, vagy jó napot, jó estét vagy jó éjt köszönjön vagy csodálkozzon, hogy még fenn van az aki a programot futtatja. Gondolom, érzik, hogy itt azért több feltételt kell majd kiértékelni. Tegye a ceruzáját a startra és kövesse a nyilat. Először az első feltételes elágazáshoz érünk. Ott kiértékelődik az első feltétel. Ha ez igaz, akkor az 1. utasítás hajtódik végre. Ha ez nem igaz, akkor további feltételvizsgálat következik a 2. feltétel. Ha ez igaz, 12. ábra - Többszörös szelekció művelete különben akkor a 2. utasítás lesz végrehajtva. Ha ággal ez a feltétel sem igaz, akkor a 3. feltételvizsgálat következik. Ha ez igaz, akkor a 3. utasítás lesz végrehajtva, ha ez a feltétel sem igaz, akkor az egyszerű if – then – else ághoz hasonlóan a különben ág hajtódik végre, azaz a 4. utasítás, majd a program véget érs vagy folytatódik tovább.

Ha nem nagyobb, mint 24, akkor meg kell vizsgálni, hogy mely intervallumba esik a megadott szám. Vizsgáljuk meg, hogy nagyobb-e vagy egyenlő mint 22, mert akkor jó éjt kell köszönni. Azaz ide tartozik a 22,23,24 óra. Ha nem nagyobb vagy egyenlő, mint 22, akkor csak kisebb lehet. Jó, de mennyi akkor? Ismét vizsgálat következik és meg kell vizsgálni, hogy nagyobb-e vagy egyenlő, mint 18. Ha igen, akkor jó estét kell köszönni. Ha nem nagyobb vagy egyenlő, akkor csak kisebb lehet, tehát ismét egy vizsgálatnak kell következnie. Most meg kell vizsgálni, hogy nagyobb-e vagy egyenlő, mint 10, ha igen, akkor most jó napot kell köszönni. Ha nem nagyobb, akkor csakis kisebb lehet, tehát ismét meg kell vizsgálni, hogy mekkora a megadott óra számértéke. Most már csak egyetlen vizsgálat van hátra, hogy nagyobb-e vagy egyenlő, mint 6. ha igen, akkor jó reggelt-et kell köszönni, ha nem, akkor egy csodálkozó üzenetet kell kiírni a képernyőre, „Te még/már fent vagy?”. Ha ezeket a vizsgálatokat a Pascal segítségével szeretnénk leprogramozni, akkor egy egymásba ágyazott if-then-else megoldással megoldható e feladat. Lássunk hát egy lehetséges megoldást: Program koszon;

{Program fej}

Uses

{Képernyő kezeléséhez}

Crt;

csodálkozzon, hogy még fent vagyunk?

· 7..10–ig

jó reggelt köszönjön

Ora : Byte;

{Képernyőtörlés}

Write(’Hány óra van? ’); {Szöveg kiírása a képernyőre} ReadLn(Ora)

{Ora bekérése képernyőről}

If Ora > 24 Then

{ha óra > 24, akkor hibaüzenet kiírása}

WriteLn(’Csak 0 és 24 közötti számot adhatsz meg!’) Else If Ora>=22 Then

{Ha óra>=22, akkor jó éjt}

WriteLn(’jó éjt’) Else If Ora >=18 Then

{Ha óra>=18, akkor jó éjt}

WriteLn(’Jó estét’) Else If Ora>=10 Then

{Ha óra>=10, akkor jó napot}

WriteLn(’Jó napot’) Else If Ora>=6 Then

· 19..21–ig jó estét köszönjön

{Ha óra>=6, akkor jó regelt}

WriteLn(’Jó reggelt’)

· 22-24–ig jó éjt köszönjön

72

{Ora változó deklarálása}

ClrScr;

· 11..18–ig jó napot köszönjön

Hogyan is kell egy ilyen intervallumos példát megoldani? Remélem, hogy Excelnél már találkoztak hasonló problémával. Először meg kell vizsgálni, hogy jó-e a megadott óra értéke. Ezt igazából a barkóba játékhoz hasonlóan szoktam elmesélni. Először kérdezzük meg, hogy az óra nagyobb-e mint 24, mert akkor a megadott idő hibás és adjunk hibaüzenetet, melyben tájékoztatjuk a kedves felhasználót, hogy milyen időintervallumban (0..24) lehet csak órát megadni. Ha nem nagyobb mint 24, akkor valószínű, hogy jó számot adott meg a felhasználó.

a Crt unit deklarálása}

{}

Begin

Állítsuk fel a feltételrendszert, ami alapján majd köszön a program. · 0..6–ig

{

Var

Else

{különben rácsodálkozás}

WriteLn(’Te még/már fent vagy?’); ReadLn; End.

Egy picit zsúfolt, ugye? Mindenkiben felmerül az igény egy jobban áttekinthetőbb program elkészítésére. Erre ad megoldást a Case Of szerkezet.

73

Az „If logikai_feltétel Then utasítás;” esetén bajban vagyunk, mert csak egyetlen utasítás állhat a Then után. Mi hát a megoldás arra az esetre, ha több utasítást szeretnénk végrehajtatni? Ebben az esetben Begin – End blokkba kell foglalni az utasításokat. If logikai_feltétel Then Begin

{Logikai vizsgálat} {Blokk kezdete}

1. utasítás;

{1.ut. végrehajtása,}

2. utasítás;

{2.ut. végrehajtása, ha … -”-!}

3. utasítás;

{3.ut. végrehajtása, ha … -”-!}

{ha igaz a logikai feltétel!}

End;

{Blokk vége}

Program koszon2;

Crt;

Ora : Byte; Begin

cimke1 : 1. utasítás;


WriteLn(Mennyi az idő? );

{Szöveg kiírása a képernyőre}

ReadLn(Ora);

{Óra bekérése billentyűzetről}

Case Ora Of

{Case fejrésze a szelektorral}

{

1. utasítás hajtódik végre}


{Ha a szelektor = cimke2-vel, akkor…}


{ -”-}

cimke4 : 4. utasítás; Else n. utasítás End;

: WriteLn(’Te még/már fent vagy?’);

6..10

: WriteLn(’Jó reggelt’);

11..18

: WriteLn(’Jó napot’);

19..21

: WriteLn(’Jóestét’);

22..24

: WriteLn(’Jó éjt’);

{ -”-}

{Különben ág}

WriteLn(’Hibás adat! Az óra csak 0 és 24 között lehet!’); End;

{Case utasítás vége}

ReadLn;

{Várakozás az Enter leütésére}

End.

{Program vége}

Ebben a példában a konstansok résztartomány típusúak. Így egyszerűbb és szebb a köszönő program megírása.

{A Case különben ága}

Iteráció

{Ha egyik feltétel sem igaz, akkor ez…}

A programozásban, mint azt a robotos példánál is láthatták, gyakran van szükség utasítások többszöri végrehajtására. Ezek az ún. ciklus utasítások. A Pascalban három ilyen utasítás áll rendelkezésre. Ha ismerjük a ciklusok számát, akkor a For, ha nem, akkor valamilyen feltétel bekövetkezése Program szabja meg a ciklusok számát, akkor a While és a Repeat Until szerkezet ad megoldást. Az iteráció a Feltétel lista: Jackson-féle jelölésben egy a doboz jobb felső sarkáF1 F1 : feltétel ba rajzolt csillaggal van jelölve. Megkülönböztetünk * Ciklusmag elöl tesztelő és hátul tesztelő ciklusokat. Amennyiben hátul tesztelőről van szó, akkor a csillag a jobb 13. ábra - Iteráció Jackson-féle alsó sarokba kerül. Ugyanúgy mint a szelekciónál, itt jelöléssel is meg kell adni a feltételt ameddig a ciklus tart, vagy amikor befejezhető (hátul tesztelő esetén).

{Case-t záró End;}

A Case szelektor Of –ban a szelektor csak sorszámozott típusú lehet. A case konstansok típusának meg kell egyeznie a szelektor típusával. Azok az utasítások kerülnek végrehajtásra, melyek cimkéje megegyezik a szelektor értékével, ha nincs ilyen érték, akkor az Else utáni utasítás lesz végrehajtva, feltéve, hogy van Else ága a Case-Of szerkezetnek. Akkor oldjuk meg a fenti köszönős példát a Case Of szerkezet segítségével. Láthatjuk, hogy mennyivel tisztább képet kapunk ennek a szerkezetnek az alkalmazásával.

74

0..5

Else {Case fej} {Ha a szelektor = cimke1-gyel, akkor}

{Ora változó deklarálása} {Főprogram kezdete}

ClrScr;

A Case utasítással könnyedén megoldhatjuk programunk többirányú elágaztatását. A Case utasítás után egy selektor áll aztán az Of kulcsszó zárja. Ezt követik a case konstansok és a hozzájuk tartozó utasítások és a végén (persze nem kötelezően) az Else (különben) ág, majd az End;. Case szelektor Of

{Képernyőkezelő unit deklarálása}

Var

Case Of utasítás

A szintaktikája a következő:

{Köszön 2 program}

Uses

75

Írjunk ki N darab ’X’-et a képernyőre

For utasítás A for utasítást akkor használhatjuk, ha ismerjük az ismétlések számát. Ekkor a ciklusmag meghatározott számszor hajtódik végre. Lehetőség van növekményes ciklus használatára, és lehetőség van csökkenős ciklus használatára. Az első esetben egy kisebb számtól számoltatunk el egy magasabb felé és fordítva (a csökkenőnél) egy nagyobb számtól számoltatunk vissza a kisebb felé. Az utasítás szintaktikája: For ciklusváltozó := kezdőérték To / DownTo végérték Do utasítás;

Ahol a ciklusváltozó sorszámozott11 típusú változó hivatkozás, a kezdőérték és a végérték pedig sorszámozott típusú kifejezések. A ciklusváltozó a kezdőértéktől a végértékig egyesével nő (To) vagy csökken (DownTo). Az utasítás (vagy a Begin - End utasítás zárójelek közé zárt utasításcsoport) a ciklusváltozó minden értékénél végrehajtódik. Elöltesztelő ciklus, így ha a kezdőérték > végérték (To esetén) vagy a kezdőérték < végérték (DownTo esetén), akkor a ciklusmag egyszer sem kerül végrehajtásra (üres ciklus). Vessünk egy pillantást a jobboldali folyamatábrára. Tegyük a ceruzánkat a fenti nyílra és induljunk el az irányába. Először a kezdőérték beállítása történik ciklusváltozó:=kezdőérték utasítással. Ha a ciklusváltozó <= végérték, akkor a ciklusmag végrehajtódik és a ciklusváltozó értéke eggyel meg lesz növelve. majd a feltétel kiértékelése történik meg ismételten, ha a ciklusváltozó még mindig kisebb vagy egyenlő, mint a végérték, akkor a ciklus ismét lefut. Ha már meghaladja a ciklusváltozó a végértéket, akkor a feltétel hamissá válik és a ciklus véget ér. Vajon melyik ciklus a For ciklus? Ha jól megnézzük az ábrát, akkor ebből kiderül. A ciklusmag egyszer sem hajtódik végre, ha a ciklusfeltétel hamis. Ha igaz, akkor végrehajtódik. Tehát ezt a növekményes ciklust un. elöl tesztelő ciklusnak hívhatjuk. Abban az esetben, ha nem csak egyetlen utasítást szeretnénk végrehajtani a ciklusmagban, akkor csoportba foglalhatunk akár 14. ábra - For ciklus több utasítást is egy Begin – End párossal. A Begin – End párost folyamatábrája úgy is tekinthetjük, mint egy zárójelet. A Begin a „(” és az End a „)” jelnek feleltethető meg.

11

Program Csillag;

{Program fej}

Uses

{Unitok, modulok}

Crt; Var

{

Képernyőkezelő unit}

{Változók deklarálása}

i, n: byte; Begin

{Ciklusváltozó és az ’ig’ változó deklarálása} {Főprogram kezdete}

ClrScr;


ReadLn(n);

{Hány karaktert kell majd kiírni?}

For i := 1 To n Do

{Ciklus fej}

Write('X'); ReadLn; End.

{Ciklusmag, a karakter kiírása} {Várakozás egy Enter-re} {Program vége}

A ciklusváltozó értékét a ciklusmagban felhasználhatjuk, de nem változtathatjuk meg. Program Csillag;

{Program fej}

Uses

{Unitok, modulok}

Crt; Var

{

Képernyőkezelő unit}


i: byte; Begin ClrScr; For i := 1 To 5 Do WriteLn(i); ReadLn;

{

A ciklusváltozó deklarálása}

{Főprogram kezdete} {Képernyőtörlés} {Ciklus fej} {Ciklusmag, a ciklusváltozó kiírása} {Várakozás egy Enter-re}

End.

While..Do utasítás A While utasítás tartalmaz egy logikai kifejezést, amely vezérli az ismételt utasítások végrehajtását. A While utasítás szintaktikája: While logikai_kifejezés Do Ciklusmag utasítás;

Kezdőfeltételes ciklus. Amíg a feltétel igaz, addig ismétli az utasítást, ha hamis, akkor a program következő utasítására ugrik. A feltétel egy logikai (boolean) kifejezés. Ha több utasítás szerepel a ciklus magjában, akkor Begin - End un. utasítás zárójelet kell alkalmaznunk. Ha a feltétel már először sem teljesül, akkor a ciklusmag egyszer sem kerül végrehajtásra (üres ciklus), ha pedig a feltétel soha nem vesz fel hamis értéket, akkor a program végtelen ciklusba kerül.

Sorszámozott típusok: egészek, logikai, karakter, felsorolt, intervallum

76

77

Ismét tegye a ceruzáját a felső, bevezető nyílra és induljon el a nyíl irányába. Először a ciklusfeltétellel találkozunk. Amennyiben a ciklusfeltétel igaz, akkor a ciklusmag végrehajtódik és a végrehajtás után azonnal a ciklusfeltétel elejére kerülünk. Most ismét a ciklusfeltétel kiértékelése a következő lépés. Ha ez most hamis, akkor a ciklus véget ér és a következő utasításnál folytatódik a program. Tipikus használata: a ciklus végrehajtása attól függ, hogy van-e még feldolgozandó adat, az ismétlések számát előre nem ismerjük, akár 0 is lehet. Példa: Képezzük a billentyűzetről érkező pozitív számok összegét, a számsorozat végét a 0 vagy egy negatív szám jelezze. Megoldás Az ilyen típusú feladatok általános megoldási sémája: 15. ábra - A While ciklus folyamatábrája

§ § § § §

az első adat előállítása (pl. beolvasása) ciklusfej az adat feldolgozása a következő adat előállítása (pl. beolvasása) ciklus vége

A példa így fest Pascalban: Program Osszeg_szamitas; Uses Crt;

{

Var

Az utasítás szintaktikája: Repeat Ciklusmag Until ciklus_feltétel;

Végfeltételes ciklus. Az utasítás(ok) végrehajtását meg kell ismételni, ha a feltétel hamis. Ha a feltétel igaz, a program a ciklus utáni utasítással folytatódik. A ciklusmag legalább egyszer végrehajtódik. A ciklusmagot a Repeat - Until kulcsszavak fogják közre, nem kell Begin End utasítás zárójelet használnunk. A folyamatábra értelmezése hasonló az előzőekhez. Jól látható, hogy a ciklusmag legalább egyszer végrehajtódik, és ha a ciklus-feltétel igazzá válik, csak akkor ér véget a ciklus. Ha a ciklusfeltétel hamis, akkor a ciklusmag ismételten végrehajtásra kerül.

16. ábra - A hátultesztelő ciklus

A While és a Repeat ciklust hasonló típusú feladatok megoldására használhatjuk. Esetleg az egyik egy kicsit kényelmesebb megoldást nyújt, persze ez feladatfüggő. Program Osszeg_szamitas2;

{Program: 2. összeg számítás}

Uses

{}

Crt; Var

{} {}

adat, osszeg: integer; Begin

{} {Főprogram kezdete}

{ két egész típusú változó} {Főprogram kezdete}

ClrScr;


osszeg := 0;

{Változó inicializálása}

ClrScr;


ReadLn(adat);

{Adat bekérése}

osszeg := 0; ReadLn(adat);

{Változó inicializálása12} {Adat bekérése}

Repeat

{Ciklus fej}

While adat > 0 Do

{ha nagyobb mint 0, akkor a ciklusmag}

Begin

{Ciklusmag blokk kezdete}

osszeg := osszeg + adat;

{

összeg inkrementálása az adattal}

ReadLn(adat);

{

Adat ismételt bekérése}

end; WriteLn('Az összeg: ',osszeg); ReadLn; end.

Kezdeti értékének megadása

78

képernyőkezelő unit}


adat, osszeg : integer; Begin

12

{Program: Összeg számítása} {Beépülő modulok}

Repeat..Until utasítás pár

{Ciklusmag blokk vége} {Az összeg kiírása} {Enter-re vártakozás} {Program vége}

osszeg := osszeg + adat;

{

ReadLn(adat);

{Adat ismételt berkérése}

Until adat <= 0;

változó inkrementálása (növelése)}

{ha a ciklusváltozó igaz -> kilépés}

WriteLn('Az összeg: ',osszeg);

{összeg kiiratása}

ReadLn;

{Enter-re várakozás}

End.

{Program vége}

Aki kíváncsi a program lépésenkénti végrehajtására az nyomja meg az F8-as billentyűt. Ekkor a program lépésenkénti végrehajtással futtatja le a programot. Minden F8 további megnyomásával, egy utasítással továbblép. Ebben a módban jól nyomon követhetőek a ciklusok, az elágazások. Ha a későbbiekben saját alprogramokat írunk, akkor az F7-es billentyűvel lehet az alprogramokba is belépni a nyomkövetés közben.

79

Lehetőség van töréspontok elhelyezésére is a Ctrl+F8-cal. Ez azt jelenti, hogy a program addig a pontig lefut, majd megáll és várja a programozó utasítását, azaz a további nyomkövetési lépéseket az F7 vagy az F8-as billentyűvel. A töréspont eltávolítása ugyanavval a billentyűvel lehetséges, mint amivel beszúrtuk. A töréspontokat piros csíkkal jelöli a Turbo Pascal, a nyomkövetést világoskékkel.

Itt a változó nevét minden egyes alkalommal le kell írni a programozónak. Mennyivel egyszerűbb lenne, ha ezt nem kellene többször, csak egyszer. Nézzük, akkor az előző mintát a With használatával With Dolgozo Do Begin

With utasítás A with utasításhoz ismertetni kell a rekordot, mint strukturált adattípust. A rekord - Record típus

A rekord strukturált adattípus, amelyben különböző típusú adatokat (mezőket) fogunk öszsze. Deklarálásakor a Record és End kulcsszavak között fel kell sorolnunk az egyes mezők neveit valamint típusait. Például így fest egy egyszerűbb dolgozó rekord deklarálása: ...

{... Előző program sorok}

Type

{Saját típus definiálása}

DolgozoTip = Record

{A DolgozoTip típus bevezetése}

DolgozoKod : Word;

{A mezők és a típusok}

Neve

: String;

{

Telepules

: String;

{}

UtcaHsz

: String;

{}

Fizetes

: Word;

{}

Hazas

: Boolean;

{}

End; Var

felsorolása}

Dolgozo : DolgozoTip;

{Adatbeolvasás a rekord egy-egy}

ReadLn(Neve);

{

ReadLn(Telepules);

{}

End;

mezőjébe}

{With - blokk vége}

Mennyivel egyszerűbb így a mezőnevekre hivatkozni. Egyszer kell leírni a rekord típusú változót és azután már csak a mezőire kell hivatkozni bevezetőrész nélkül. Más szerepe nincs a With-nek.

1. FELADAT Kösse össze a kulcsszavakat a hozzájuk tartozó fogalommal.

Repeat Elöltesztelő ciklus

If

{Változók}

...

{Blokk kezdete}

ReadLn(DolgozoKod);

For

{Rekord vége}

{With feje}

{Dolgozo változó deklarálása} {... További program sorok}

Hivatkozás a rekord egy mezőjére:

To While

Hátultesztelő ciklus

rekordazonosító.mezőazonosító

DownTo

Pl. Dolgozo.Hazas

{Hivatkozás a rekord egy mezőjére}

Azaz a „Dolgozo” változó, ami „DolgozoTip” típusú, annak van egy „Hazas” nevű mezője. Erre a mezőre a példában látható módon lehet hivatkozni.

Until Case

Lássuk hát akkor a With utasítást Ha egy programrészletben gyakran hivatkozunk egy (vagy több) rekord mezőire, akkor a With utasítással ez leegyszerűsíthető, a rekordazonosító elhagyható.

Feltételes elágazás

Of

Például a With nélkül így nézne ki egy programrészlet: ReadLn(Dolgozo.DolgozoKod);

{Adatbeolvasás a rekord egy}

ReadLn(Dolgozo.Neve);

{

Repeat

mezőjébe}

ReadLn(Dolgozo.Telepules);

80

81

Önellenőrzés

?

Válaszok

1. Írjon példát az aritmetikai értékadó utasításra.

1. Írjon példát az aritmetikai értékadó utasításra.

...........................................................................................................................................................

X := a + b * 2;

2. Írjon példát a logikai értékadó utasításra.

2. Írjon példát a logikai értékadó utasításra.

...........................................................................................................................................................

Y := a < b;

3. Mire használható a blokk utasítás?

3. Mire használható a blokk utasítás? Csoportba fogja az utasításokat olyan esetekben, amikor például egy feltételes elágazásnál csak egyetlen utasítást lehet megadni azelágazás utasításrészében. Ilyenkor a Begin – End páros a feltételes elágazás egyetlen utasítása, ami zárójelként viselkedik a közé írt utasításokra nézve.

........................................................................................................................................................... 4. Mi a szekvencia? ...........................................................................................................................................................

4. Mi a szekvencia? Utasítások egymásutáni végrehajtása, sorozat.

5. Mi a szelekció? ...........................................................................................................................................................

5. Mi a szelekció? Bizonyos utasításoknak valamilyen feltétel szerinti végrehajtása. Feltételes elágazást jelent.

6. Mi az iteráció?

6. Mi az iteráció? Bizonyosutasítások valamilyen feltétel szerinti ismételt végrehajtását jelenti. Ciklus.

........................................................................................................................................................... 7. Mi az iteráció?

7. Milyen ciklus a for ciklus? Elöltesztelő, növekményes ciklus, ahol a ciklusok száma előre ismert.

...........................................................................................................................................................

8. Mire használható az „else” utasítás? A feltételes elágazásoknál a különben ágat vezeti be.

8. Mire használható az „else” utasítás?

9. Szükséges-e blokk utasítás, ha a ciklusmagban több utasítás szeretnénk írni a …

...........................................................................................................................................................

… a for ciklusnál? Igen

9. Szükséges-e blokk utasítás, ha a ciklusmagban több utasítást szeretnénk írni a … … a for ciklusnál? ................................................................................................................

… a while ciklusnál? Igen … a repeat – until ciklusnál? Nem, mert az utasítás pár, maga a blokk utasítás is egyben

… a while ciklusnál? ............................................................................................................. … a repeat – until ciklusnál? ..............................................................................................

82

83

Az eredmény kivezet az egész számok köréből Az eredmény mindig valós pl. a 6/2-t már nem egész számként kezeli a rendszer.

2. A Pascal nyelv adattípusai

<, >, <=, >=, =, <> relációs műveletek, az eredmény logikai típusú.

Egyszerű adattípusok

in halmaz elemvizsgálat, logikai eredmény (ld. halmaz adattípus).

Egész típusok

Fontosabb szabványos eljárások, függvények

Egy típus jellemzésénél az alábbiakat kell figyelembe venni: ·

felvehető értékek halmaza (adatábrázolás)

·

konstansai

·

végezhető műveletek

·

szabványos eljárások, függvények Értéktartomány

Byte

Tárolás

0..255

1 byte

-128..127

1 byte

0..65535

2 byte

Integer

-32768..32767

2 byte

LongInt

-2*109..2*109

4 byte

ShortInt Word

Függvények: Abs, Sqr, Trunc, Round, Ord, Pred, Succ, Random

·

Eljárások:

Inc, Dec, Str, Val, Randomize

Megjegyzés

A Pascal nyelvben bőséges választék áll a rendelkezésünkre egész típusokból Típus

·

A Byte és a Word típus esetén 8 illetve 16 biten 28 = 256 (00000000-tól 11111111-ig) illetve 2 16 = 65536 különböző számot ábrázolhatunk kettes számrendszerben. A ShortInt, az Integer és a LongInt típusokban negatív számokat is tárolhatunk. Itt az ábrázolási tartomány egyik fele kettes komplemens kódolással negatív számokat jelent.

A függvények mindig egy értéket állítanak elő (visszatérési érték), kifejezésekben hívhatjuk meg őket, pl. egy értékadó utasítás jobb oldalán; a := Abs(a) + 2 . A függvények paraméteri kifejezések lehetnek, pl. Sqr(a + Round(x)). Az eljárásokat utasításszerűen hívjuk, pl. Inc(i). Valós típusok Értéktartomány, számábrázolás A Turbo Pascalban a következő valós típusokat definiálták: Real (6 byte), Single (4 byte), Double (8 byte), Extended (10 byte), Comp (8 byte), azonban a Real típus kivételével mindegyik használatához matematikai társprocesszorra, vagy annak emulálására van szükség. A Real típus ábrázolása 6 bájton, lebegőpontosan történik. Az értéktartomány: ·

Smin = 2,9*10-39

·

Smax = 1,7*1038

A pontosság 11-12 decimális számjegy. (Ennyi az értékes számjegye egy valós számnak, a többi jegyet nem ábrázolja a rendszer, pl. a 1234567890,1234567 számból a dőlt számjegyek elvesznek.)

Egész típusú konstans Decimális egészek, pl.: 21, -234 Hexadecimális egészek, pl.: $31, -$A9D2

Konstansok Pl. 5.12, -123.2313, 12.54E6, 21.12E-5

Végezhető műveletek Az eredmény is egész típusú:

+,- (előjel), *, +, -

Műveletek

div egész osztás, pl.:

13 div 3 = 4

Az eredmény is valós típusú: +,- (előjel), *, /, +, -

mod maradékképzés, pl.:

13 mod 3 = 1

Az eredmény logikai típusú: <, >, <=, >=, =, <>

not bitenkénti negálás, pl.:

not 28 = -29 ; (not 00011100 = 11100011)

and bitenkénti és, pl.:

5 and 6 = 4;

(00000101 and 00000110 = 00000100)

or bitenkénti vagy, pl.:

5 or 6 = 7;

(00000101 or 00000110 = 00000111)

xor bitenkénti kizáró vagy, pl.:

5 xor 6 = 3;

(00000101 and 00000110 = 00000011)

shl bitenkénti eltolás balra, pl..

5 shl 3= 40;

(00000101 shl 3 = 00101000)

shr bitenkénti eltolás jobbra, pl.: 5 shr 2= 1; 84

Fontosabb szabványos eljárások, függvények ·

Függvények:

Abs, Sqr, Sqrt, Sin, Cos, ArcTan, Exp, Ln, Int, Frac, Random, Round, Trunc, Pi

·

Eljárások:

Str, Val, Randomize

(00000101 shr 2= 00000001)

85

A karakteres típus - Char Értéktartomány, adatábrázolás Egy bájtos típus, tehát 28 = 256 különböző érték , az ASCII kódrendszer 256 elemének a tárolására képes. A karakter típusú változó egy ASCII kódot tartalmaz. Pl. ha a változóhoz tartozó memóriarekesz értéke 65, akkor mivel változónk típusa Char, ezt a rendszer 'A' betűként értelmezi.

Logikai értéket előállító függvények Odd, Eof, Eoln Felsorolt típus Értékek, adatábrázolás A típus megadásakor fel kell sorolni a lehetséges értékeit. Ezek csak azonosítók lehetnek. A konstansok a felsorolás sorrendjében sorszámot kapnak 0-tól kezdődően. Tárolás a konstansok számától függően 1 vagy 2 bájton történik.

Konstansok Formája: 'A', '*', '4', #65 (ez utóbbi a 65-ös ASCII kodú karaktert, azaz 'A'-t jelenti). Lehetnek: betűk, számjegyek, írásjelek, speciális karakterek (pl. '@', '#', '$', ...), vezérlő karakterek (pl. a gyakran használt #27 - ESCape), egyéb karakterek (az ASCII kódtábla 128-255 része, pl. 130 -> 'é').

Pl.: Var Tantargy : (magyar, matek, fizika, tesi); ...

Műveletek

tantargy := matek;

Relációs műveletek: <, >, <=, >=, =, <> (az eredmény természetesen logikai típusú, a karakter ASCII kódja határozza meg. Pl. 'A' < 'B' igaz, 'A' = 'a' hamis.)

Konstansok

in halmaz elemvizsgálat, logikai eredmény (ld. halmaz adattípus)

Műveletek

Fontosabb szabványos eljárások, függvények ·

Függvények: Ord, Chr, UpCase, Pred, Succ

·

Eljárások:

Inc, Dec

A logikai típus - Boolean Értéktartomány, adatábrázolás

Konstansai a felsorolásban szereplő azonosítók.

Relációs műveletek: <, >, <=, >=, =, <> (az eredmény természetesen logikai típusú, a felsorolt típusú érték sorszáma határozza meg. Példánkban a matek < tesi természetesen IGAZ.) in halmaz elemvizsgálat, logikai eredmény (ld. halmaz adattípus) Függvények, eljárások A sorszámozás alapján értelmezhetőek az alábbi

Egy logikai típusú változó két értéket vehet fel: IGAZ vagy HAMIS. Ábrázolására egy bájton történik (akár egy bit is elég lenne). Ha a bájt értéke 0, akkor a logikai típusúként értelmezett érték HAMIS, nullától eltérő érték esetén pedig IGAZ.

·

Függvények:

Ord, Pred, Succ;

·

Eeljárások:

Inc, Dec;

Intervallum típus Konstansok Két előredefiniált konstans: TRUE ( IGAZ), FALSE (HAMIS ) Műveletek Az eddig tanult típusokra értelmezett relációs operátorok (valamint az in halmazművelet) mindig logikai értéket állítanak elő. Logikai műveletek: NOT, AND, OR, XOR (az operandusok logikai típusúak). A műveletek igazságtábláit lásd az aritmetikai résznél a modulfüzet elején. Pl. egy logikai kifejezés: (x > 4) AND (x < 10) OR NOT b , ahol b egy Boolean változó.

86

Egy már létező sorszámozott típus egy intervalluma. Szintén nekünk kell definiálnunk. Az adatábrázolás, műveletek, függvények, eljárások megegyeznek az eredeti típuséval. Pl. Var

{felsorolt típus} nap : (hetfo, kedd, szerda, csutortok, pentek, szombat, vasarnap); munkanap: hetfo..pentek;

{intervallum típusok}

betu: 'A'..'Z'; szamjegy: '0'..'9';

87

Az egyszerű típusok csoportosítása ·

Sorszámozott típusok

·

Egészek

·

Logikai

·

Karakter

·

Felsorolt

·

Intervallum

·

Valós típusok

Sorszámozott típusok: minden lehetséges értékhez hozzárendelhető egy sorszám, az értékek a sorszám szerint rendezettek. Karakterlánc típus valamint a strukturált (összetett) típusok A karakterlánc - String típus

Adatábrázolás A rendszer a karakterek ASCII kódját tárolja maxhossz+1 bájton. A karakterlánc 0. bájtja tartalmazza a karakterlánc hosszát, Ord(karlanc[0]) = Length(karlanc). Szabványos függvények, eljárások ·

Függvények:

Length, Pos, Copy, Concat.

·

Eljárások:

Str, Val, Delete, Insert.

Lehetőleg a string műveleteket és függvényeket használjuk a karakterláncok kezelésére, a karakterenkénti hozzáférést körültekintően végezzük. A tömb típus - Array A tömb strukturált (összetett adattípus). Deklarálása Var

Deklarálása

Tomb

Var

Matrix : array[1..5, 1..4] of integer; Neve : String[[maxhossz]];

Pl: Neve : String[40];

ahol 1 <= maxhossz <= 255, ha elhagyjuk, maxhossz = 255. Dinamikus hosszúságú karaktersorozat: hossza futás közben változhat, elemei Char típusúak. A hossz deklarálása elmaradhat. Pl.:

: array[1..10] of integer;

A „Tomb” tíz elemű egydimenziós tömb A „Matrix” egy 5 sorból és 4 oszlopból álló kétdimenziós tömb, mátrix, elemei integer típusúak. A tömb olyan adatcsoport, melynek elemei azonos típusúak, az elemek száma rögzített (statikus méretű), sorrendjük kötött (indexelés), az elemekhez közvetlenül hozzáférhetünk. Meghatározása: név, dimenzió, elemeinek típusa, indexeinek típusa és tartománya. Az indextípus csak sorszámozott típus lehet (kivéve Longint), többnyire intervallum típus,

Var Neve : String;

A string típusú változók 0. karakterében kerül tárolásra a string hossza. Karakterlánc konstans: 'aposztrófok közötti szöveg' Hivatkozhatunk a karakterlánc egy elemére (amely Char típusú): azonosító[index]. Pl.: WriteLn(karlanc[5]);

A karakterlánc típusú változó értékét megváltoztathatjuk értékadással, valamint beolvasással. Értékét kiírathatjuk a képernyőre. Pl.: karlanc := 'hahó';

Például: array[1..10] of real;

{általában egész típus intervalluma}

array['a'..'z'] of real;

{ritkábban karakteres típus intervalluma}

array[byte] of real;

{még ritkábban egy előre definiált típus}

A többdimenziós tömbök: a tömb elemei maguk is tömbök, Például: m: array[1..10, 1..20] of integer,

vagy m: array[1..10] of array[1..20] of integer.

Műveletek

A hivatkozás a tömb egy elemére az index segítségével történik, pélául:

+ (összefűzés, konkatenálás), pl.:

Tomb[3]

{a vektor nevű tömb 3. eleme, Integer típusú}

TeljesNeve := VezetekNeve + ’ ’ + KeresztNeve;

Matrix[2, 3]

{vagy}

Matrix[2][3]

{a matrix nevű kétdimenziós …}

Relációs műveletek: <, >, <=, >=, =, <> (az eredmény természetesen logikai típusú, az első nem egyenlő karakter ASCII kódja határozza meg. Pl. 'ATTILA' < 'ALFONZ' HAMIS.)

88

{… tömb 2. sorának 3. eleme}

89

Műveletek Két azonos típusú tömbre az értékadás és az egyenlőség vizsgálat megengedett. Egy vektor bemásolható a mátrix egy sorába (ld. tömb típus deklarálása). A tömbökkel végzett műveletek során többnyire a for ciklust használjuk, úgy hogy a ciklusváltozót végigléptetjük a tömb indextartományán. Pl. egy a vektor nevű tömb beolvasása a billentyűzetről: For i := 1 To 10 Do Begin Write('Kérem a tömb ',i,'. elemét: ');

A rekord - Record típus A rekord strukturált adattípus, amelyben különböző típusú adatokat (mezőket) fogunk öszsze. Deklarálása: Deklarálásakor a Record és End kulcsszavak között fel kell sorolnunk az egyes mezők neveit valamint típusait. A rekord tartalmazhat egy változó részt is, amely a fix rész egy mezőjétől (szelektor mező) függően más-más adatokat tartalmazhat. Record 1. mezőazonosító : típus;

ReadLn(t[i])

2. mezőazonosító : típus;

End;

3. mezőazonosító : típus;

Tömb típusú konstans Tömb konstanst csak a Const deklarációs részben adhatunk meg tipizált konstansként. Az elemeket zárójelben, vesszővel elválasztva kell felsorolnunk. Pl. const T1 : array[1..3, 1..4] of byte = ((1, 3, 4, 1), (2, 3, 4, 2), (1, 6, 3, 5));

End;

Példák: … Type DolgozoTip = Record

Adatábrázolás A rendszer a tömböt sorfolytonosan tárolja a memóriában. A foglalt terület az elemek száma szorozva egy elem méretével.

Pl.

: string;

Hazas

: boolean;

Fizetes : longint; End; Var Dolgozok : array[1..50] Of DolgozoTip;

Tömb típus deklarálása Tömb típusú változók használatakor célszerű először a Type típusdeklerációs részben a megfelelő típusokat deklarálni, majd ezeket a saját típusainkat használhatjuk a változók deklarálásakor (a Var után). A Pascal nyelv logikája ezt az áttételes deklarálást támogatja, és bizonyos esetekben ez nem is kerülhető meg (ld. alprogramok).

Nev

dolgozo

: DolgozoTip;

…

Hivatkozás a rekord egy mezőjére: rekordazonosító.mezőazonosító Pl. Dolgozo.Nev := ’Gipsz Jakab’;

type VektorTip = array[1..4] of integer; MatrixTip = array[1..5] of VektorTip; var

v1, v2 : VektorTip; m1, m2 : MatrixTip;

A fenti példában elvégezhető a következő értékadás: pl. m1[2] := v1; .

A halmaz - Set típus A programozásban a halmaz azonos típusú különböző elemek összességét jelenti. A halmazt az elemek felsorolásával adhatjuk meg. Az elemek rendezetlenek. Az összetett adattípusokhoz soroljuk, bár a halmaz egy elemére nem tudunk hivatkozni. Deklarálása: Set Of alaptípus;

ahol az alaptípus csak olyan sorszámozott típus lehet, amelynek maximálisan 256 eleme van.

90

91

Halmaz típusú konstans: Szögletes zárójelben a halmaz elemeit (az alaptípussal megegyező típusú konstansokat) vagy azok intervallumait soroljuk fel. Például: …

Önellenőrzés

?

1. Milyen egész típusokat ismer?

Const Betuk = ['A'..'Z', 'a'..'z']; …

........................................................................................................................................................... 2. Milyen valós típusokat ismer?

Begin

...........................................................................................................................................................

… H1

:= [1, 4, 6, 8..12];

H2

:= []; {üres halmaz}

…

3. Mi az eredménye a következő kifejezésnek? 20 div 3 = ……………..

End.

20 mod 3 = ……………..

A programunkban egy halmaznak a halmaz konstanstól egy kicsit különböző halmazkonstruktorral is értéket adhatunk. Itt a szögletes zárójelben felsorolt kifejezések változókat is tartalmazhatnak. Például: k := '?';

20 shr 2 = …………….. 4. Hogyan adhatunk értéket egy karakteres kifejezésnek?

H := [k, '!','.'];

Műveletek: * metszet

5. Milyen értéket vehet fel egy Boolean típus?

+ egyesítés

...........................................................................................................................................................

- különbség

6. Írjon példát egy felsorolt típusra!

Logikai típusú eredményt szolgáltatnak: = egyenlőség <> különbözőség

7. Hogyan hivatkozhatunk egy karakterlánc 5. elemére?

<=, >= tartalmazás (részhalmaz) Az In elemvizsgálat; Adatábrázolás: Egy lehetséges halmazelemnek egy bit felel meg a memóriában. Ha az lehetséges az elem benne van a halmazban, akkor a bit 1, ellenkező esetben 0. Gyakran az első és az utolsó bájt olyan biteket is tartalmazhat, amelyek nem vesznek részt a tárolásban.

8. Hogyan deklarálhatunk egy 2 dimenziós tömböt?

9. Deklaráljon egy Autók rekord típust:

Példa: A halmazokat gyakran használjuk arra, hogy menüből való választás esetén programunk csak a megfelelő billentyűkre reagáljon.

92

93

Válaszok 1. Milyen egész típusokat ismer? Byte, ShortInt, Word, Integer, LongInt 2. Milyen valós típusokat ismer? Real, Single, Double, Extended, Comp 3. Mi az eredménye a következő kifejezésnek? 20 div 3 = 6 20 mod 3 = 2 20 shr 2 = 5 4. Hogyan adhatunk értéket egy karakteres kifejezésnek? S := ’Alma’;

5. Milyen értéket vehet fel egy Boolean típus? Logikai értéket vehet fel, mint például TRUE vagy FALSE . 6. Írjon példát egy felsorolt típusra! Var Nap : (Hetfo, Kedd, Szerda);

7. Hogyan hivatkozhatunk egy karakterlánc 5. elemére? Karakter := Szoveg[5];

8. Hogyan deklarálhatunk egy 2 dimenziós tömböt? T : Array [1..10][1..20] of intger;

9. Deklaráljon egy Autók rekord típust: Type Autok = Record Rendszam : String[7]; Gyartmany : String[50]; Tipus : String[50]; Ar : LongInt; End;

94

3. Példaprogramok 1. PÉLDAPROGRAM Készítsünk programot, amelymegadott számú valós számot olvas be, és kiszámítja a számok átlagát. Program AtlagSzamitas; Var n : integer; i : integer; sum : real; x : real; Begin sum:= 0; ReadLn(n); for i:= 1 to n do begin ReadLn(x); sum:= sum + x; end; WriteLn(sum/n:8:2);

{adatok száma} {ciklusváltozó} {összeg} {aktuális adat} {részösszeg = 0} {beolvassuk az adatok számát}

{beolvassuk a következõ adatot}

{Kiírás 8 karakter hosszan 2 tizedessel}

End.

2. PÉLDAPROGRAM Írjunk programot, ami bekér számokat és a legkisebbet és a legnagyobbat kiírja: program minmax; var elso: boolean; min, max: real; x: real; begin elso:= true; while not eof do begin readln(x); if elso then begin min:= x; max:= x; elso:= false; end else begin if x < min then min:= x; if x > max then max:= x; end end; writeln('Min:', min:8:3, ' end.

{ jelzi, hogy ez a legelsõ szám } { pillanatnyi legkisebb és legnagyobb } { aktuális adat } { { { { { { {

elsõ adat következik } amíg nincs file vége } beolvassuk a következõ adatot } legelsõ adat jön } ez lesz a pillanatnyi legkisebb } es a pillanatnyi legnagyobb is } bejött az elsõ szám }

{ { { {

ha ez ha ez

az új adat kisebb a mimimumtól } lesz az új minimum } nagyobb a maximumtól } lesz az új maximum }

Max:', max:8:3);

95

3. PÉLDAPROGRAM

4. Rendezések

Olvassunk be két egész számot, és számítsuk ki a legnagyobb közös osztójukat az ún. euklideszi algoritmussal.

Bevezető

program lnko; var x, y: integer; { a két szám tárolására} begin readln(x, y); { beolvassa a kát egész éretéket } write('LNKO(', x, ',', y, ')='); { bemenõ adatok kiírása } while x <> y do begin if x > y then x:= x - y else y:= y - x; end; writeln(x); { eredmény kiírása } end.

Rendezés alatt egy sorozat elemeinek csökkenő vagy növekvő sorendbe helyezését értjük. Ezt a sorozat egyes elemeinek felcserélésel érhetjük el. A rendezésnek nagyon sokféle módszere van. A rendező algoritmusok között nincs abszolút értelemben vett legjobb, ezért mindig az adott feladatnak legmegfelelőbb algoritmust választjuk ki. A rendezés fontos jellemzői a hatékonysági mutatók. Ezek a következők: a rendezés gyorsasága, tár- és memóriaigénye, az összehasonlítások és a mozgatások száma. A hatékonysági mutatók vizsgálata különösen akkor fontos, ha sok adatot rendezünk, vagy nagy méretűek az elemek, vagy file kezeléssel rendezünk. (A tárigény számításakor nem számítjuk be a ciklusváltozókat, hiszen azok biztos kevés helyet foglalnak, a mozgatások száma az előrendezetségtől függ, míg a végrehajtási idő gépfüggő.)

1. FELADAT Írjon programot, mely beolvas egy tetszőleges számsorozatot, majd kiírja a beolvasott legkisebb és legnagyobb számot! 2. FELADAT Írjon programot, mely beolvas egy tetszőleges számsorozatot, majd kiírja a beolvasott legkisebb és legnagyobb számot! 3. FELADAT Írjon programot, mely beolvas egy tetszőleges számsorozatot, majd kiírja a beolvasott legkisebb és legnagyobb számot!

A buborék rendezés A rendezés a buborék elvén alapul, egy buborék addig száll felfele, amíg a felette lévő buborék nehezebb nála, és ha már csak könnyebbek helyezkednek el megállnak. Lényege: A sorozat két utolsó elemét összehasonlítjuk, és ha forrdított sorrendbe vannak, akkor felcseréljük őket. Ezután az eggyel előrébb álló elempárt hasonlítjuk össze. Utoljára az első két elemet hasonlítjuk össze, és ha szükséges felcseréjük őket. Így az első már biztos, hogy a legkisebb lesz. Újra kezdjük az elempárok összehasonlítását az utolsó elempártól kezdve és elvégezzük a cserét, ha szükséges. Mivel az első helyen a legkisebb elem áll azt már nem kell összehasonlítani. Ezek után már a második elem is a helyére kerül. Az utolsó menetben már csak az utolsó elempárt kell összehasonlítani és szükség esetén felcserélni, hiszen a többi már rendezett lesz. Hátránya: sok benne az összehasonlítás és a csere. A kiválasztó rendezés Lényege: Nagy mértékben hasonlít a buborékrendezéshez. Az összes elem közül kiválaszjuk a legkisebbet és felcseréljük az elsővel. Ekkor már csak a második tagtól kezdődő részsorozattal kell foglalkoznunk. Ebben a részsorozatban is megkeressük a legkisebb elemet és a részsorozat elejére rakjuk. Ekkor már az egész sorozat első két eleme rendezett lesz. Az i. lépésben az i. elemmel kezdődő részsorozat legkisebb elemét cserérjük fel az i. elemmel, így az már i. elemig rendezett lesz. Mindezt n-1-szer kell elvégezni (az n az elemek száma). Az utolsót azért nem kell vizsgálni mert az már biztos, hogy a legnagyobb. Ha az adathalmazt csökkenő sorrendbe szeretnénk rendezni, akkor csak a relációt kell megcserélni. Beillesztéses rendezés Lényege: A tömbünket két részre osztjuk. Lesz egy rendezett és egy rendezetlen rész. Az első elemet természetesen nem kell rendezni. A rendezetlen részből kiválasztjuk az első elemet és beírjuk a rendezett részbe. (Ez lesz az első.) A rendezetlen részből kivesszük a követ-

96

97

kező elemet és megkeressük a helyét a rendezett tömbrészben. Oda beszúrjuk és léptetjük a mögötte lévő elemeket eggyel feljebb. A rendezetlen tömbrészből mindaddig olvassuk be az elemeket, amíg van benne. Példaprogram a buborék rendezésre

Önellenőrzés

?

1. Hogyan töltene fel egy 10 elemü tömböt véletlenszámokkal?

Program BuborekRendezes; Uses Crt; Const meret = 100; Var t: array[1..meret] of integer; i: integer; {Először feltöltjük a tömböt 0 és 9999 közé eső véletlen számokkal} Begin ClrScr;

2. Hogyan cserélne fel két változó tartalmát?

for i:=1 to meret do t[i] := random(10000);

writeln('Rendezetlenül:'); for i:=1 to meret do write(t[i], ' ');

{A t tömb kiírása}

for i:=1 to meret do for j:=1 to i-1 do if(t[j] > t[j+1] then

{A t tömb elemének cseréje, ha kell}

begin w

:= t[j];

t[j]

:= t[j+1];

3. Hogyan íratná ki egy 10 elemű tömb tartalmát a képernyőre?

t[j+1] := w; end; writeln('Rendezve:'); for i:=1 to meret do write(t[i], ' ');

{A t tömb kiírása}

End.

1. FELADAT Keressen példaprogramokat az ismertetett rendezési algoritmusokhoz. 2. FELADAT Nézzen utána az interneten, hogy milyen elven működnek a következő rendező algoritmusok, valamint keresen hozzájuk Pascal mintaprogramokat. · A Gyorsrendezés (Quicksort). · Rendezés bináris fával. · Nagy méretű állomány rendezése (ami egyszerre nem fér be a memóriába).

98

4. Milyen rendezési algoritmusokat ismer? ........................................................................................................................................................... ........................................................................................................................................................... ...........................................................................................................................................................

99


Válaszok 1. Hogyan töltene fel egy 10 elemü tömböt véletlenszámokkal? For i:=1 To 10 Do T[i] := Random(1000);

2. Hogyan cserélne fel két változó tartalmát? … tmp

:= a;

a

:= b;

b

:= tmp;

…

Két változó tartalmának a felcseréléséhez egy harmadik változóra is szükség van, melyben ideiglenesen tárolhatjuk a az egyik változó tartalmát a csere idejére. 3. Hogyan íratná ki egy 10 elemű tömb tartalmát a képernyőre? For i:=1 To 10 Do WriteLn(T[i]);

Vagy

Bevezetés Eddigiekben láthattuk a példaprogramokban, hogy a Pascal a végrehajtható utasításokat a főprogram törzsében tartalmazta. Sokszor szükséges, hogy az adott műveleteket többször is végre lehessen hajtani a program különböző helyein. Például, ha készítünk egy saját keretrajzoló programrészletet, akkor szeretnénk, hogy azt akár többször is könnyedén el lehessen érni. Vagy készítünk egy számoló programrészletet és azt is könnyedén el szeretnénk érni a program különböző pontjaiban. Például: …

{… Előző program utasítások}

Keret(5,5,20,20,dupla,zold,kek);

{Saját keretrajzoló rutin}

{vagy} ReadLn(Sugar);

{Sugár bekérése billentyűzetről}

Terulet := KorTerulet(Sugar);

{Saját függvény meghívása}

{esetleg} WriteLn(KorTerulet(Sugar));

{Saját függvény …}

…

{… Következő program utasítások}

{… közvetlen kiiratása}

For i:=1 To 10 Do Write(T[i],’, ’);

Látható, hogy mennyivel egyszerűbb ugyanannak a programrésznek a meghívása, ha névvel hivatkozunk rá.

Az adat kiírása után egy vesszőt és egy szóközt is kiíratunk

A tanulási feladatok elvégzése után a hallgató: · Képes lesz saját eljárások megírására · Képes lesz saját függvények megírására · Képes lesz saját eljárásainak és függvényeinek unitokba való elhelyezésére és meghívására és így, ezen ismeretekkel moduláris programok megírására

4. Milyen rendezési algoritmusokat ismer? Pl: ·

Buborékrendezés

·

Kiválasztó rendezés

·

Beillesztéses rendezés

·

Gyors rendezés

·

Rendezés bináris fával

·

Nagy állományok rendezése, melyek nem férnek be a memóriába

100

Rész célkitűzések 1. Eljárások 2. Függvények 3. Unitok 4. Példaprogramok

101

Például egy téglalap területének és kerületének a kiszámítása:

1. Eljárások

Procedure Teglalap(a, b: integer; var t, k: integer); Begin

A eljárások, tulajdonképpen alprogramok, melyek azért készülnek, hogy a programozó a programja során többször, kényelmesen meghívhassa őket. Vannak program részletek, amiket többször ugyanúgy kell végrehajtani, természetesen a paraméterek függvényében egy picit változhat a végrehajtás módja, de alapjaiban véve egységes. Az alprogramoknak szintén van neve és a főprogramból vagy másik alprogramból e névre való hivatkozással meg lehet hívni őket. Ezáltal a programunk szerkezete áttekinthetőbb, azaz strukturáltabb lesz, ha a logikailag összetartozó utasításokat alprogramokba foglaljuk. A Pascalban ezt a Procedure kulcsszóval vezethetjük be hasonlóan a Program kulcsszóhoz, mely a főprogramot vezeti be. Előnyük, hogy többször meghívhatók, és csak egyszer kell őket jól megírni. A pascalban kétféle alprogram van. Az eljárás és a függvény. A függvénnyel a következő fejezetben fogunk foglalkozni. Az alprogram olyan utasítások csoportja, amelyet a program bizonyos pontjairól aktivizálhatunk. Az alprogramokat a deklarációs részben kell megírnunk. Az alprogramok tartalmazhatnak újabb alprogramokat (egymásba ágyazás).

t := a * b; k := 2 * (a + b) End;

Az eljárás hívása azonosító [ (aktuális paraméter lista)]

ahol az aktuális paraméter lista elemei kifejezések vagy változók lehetnek (ld. paraméterátadás) egymástól vesszővel elválasztva. Például: Teglalap(5, 4, Ter, Ker)

Az eljárások hatásköre A Pascal nyelv befelé strukturált, az alprogramokat egymásba ágyazhatjuk (az alprogram deklarációs részében is lehet alprogram). Ezért fontos tisztán látnunk, hogy hogy a főprogramból illetve egy alprogramból mely eljárásokat hívhatjuk meg: §

A program illetve egy eljárás meghívhatja (ismeri) azokat az alprogramokat, melyeket a program vagy az adott alprogram deklarációs részében deklaráltunk, de azok alprogramjait már nem.

§

Egy alprogram meghívhatja az ugyanazon deklarációs részben (, ahol őt deklaráltuk) korábban deklarált alprogramokat.

§

Egy alprogram meghívhatja az őt tartalmazó eljárásokat.

§

Egy alprogram meghívhatja saját magát. (Rekurzió)

Akkor használjuk őket, ha ·

bizonyos tevékenység többször előfordul a programban,

·

egy nagy programot tagolni, strukturálni szeretnénk.

Már eddig is sok szabványos eljárást és függvényt használtunk, melyeket a különböző unitokban deklaráltak. Nézzük, hogyan készíthetünk saját alprogramokat! Szerkezete Szintaktikája hasonló a programéhoz. Procedure azonosító [ ( formális paraméter lista ) ]; Label... Const... Type... Var...

Paraméterek A paraméterek az eljárás és az őt hívó programrész közötti adatcserét, kommunikációt szolgálják. A formális paraméterekkel írjuk le az alprogram tevékenységét. Híváskor ezek helyére konkrét objektumokat, aktuális paramétereket írunk. Az aktuális és a formális paramétereknek meg kell egyezniük számban, sorrendben és típusban.

Procedure... Function... Begin utasítások End;

Ahol a formális paraméter lista a következő: [Var] azonosító [, azonosító...] : típusazonosító [; [Var] azonosító [, azonosító...] : típusazonosító...]

102

103

A paraméterátadás két féle módon történhet:

Önellenőrzés

Érték szerinti paraméter átadás (a deklarációban a formális paraméter előtt nincs Var) Ekkor az aktuális paraméter értéke kerül át a formális paraméterbe. Az eljárás minden egyes hívásakor a rendszer tárterületet rendel a verem memóriában a formális paraméterekhez, és ide másolja be az aktuális paraméterek értékeit. Az eljárás végeztével ez a terület felszabadul. Az aktuális paraméter értékét az eljárás nem változtathatja meg, így ez csak bemenő paraméter.

?

1. Mi az eljárás? ........................................................................................................................................................... ...........................................................................................................................................................

Az aktuális paraméter kifejezés lehet. Cím szerinti paraméter átadás (a deklarációban a formális paraméter elé Var -t írunk)

2. Mihez hasonlítható az eljárás szintaktikája?

Az aktuális paraméter címe kerül át a formális paraméterhez, ha változik a formális paraméter, akkor változik az aktuális is. Ezáltal egyaránt használhatjuk be- és kimenő paraméterként is.

...........................................................................................................................................................

Az aktuális paraméter csak változó lehet.

3. Írjon példát eljárás meghívására. ...........................................................................................................................................................

Lokális és globális változók Egy eljárásban deklarált változókat ezen eljárás lokális változóinak nevezzük. Ezek a program más részein nem ismertek. (Így különböző eljárásokban előfordulhatnak azonos nevű változók, amelyeknek azonban semmi közük egymáshoz.) A lokális változókhoz (az eljárás paramétereihez hasonlóan) a rendszer a veremben rendel tárterületet, dinamikus módon, azaz csak akkor van címe a változóknak, ha az eljáráson van a vezérlés. A lokális változók értéke az eljárás két hívása között elvész. Egy eljárásra nézve globális változó egy őt tartalmazó eljárásban vagy a főprogramban deklarált változó. Ezt az eljárás ismeri, hacsak nem deklaráltunk egy vele azonos nevű lokális változót vagy az eljárásnak nincs egy vele azonos nevű paramétere. Ekkor a lokális változó "eltakarja" a globálist. A globális változó értéke természetesen nem vész el. (Abban az esetben használhatunk egy a lokálissal azonos nevű globális változót, ha az a főprogram változója. Ekkor a program nevével kell minősítenünk a globális változót: programnév.változónév.) Információ csere Összefoglalva elmondhatjuk, hogy egy alprogram kétféle módon kommunikálhat az őt hívó programegységgel,

4. Milyen hatókörű változók léteznek? ........................................................................................................................................................... ........................................................................................................................................................... 5. Mit jelent az érték szerinti paraméterátadás? ........................................................................................................................................................... ........................................................................................................................................................... 6. Mit jelent a cím szerinti paraméterátadás? ........................................................................................................................................................... ...........................................................................................................................................................

§

a paramétereken keresztül

7. Hogyan cserélhetnek információt az alprogramok?

§

a globális változók segítségével

........................................................................................................................................................... ........................................................................................................................................................... ...........................................................................................................................................................

104

105

Válaszok 1. Mi az eljárás? A eljárások, tulajdonképpen alprogramok, melyek azért készülnek, hogy a programozó a programja során többször, kényelmesen meghívhassa őket. 2. Mihez hasonlítható az eljárás szintaktikája? A főprograméhoz hasonlítható, csak nem program kulcsszóval, hanem procedure kulcsszóval kell bevezetni. 3. Írjon példát eljárás meghívására. Keret(3,3,10,10,dupla);

vagy Vonal(23,23,100,200,szimpla,sarga)

2. Függvények A függvény feladata egy érték előállítása. Ezt az értéket a függvény nevéhez rendeljük, a függvény törzsében kell szerepelni legalább egy értékadó utasításnak, amelyben a függvény neve a baloldalon áll. (Vigyázzunk, ha a jobboldalon szerepeltetjük a függvény nevét, akkor az már rekurziót jelent.) A függvényt egy kifejezésben hívhatjuk meg, pl. egy értékadó utasítás jobboldalán. Szerkezete megegyezik az eljáráséval azzal a különbséggel, hogy még meg kell határoznunk a viszatérési érték típusát is. Így a függvény feje: Function azonosító [ ( formális paraméter lista ) ]: típusazonosító;

ahol a típusazonosító csak sorszámozott, valós, karakterlánc vagy mutató lehet. Például: … Function Tangens(Alfa: real): real; Begin If cos(Alfa) <> 0 Then

4. Milyen hatókörű változók léteznek? Globális és lokális.

Tangens := Sin(Alfa) / Cos(Alfa) End;

5. Mit jelent az érték szerinti paraméterátadás? (a deklarációban a formális paraméter előtt nincs Var)

…

Példa a fenti függvény meghívására:

Ekkor az aktuális paraméter értéke kerül át a formális paraméterbe. Az eljárás minden egyes hívásakor a rendszer tárterületet rendel a verem memóriában a formális paraméterekhez, és ide másolja be az aktuális paraméterek értékeit. Az eljárás végeztével ez a terület felszabadul. Az aktuális paraméter értékét az eljárás nem változtathatja meg, így ez csak bemenő paraméter.

Rekurzió

6. Mit jelent a cím szerinti paraméterátadás? (a deklarációban a formális paraméter elé Var -t írunk)

A rekurzió alkalmazásának egyik területe, amikor úgy oldunk meg egy problémát, hogy visszavezetjük egy egyszerűbb esetre, majd ezt addig folytatjuk, míg el nem jutunk a triviális esetig. A módszer a matematikai indukción alapszik.

Az aktuális paraméter címe kerül át a formális paraméterhez, ha változik a formális paraméter, akkor változik az aktuális is. Ezáltal egyaránt használhatjuk be- és kimenő paraméterként is. 7. Hogyan cserélhetnek információt az alprogramok? Paramétereken és globális változókon keresztül.

106

x := Tangens(b);

Ha egy alprogram saját magát meghívja, akkor rekurzióról beszélünk. Megkülönböztethetünk közvetlen és közvetetten rekurziót.

A megoldás lépései 1. Megkeressük azt a legegyszerűbb esetet, ahol a megoldás már magától értetődő - triviális eset. Ekkor áll le a rekurzív hívások sorozata. 2. Megvizsgáljuk, hogy ismételt egyszerűsítésekkel hogyan juthatunk el a triviális esethez. (Az általános esetet visszavezetjük az eggyel egyszerűbbre.)

107

Önellenőrzés

?

1. Mi a függvény feladata? ........................................................................................................................................................... 2. Hogyan kap értéket a függvény? ...........................................................................................................................................................

Válaszok 1. Mi a függvény feladata? A függvény feladata az érték előállítása. 2. Hogyan kap értéket a függvény? A függvén utolsó sorában a Függény neve := érték;

utasítással 3. Hogyan hívhatjuk meg a függvényt? ...........................................................................................................................................................

3. Hogyan hívhatjuk meg a függvényt? {például} x := Tangens(b);

4. Mi a rekurzió? ........................................................................................................................................................... 5. Mi a különbség a függvény és az eljárás között?

4. Mi a rekurzió? Amikor egy függvény önmagát hívja meg. Például egy faktoriális kiszámításához jól felhasználható ez a lehetőség.

...........................................................................................................................................................

5. Mi a különbség a függvény és az eljárás között? A függvény egy értékel tér vissza, még az eljárás nem.

...........................................................................................................................................................

6. Írjon egy egyszerű függvényt, ami kiszámolja egy téglalap területét? …

6. Írjon egy egyszerű függvényt, ami kiszámolja egy téglalap területét?

Function teglalap_terulet (a,b:real):real; Begin teglalap_terulet := a * b; End; … {a függvény meghívása} T := teglalap_terulet(3,4); WriteLn(’A téglalap területe: ’,T); …

108

109

Példa:

3. Unitok Az egységek (unitok) előre lefordított programmodulok. Általában egy adott területhez tartozó eljárásokat, függvényeket tartalmaznak, illetve deklarálják az általuk használt konstansokat, típusokat, változókat. Mivel a kódszegmens maximálisan 64 kB lehet, így programunk nagysága is korlátozott. Ha elértük a határt (kb. 2-3000 programsor), akkor programunk egyes részeit saját unitokban helyezhetjük el, melyek külön-külön szintén 64 kB méretűek lehetnek.

A négyzet és a kör kerületét kiszámító függvényt írjuk meg és helyezzük el egy külső unitban. Íme a megvalósítása: A programot Sajat.pas-ba szükséges menteni. Unit Sajat1; Interface Crt;

Az egység felépítése: Unit azonosító;

{Kapcsolattartó/interfész rész}

Uses

{egységfej, akár a programnál a program fej}

Az azonosítót kell megadnunk a Uses kulcsszó után abban a programban vagy egységben, ahol a unitot használni szeretnénk, továbbá az azonosító legyen a neve az elmentett forrásnyelvű unitnak.

Function KorKerulet(Sugar:Real) : Real; Function NegyzetKerulet(A_oldal:Real) : Real; Implementation

{Kifejtő rész}

Function KorKerulet;

Illesztő rész:

{Itt már nem kell megismételni}

Begin

Interface

{

a teljes fejrészt}

KorKerulet := 2 * Sugar * 3.14;

[USES azonosító [,azonosító...];]

End;

Továbbá globális deklarációk (konstansok, típusok, címkék, változók, eljárások, függvények), melyeket az egységet használó programokban illetve egységekben is elérhetünk. Az eljárásoknak, függvényeknek itt csak a fejlécei szerepelnek.

Function NegyzetKerulet; Begin NegyzetKerulet := A_oldal * 4;

Kifejtő rész:

End;

Implementation

End.

[USES azonosító [,azonosító...];]

A fenti unit meghívása programunkból:

Továbbá egység hatáskörű deklarációk (konstansok, típusok, címkék, változók, eljárások, függvények), melyeket csak ebben az egységben érhetünk el. Itt fejtjük ki az Interface részben deklarált eljárásokat, függvényeket is. Inicializáló rész: [BEGIN

Program MintaProgram; Uses Crt, Sajat; …

{Azt a nevet, amit a fenti modulban: Unit Sajat;}

Begin …

[utasítás [; utasítás...]]

A függvények hívása már ugyanúgy megy, mint eddig} WriteLn(’A négyzet kerülete = ’,nKer:10:2);

A főprogram első utasítása előtt egyszer végrehajtódik, elhagyható.

Ha az egységet elkészítettük, .pas kiterjesztéssel mentjük lemezre. Az egységet le kell fordítanunk (a fordítást lemezre kérjük a „Compile” menü „Destination Memory”-ra ütünk entert. Ekkor az megváltozik „Destination Disk”-re). A lefordított egység kiterjesztése .tpu lesz.

110

Saját unit

nKer := NegyzetKerulet(4);

END.

Ha több egység egymást kölcsönösen használja, akkor mindegyikben a többi egység nevét az implementációs rész Uses kulcsszava után kell megadni.

{Itt kell megadni a használni kívánt unit nevét}

{vagy a WiteLn-be ágyazva közvetlenül:} WriteLn(’A négyzet kerülete = ’, NegyzetKerulet(4):10:2); {Ugyanígy kell meghívni a kör kerületét is, mint a négyzet kerületét. J} … End.

111

Önellenőrzés

?

1. Miért van szükség unitokra? ........................................................................................................................................................... ........................................................................................................................................................... 2. Milyen azonoságot kell betartani az egység nevével kapcsolatban?

Válaszok 1. Miért van szükség unitokra? Az egységek (unitok) előre lefordított programmodulok. Általában egy adott területhez tartozó eljárásokat, függvényeket tartalmaznak, illetve deklarálják az általuk használt konstansokat, típusokat, változókat. Mivel a kódszegmens maximálisan 64 kB lehet, így programunk nagysága is korlátozott. Ha elértük a határt (kb. 2-3000 programsor), akkor programunk egyes részeit saját unitokban helyezhetjük el, melyek külön-külön szintén 64 kB méretűek lehetnek.

...........................................................................................................................................................

2. Milyen azonoságot kell betartani az egység nevével kapcsolatban? Az egység feje és a fájl neve egyezzen meg.

3. Hogyan kell lefordítanunk az egységet?

3. Hogyan kell lefordítanunk az egységet? Lemezre. A „Compile” menüben a „Destination memory”-ra kell entert ütni és akkor átváltozik „Destination disk”-re. Azaz a kész unit a lemezre készül el és .tpu kiterjesztést fog kapni.

........................................................................................................................................................... ........................................................................................................................................................... 4. Írjon egy egyszerű unitot, melyben egy két számot öszeadó függvényt ír meg.

4. Írjon egy egyszerű unitot, melyben egy két számot öszeadó függvényt ír meg. Unit Sajat1; Interface

{Kapcsolattartó/interfész rész}

Function Osszead(a,b:Real) : Real; Implementation

{Kifejtő rész}

Function Osszead;

{Itt már nem kell megismételni}

Begin

{

a teljes fejrészt}

Osszead := a + b; End; End. … {Meghívása például:} Osszeg := Osszead(3,4); {vagy} Osszeg := Osszead(x,y); …

112

113

Objektumorientált programozási technikák alkalmazása Bevezetés Ha most megvizsgálnánk a fejlesztőrendszerekkel kapcsolatos piaci helyzetet, akkor megállapíthatnánk, hogy egyre nagyobb az igény a hatékony, Windows alatt működő programok rövid határidős fejlesztésére. A Windows programok készítésére szolgáló hagyományos fejlesztő programokkal való programkészítéshez hatalmas programozói tudásra és gyakorlatra van szükség. Nem beszélve a különböző adatbázisokkal való kapcsolatteremtésről. További eszközöket igényel az elkészített alkalmazás piacképes változatának kialakítása. A fenti nehézségek áthidalására születtek meg a különböző 4GL-es fejlesztőrendszerek, mint például a Borland cég által készített Delphi is. Itt had említsem meg, hogy nem ez az egyetlen 4GL-es fejlesztőrendszer. Ilyen fejlesztőrendszer még a Visual FoxPro, Visual Basic, Visual C és a Clarion for Windows is, és még sorolhatnánk egy ideig. A lényeg, hogy ezek a rendszerek már majdnem mindegyike Objektumorientált programozási technikát igényel.

A tanulási feladatok elvégzése után a hallgató: · Ismerni fogja az OOP alapfogalmait · Képes lesz saját objektumok létrehozására a Pascalban · Képes lesz elindítani a Delphi fejlesztőrendszert · Képes lesz létrehozni, elmenteni, megnyitni egy Delphi projektet · Képes lesz elkészíteni egy egyszerűbb Delphi alkalmazást Rész célkitűzések 1. Objektumorientált programozási alapfogalmak 2. A Delphi keretrendszer 3. Program készítése Delphiben 4. Egy egyszerű Delphi alkalmazás elkészítése

Minden apróságnak az ismertetése meghaladja a könyvünk terjedelmét így épp csak a legrövidebb bemutatásra kerül sor. Tulajdonképpen ez csak egy kis kedvcsináló, hogy a kedves Olvasó elmenjen egy könyvesboltba és vásároljon valamilyen 4GL-ről szóló könyvet és beszerezzen valamilyenly 4GL-es fejlesztőrendszert. A Delphinek a legújabb, valamilyen korlátozással bíró változata letölthető az Internetről és regisztráció után saját tanulási célra felhasználható. A modulfüzetben nem törekedhetünk a teljességre. Itt most azt tartottuk szem előtt, hogy némi programozói alapismerettel tudjanak valamilyen egyszerűbb programot készíteni 4GL-es eszközökkel. Mire is gondoljunk, amikor azt halljuk, hogy Delphi? A gyártó hivatalos definíciója szerint: „A Delphi olyan windowsos alkalmazásfejlesztő eszköz, amelyet az alábbi fontosabb tulajdonságok kombinációja jellemez: A vizuális, komponensalapú felépítéséből következő gyors alkalmazásfejlesztés (RAD – Rapid Application Development). Az optimalizálásra is képes forrásnyelvi fordítóprogram. A testre szabható atbázis-hozzáférés.”

Természetesen, ha valamely 4GL eszközzel kíván majd adatbázist kezelni, javaslom, hogy keressen olyan 4GL-es fejlesztőrendszert, amit esetleg pont adatbáziskezelésre fejlesztettek ki. Ilyen például a Clarion for Windows vagy a Visual FoxPro, de nyugodtan használjunk egy általános fejlesztőrendszert is adatbáziskezelésre, mint például a Delphi. Amennyiben sikerült felkeltenem az érdeklődését a hallgatóknak, akkor javaslom, hogy válasszanak könyvet az ajánlott, témához kapcsolódó irodalomjegyzékből.

114

115

1. Objektumorientált programozási alapfogalmak Rekord vagy objektum? Az OOP (Objektumorientált Programozás) sokban eltér a hagyományos, strukturált programozástól, annál hatékonyabb, de több ismeretet is követel a programozótól. Alapja az Objektum, mely adatszerkezet hasonlít a Record-ra, s megérteni is legjobban a rekorddal való összehasonlítás során lehet. Nézzük meg egy rekord felépítését! Legyen ez a Record egy szöveg kiírását segítő adatszerkezet! Type

{Saját típus deklarálása}

Szoveg=Record

{Koordináták}

s

{Szöveg változója}

: String;

Var SajatSzoveg : Szoveg;

Szoveg=Object

Begin

{Objektum fej}

x,y : Integer;

{koordináta mezők definiálása}

s

{szöveg mező definiálása}

: String;

{Az objektum metódusainak deklarálása. Egy inicializáló és egy kiíró} Procedure Init(X0,Y0:Integer; S0:String); Procedure Kiir; End;

{} {}

{Az inicalizáló metódus kifejtése. A metódus neve előtt meg kell adni,} {hogy mely objektum metódusa. Ezt láthatjuk lejjebb a kiíró metódusnál is} Procedure Szoveg.Init(X0,Y0:Integer; S0:String); Begin

{Metódus kezdete}

{Változók deklarációja}

x:=X0;

{A mezők értékeinek megadása}

{A SajatSzoveg egy Szoveg típusú}

y:=Y0;

{

{

s:=S0;

{}

rekord}

Procedure Ertek(Var SajatSzoveg:Szoveg);{Eljárásfej}

End;

a metódus paraméterei által}

{Init metódus vége}

{Eljárás kezdete}

With SajatSzoveg do

{}

{Szöveget kiíró metódus kifejtése}

X:=10;

{Értékadás: koordináták megadása}

Procedure Szoveg.Kiir;

Y:=10;

{-”-}

S:=’Ez egy szöveg :-)’;

{Értékasás az S-nek}

GotoXY(x,y);

{Pozicionálás a képernyőn}

{With vége}

WriteLn(s);

{Szöveg kiírása képernyőre}

End; End; Procedure Kiir(SajatSzoveg : Szoveg); Begin

{Eljárás vége} {A kiíró eljárás feje} {Az eljárás kezdete}

GotoXY(SajatSzoveg.X,SajatSzoveg.Y);{Pozicionálás a képernyőn} WriteLn(SajatSzoveg.S);

{Képernyőre való írás} {Az eljárás vége}

Jobb megoldás lenne ennél, ha a rekordhoz nem kellene külön megírni az eljárásokat, hanem az adatszerkezet tartalmazná azokat. A rekordnál ez nem lehetséges, mert a nyelv szintaktikája szorosan köt minket.

116

Type

{Rekord vége}

Az x,y mezők a szöveg helyét határozzák meg a képernyőn, az s magát a szöveget. Mint láthatjuk a Rekord-nak van neve, típusa, és vannak mezői, melyek összességükben egy adatstruktúrát alkotnak. Ahhoz viszont, hogy a rekordban tárolt szöveg a képernyőre kerüljön, mindenképpen deklarálnunk kell a rekord egy példányát, értéket kell adnunk a rekord mezőinek, mely egy újabb rutin, majd készítenünk kell egy kiíró eljárást. A Turbo Pascal nyelvi változat a következő képpen néz ki:

End;

Nézzük ugyanazt a megoldást objektum segítségével: {Saját, Szoveg nevű objektum típus deklarálása}

{Rekord fej}

x,y : Integer; End;

Ennek a problémának a megoldásához Objektum-ot kell használnunk, melybe beleírhatunk az eljárásokat és a függvényeket is, megoldhatjuk benne a kezdőértékek beállítását és még jó néhány dolgot, de ezeket majd később nézzük meg. A probléma megoldása tehát az Objektum, amelynek az adatmezőin kívül metódusai is vannak. A metódusok azok az eljárások és függvények, amelyek az objektum adatain dolgoznak. Segítségükkel beállíthatjuk az objektum adatmezőinek az értékeit, valamint lekérdezhetjük azokat.

Begin

End;

{Metódus (eljárás) fej} {Kiír kezdete}

{Kiír metódus vége}

Ez így már egész jól néz ki! Az objektum magában foglalja a kiíráshoz szükséges adatokat, a kezdőérték beállítását, valamint a kiíró eljárást (utasítást) is. Előny az is, hogy a változókat elfedtük a külvilág elől, mivel a kezdőérték beállítását nem közvetlenül, hanem az Init eljárás segítségével közvetett úton adjuk meg. Ez hasznos lehet a későbbiekben, amikor bonyolultabb objektumokat készítünk, mert az adatokat meg tudjuk védeni a hibás értékadásoktól (erre a technikára az OOP nyelvek lehetőséget biztosítanak a Private, Public és Protected kulcsszavakkal), s ellenőrizni tudjuk, hogy mikor és hogyan kapnak értéket. Fontos szabály az OOPben, hogy az adatokhoz a programozó biztosítja a hozzáférést, tehát azokat a külső rutinok

117

csak így, közvetett úton érhetik el. Ezt mi is tegyük meg! Írjunk az objektumhoz függvényeket, amik lekérdezik a mezők értékét! {X koordinátát lekérdező metódus (függvény)} Function GetX:Integer;

{Függvény fej}

Begin GetX:=X;

{Értékadás a függvénynek}

End; {Y koordinátát lekérdező metódus (függvény)} Function GetY:Integer;

{Függvény fej}

Begin GetY:=Y;

Néhány gondolat az objektumorientált programozásról ·

Az objektum tartalmazza az eljárásokat (metódus), amikkel az objektum adatain dolgozhatunk!

·

Az objektumnak kezdőértéket kell kapnia (inicializálás)!

·

Az objektum mezői a metódusain keresztül kapnak értéket!

·

A mezők értékét közvetett úton lehet olvasni, függvények (esetleg property-k) segítségével! (adatrejtés)

·

Az objektumnak deklarálni kell egy példányát, csak ezután használható!

·

Az objektum metódusai mindig az objektum mezőire vonatkoznak és azokra fejtik ki hatásukat!


End;

Az OOP alapfogalmai:

{Szöveget lekérdező metódus (függvény)} Function GetS:String;

·

Egységbezárás (encapsulation) azt jelenti, hogy az adatstruktúrákat és az adott struktúrájú adatokat kezelő függvényeket (metódusokat) kombináljuk, azokat egy egységként kezeljük, és elzárjuk őket a külvilág elől. Az így kapott egységeket objektumoknak nevezzük.

·

Öröklődés (inheritance) azt takarja, hogy a meglévő objektumokból levezetett újabb objektumok öröklik a definiálásukhoz használt alapobjektumok egyes adatstruktúráit és függvényeit, ugyanakkor újabb tulajdonságokat is definiálhatunk hozzájuk vagy a régieket felüldefiniálhatjuk.

·

Többrétűség (polymorphism) alatt azt értjük, hogy egy adott tevékenység (metódus) azonosítója közös lehet egy adott objektum hierarchián belül, ugyanakkor az objektumhierarchia minden egyes objektumában a tevékenységet végrehajtó metódus implementációja az adott objektumra nézve specifikus lehet.

{Függvény fej}

Begin GetS:=S;


End;

Természetesen az objektum deklarációjában fel kell venni e három függvényt. Ha ezt megtettük, az objektum a következőképpen fog kinézni: Type Szoveg=Object x,y : Integer; s

: String;

Function GetX:integer; Function GetY:integer; Function GetS:String; Procedure Init(X0,Y0;S0:string); Procedure Kiir; End;

Vegyük észre, hogy az objektum mezőire nem úgy hivatkoztunk az eljárásokban, mint ahogy a rekordoknál tettük! Ennek az oka az, hogy az objektum metódusai mindig az objektum mezőire vonatkoznak, és a hagyományos felfogással szemben itt nem az eljárásokhoz készítünk változókat, hanem a változókhoz rendeljük hozzá az eljárásokat. Ez a látásmód eltér az eddigiektől, de ha megszokjuk és megtanuljuk az alkalmazását, lényegesen megkönnyíti munkánkat.

Ez a három fogalom kulcsfontosságú az OOP alkalmazásában. Ezek az elvek képzik az alapját az objektumorientáltságnak, s ezek az elvek teszik hatékonyabbá a hagyományos struktúrát programozásnál.

Öröklés Az öröklés nagyon hasonlít a való világban ismert öröklésre. Nézzünk egy példát. Vegyünk egy gyermeket. Megállapítható, hogy ő milyen tulajdonságokat örökölt a szüleitől és az is megállapítható, hogy milyen új tulajdonságokat vett fel, amiket nem örökölt. Gondolhatunk a családfára is. Az objektumhierarchia hasonló a családfához. A pascalban deklarálhatók alosztályok (leszármazott típusok), ezek öröklik az osztályok (őstípusok) adatmezőit és metódusait, ami lehetővé teszi a hierarchikus struktúra létrehozását. Ez nagyságrendekkel előrébb vitte a programozói szemléletet a hagyományos procedurális programozáshoz képest. Nézzük meg az öröklést egy példán keresztül:

118

119

Korai és késői kötés

Type {Az őstípus objektum definiálása, az Object után nincs zárójel} Hely = Object x, y : Integer;

{Koordináták deklarálása}

End; {Leszármazott típus. Az Object(Hely) zárójelben az őst kell megnevezni} Pont = Object(Hely) Lathato : Boolean;

Vajon mi lehet a különbség a korai és a késői kötés között. Ugyanaz mint a most meghozott döntés és a később meghozott döntés között. Azaz megmondjuk a fordítómnak, hogy tudod mit akarok, tedd hát meg vagy még nem tudom mit akarok, majd ha eljön az ideje, akkor tedd meg. Korai kötésnek nevezzük azt az eljárást, amikor egy statikus metódus hívása fordítási időben egyszer s mindenkora rögzített. Ennek futási időben történő eldöntését késői kötésnek nevezzük.

{Új mező felvétele}

A Constructor és a Destructor

End;

Itt a „Hely” egy őstípus és a „Pont” egy leszármazott típus. Minden objektumnak bármenynyi leszármazottja lehet (a „Pont” objektumnak is lehet további leszármazottja), de őse csak egy.

A Private és Public kulcsszavak Lehet olyan körülmény, amikor azt szeretnénk, hogy az objektum egy része ne legyen elérhető a külvilágból. Ezt könnyen megtehetjük, mert azokat a mezőket a private kulcsszóval bevezetve deklaráljuk. Ezekhez az adatmezőkhöz csak a metódusaival férhetünk hozzá. Erre a szintaktika is lehetőséget biztosít a private és a public kulcsszavak bevezetésével. Nézzünk erre egy példát! Készítsünk egy objektumot, mely egy kört rajzol ki a képernyőre! Type Kor=Object(Hely) Private Szin

: Byte;

Sugar

: Integer;

Public Constructor Init(pSzin:Byte;pSugar:Integer);Virtual; Function GetX:Integer; Function GetY:Integer; Procedure Rajzol; Destructor Done; End;

Látható, hogy a deklarációban szerepel két új kulcsszó. A private rész után szereplő változók, eljárások a „külvilág” (a főprogram) számára láthatatlanok, vagyis azokat csak az objektum metódusai érhetik el, míg a public kulcsszó utáni változók, eljárások láthatóak.

További két új szóval találkozunk az objektum deklarációban: ez a Constructor és a Destructor. A szabályok közt szerepelt az is, hogy az objektum mezőinek kezdő értéket kell kapniuk, ez a Constructor feladata; majd a használat után az erőforrásokat fel kell szabadítani, és erről gondoskodik a Destructor. Az ilyen módon deklarált eljárások minden esetben (garantáltan) lefutnak. A konstruktor neve a pascalban Init, a Delphiben Create, a destruktor neve a Pascalban Done, a Delphiben Destroy vagy Free. ·

A konstruktor egy speciális eljárás, amit virtuális metódusok inicializálására használunk.

·

A destruktor az a speciális metódus, amely a dinamikusan helyet foglaló objektum példányok törlésére és megszüntetésére használható.

A „Kor” objektummal nem kellett ismét megírni a metódusokat, hanem a régieket használhatjuk úgy, hogy az objektumot egy, már meglévőből „Hely” hoztuk létre. Ilyen módon létrehozhatunk több egymásból származtatott objektum szintet is. A programok továbbfejlesztésénél ez nagyon kényelmes megoldás, mivel nem kell a meglévő Objektumok helyett újakat írni. Az eddig említett néhány szabály elegendő ahhoz, hogy belekezdjünk a Delphi megismerésébe. Az Objektumorientált Programozás ismerete nélkülözhetetlen a Delphi programozása. Ezért amikor tanuljuk a Delphi-t, érdemes rá időt fordítani. Ismerete nélkül a továbbhaladás nagyon nehézkes, némely részeknél szinte lehetetlen. Fordítsunk tehát figyelmet az Objektumok részletes megismerésére, az Objektum Hierarchia, az öröklődés, és a különböző kulcsszavak tanulmányozására, hogy ezzel későbbi munkánkat megkönnyítsük! A Delphi rendszerben használható a fent említett Object kulcsszó, de a Delphi programok az ún. Osztály vagy másnéven Class kulcsszóval deklarált adatszerkezetet támogatják. A Class lényegesen több beépített metódust és lehetőséget tartalmaz, mint az Object.

Virtuális metódusok Az eddig tárgyalt metódusok statikusak. A fordító fordítási időben dönti el, hogy hol foglalnak majd helyet a memóriában ugyanúgy, mint a változóknak. Az itt említett probléma oka az ún. fordítási időben való hivatkozás-feloldás. A probléma megoldása a futási időben való hivatkozás-feloldása, vagyis dinamikussá tétele. Ehhez nyújtanak segítséget a virtuális metódusok. 120

121

Önellenőrzés

?

1. Milyen 4GL-es fejlesztőrendszereket ismer?

Válaszok

...........................................................................................................................................................

1. Milyen 4GL-es fejlesztőrendszereket ismer? Delphi, Visual FoxPro, Visual C, Visual Basic, Visual Java, Clarion for Windows, …

2. Mik a metódusok?

2. Mik a metódusok? A metódusok, eljárások és függvények, melyek az objektum adatain dolgoznak.

........................................................................................................................................................... 3. Mit jelent az egységbezárás? ........................................................................................................................................................... ........................................................................................................................................................... 4. Mit jelent az öröklés? ...........................................................................................................................................................

3. Mit jelent az egységbezárás? Egységbezárás (encapsulation) azt jelenti, hogy az adatstruktúrákat és az adott struktúrájú adatokat kezelő függvényeket (metódusokat) kombináljuk, azokat egy egységként kezeljük, és elzárjuk őket a külvilág elől. Az így kapott egységeket objektumoknak nevezzük. 4. Mit jelent az öröklés? Öröklődés (inheritance) azt takarja, hogy a meglévő objektumokból levezetett újabb objektumok öröklik a definiálásukhoz használt alapobjektumok egyes adatstruktúráit és függvényeit, ugyanakkor újabb tulajdonságokat is definiálhatunk hozzájuk vagy a régieket felüldefiniálhatjuk.

........................................................................................................................................................... 5. Mi a többrétűség? ........................................................................................................................................................... ........................................................................................................................................................... 6. Mi a korai kötés? ........................................................................................................................................................... 7. Mi a késői kötés?

5. Mi a többrétűség? Többrétűség (polymorphism) alatt azt értjük, hogy egy adott tevékenység (metódus) azonosítója közös lehet egy adott objektum hierarchián belül, ugyanakkor az objektumhierarchia minden egyes objektumában a tevékenységet végrehajtó metódus implementációja az adott objektumra nézve specifikus lehet. 6. Mi a korai kötés? Korai kötésnek nevezzük azt az eljárást, amikor egy statikus metódus hívása fordítási időben egyszer s mindenkora rögzített … 7. Mi a késői kötés? … ennek futási időben történő eldöntését késői kötésnek nevezzük.

........................................................................................................................................................... 8. Mi a construktor és a destructor foglalt szó szerepe? ........................................................................................................................................................... ...........................................................................................................................................................

122

8. Mi a construktor és a destructor foglalt szó szerepe? · A konstruktor egy speciális eljárás, amit virtuális metódusok inicializálására használunk. · A destruktor az a speciális metódus, amely a dinamikusan helyet foglaló objektum példányok törlésére és megszüntetésére használható.

123

2. A Delphi keretrendszer „Minden programnak saját egyéni felületet!” ez lehetett a jelszó az IBM által kifejlesztett SAA13 koncepció megalkotása előtt. Az eddigi, egyedileg fejlesztett programoknál, amiknek nem volt egységes kezelőfelülete, szinte minden alkalommal nem csak a programot magát, hanem a kezelését is meg kellett tanulni. Ennek az időszaknak úgy látszik, hogy vége van már, mert az új 4GL-es fejlesztőrendszerekkel készített programok már-már mind megfelelnek az IBM által kidolgozott SAA koncepciónak. Mit is jelent ez? Egy, a gyakorlatban is jól bevált külsőt alkalmazunk minden programra. Azaz a a súgót az F1-es billentyűvel érjük el, a képernyő frissítés az F5, a menüt az F10-es billentyűvel lehet meghívni, a párbeszédablakokat az ESC-vel lehet elhagyni, az OK gombot az Enterrel lehet megnyomni, ha nem is vagyunk rajta (persze, ha az az alapértelmezett gomb) és így tovább. Az SAA úgy is fordítható, hogy „Egységes műveletstruktúra a felhasználás számára”.

Mielőtt nekiállnánk a Delphi programozásának, ugyanúgy, mint a Turbo Pascalnál, meg kell ismerkednünk a fejlesztőrendszer alapvető kezelésének ismereteivel. Természetesen itt is feltételezzük, hogy a Delphi már telepítve van az önök számítógépére, így most a telepítését nem részletezzük. A Delhi elindítása a Start menü / Programok / Borland Delhi 5 / Delphi 5 almenüponttal indítható. Természetesen a különböző változatok esetén ez egy picit eltérhet, feltételezzük, hogy egy program indítása már nem okoz nehézségeket. Itt most a Delhi 5-ös verziójában mutatjuk be az alapvető, szükséges ismereteket. Ugyanis, aki ezeket megtanulja az már könnyedén fog átállni egy következő változatra és más hasonló 4GL-es fejlesztőrenszer megismerése sem fog különösebb gondot okozni. Az alapkoncepció nagyban nem tér el az újabb változatokban. Azokban sokkal több új komponens, lehetőség jelenik meg, de a számunkra fontos tanulási feladatok elvégzéséhez ez is bőven elegendő lesz. Amikor elindítjuk a fejlesztőrendszert, akkor a következő ábrán látható ablakokat láthatjuk a képernyőn:

Az SAA-koncepció három részre tagolható: 1. CPI (Common Programming Interface) A CPI leírja az interfészt, amelyen keresztül a perifériák, fájlok, … elérhetők. 2. CUA (Common User Access) A „egyetemes felhasználói hozzáférés” azt mondja, hogy egy programnak hogyan kell a képernyőn megjelennie, hogyan kell a különböző információkat kiírnia, és hogyan kell azokra a felhasználóknak reagálnia. Pl.: F1 a help, F10 a menü és így tovább. Ez perszt további három résztre osztható, azaz meg kell különböztetni a megjelenítés lehetősége alapján a következő három megjelenítő eszközt: ·

Terminál (Pl. IBM AS/400)

·

Karakteres képernyő (Pl. DOS)

·

GUI (Azaz a grafikus felhasználói felület, mint pl. a Windows 95)

3. CCS (Common Communications Support) Az „egységes kommunikációs támogatás” a számítógépek közötti kommunikációra, adatcserére vonatkozó kritériumokat tartalmazza. A fájlformátum és kommunikációs protokoll egységesítése tartozik ide. A TP 6.0 is már ilyen egységes felülettel rendelkezik. A Windowsban lévő szinte az össze program is. Gondoljon csak bele a kedves Olvasó, mi lenne, ha az egyik programban a menüt az F10-zel érné el a másikban az F4-gyel és a harmadikban a Ctrl+Alt+Shift+M –mel. Ugye milyen rossz lenne mindig újat tanulni? Hogy a legnagyobb mértékben tudjunk egységes programot készíteni, a Delhi az egységesen, a már máshol is megszokott eszközpalettát biztosítja a számunkra. Ezeket az eszközöket a programozói szakszótárban is kontrolloknak hívják. Ilyenek például a nyomógombok, a beviteli szerkesztőmezők, a listaelemek, a menük és így tovább. 13

System Application Architecture

124

Fejrész

Objektum-felügyelő

A Formszerkesztő

Itt lóg ki a kódszerkesztő ablak alja

17. ábra A Delphi keretrendszer

A Delphi fejlesztőkörnyezet négy fő területből (ablakból) áll: a fejrészből, ami a menüt, az eszközöket és a komponenseket tartalmazza, a bal oldalt látható objektum-felügyelőből (Object Inspector), a formszerkesztő ablakból és a formszerkesztő által részben eltakart kódszerkesztőből. Utóbbi úgy válik láthatóvá, ha a formszerkesztő alól "kilógó" részére rákattintunk.

125

·

Reopen:

A legutóbb használt néhány projekt ill. fájl nyitható meg innen

·

Save:

Elmenti az aktuális fájlt

·

Save As...:

Másik név alatt menthetjük el a fájlt

·

Save Project As...:

A projektet új néven menti el

·

Save All:

A projekthez tartozó összes fájlt elmenti.

·

Close:

Bezárja az aktuális fájlt. Ha még nem volt elmentve, rákérdez a mentésre

·

Close All:

Az összes megnyitott fájlt bezárja. A mentetlenekre rákérdez

Bármilyen száraznak is tűnhet a következő rész, a menük rövid ismertetésével fogjuk kezdeni a bemutatást.

·

Use Unit…:

A unitok kezelését könnyíti meg (ha több unitból áll a projekt)

·

Print…:

Nyomtatás

A Delphi menüje is helyzet érzékeny, azaz esetenként a legördülő menülista tételei attól is függnek, hogy éppen milyen műveletet végezünk.

·

Exit:

A Delphiből való kilépés egyik lehetősége

A formszerkesztő és a kódszerkesztő ablakok között az F12-es billentyűvel lehet váltani. Az F11-es billentyűvel pedig e két ablak és beleértve az objektum-felügyelő között lehet váltani.

A Delphi munkaterület fejrésze Itt csak a legfontosabb elemeket mutatjuk be és meg kell elégedniük egy-egy programocska elkészítésének bemutatásával. Az ajánlott irodalom résznél olyan könyveket talál, amelyek egy részét jómagam is elolvastam. Ha a könyvnek megjelent újabb kiadása a magasabb verziószámú fejlesztőrendszerről, akkor természetesen azt ajánlom. A menü

Edit menü ·

A fálj menü ·

New...: A menüpont kiválasztásakor egy összefoglaló jellegű, többlapos párbeszédablak jelenik meg (New Items), ahonnan új projektet, vagy más elemeket választhatunk. Általában van egyszerűbb módszer is...

Mielőtt a munkát folytatnánk, nézzük meg a további menüpontokat, amiket a fájl menüben találunk a New…-en kívül. Természetesen itt is érvényes, nem csak a Turbo pascalban, mondhatnám, hogy az IBM SAA-CUA koncepciót követi, ha a menüpont neve után három pontocska áll, akkor az azt jelenti, hogy folytatás következik. Ez általában egy párbeszédablakban vagy egy üzenő ablakban nyilvánul meg.

18. ábra - File menü

A további menüpontok:

·

Cut:

Kivágás

·

Copy:

Másolás

·

Paste:

Beillesztés

·

Delete:

Törlés

·

Select All:

A szövegszerkesztő ablak minden sorát kijelöli (formszerkesztőben minden elemet)

·

Align to Grid:

Rács, amelynek segítségével pontosan helyezhetők el a komponensek a formokon

·

Bring to Front:

A kijelölt objektumot a többi fölé helyezi, ...

·

Send to Back: ...

… ez pedig alá.

·

Align:

Párbeszédablak segíti a precíz komponens-elhelyezést

·

Size:

A kijelölt objektum pontos méreteit állíthatjuk be

·

Scale:

A komponens nagyíthatóságáról lehet intézkedni

·

Tab Order:

Egy formon azt lehet beállítani, hogy a Tab billentyűvel milyen sorrendben lépkedjük végig a komponenseken

·

New Application:

Innen egyszerűbben nyithatunk új projektet

·

New Form:

Új form hozzáadása

·

New Frame:

Új keret hozzáadása

·

·

Creation Order:

A nem vizuális komponensek létrehozása

Open...:

Létező unitot vagy formot nyit meg, amivel egyúttal a projektünkhöz hozzá is adhatjuk

·

Lock Controls:

A form elemeinek rögzítésére való

·

Object:

A formra helyezett OLE objektum szerkesztése

· 126

Undelete vagy Undo és Redo: A szokásos visszavonás-visszaállítás pár

Open Project…:

Projekt megnyitása

127

Search menü

A Fő ablak

·

Find...:

Szöveget kereshetünk vele. A megnyíló párbeszédablakban megadható a szöveg. Megadható, hogy megkülönböztesse-e a kis- és nagybetűket (Case sensitive), vagy hogy csak teljes szavakat kell-e keresni (Whole words only). Megadható a keresés tartománya, azaz hogy a teljes szövegben, vagy csak a kijelölt blokkban kell-e keresni (Global, Selected), a keresés iránya előre, vagy vissza (Forward, Backward) történjen stb.

·

Replace...:

Szöveget cserélhetünk, a Text to find sorba a keresendő, a Replace with sorba a csereszöveget kell beírni. A keresési funkciónál megismert beállítási lehetőségek itt is megvannak. A Replace all bekapcsolásával valamennyi előfordulást automatikusan lecseréli.

·

Search Again:

·

Incremental Search: Ez is keresés, de begépelés közben a keresett szöveghez ugrik.

A keresési, illetve csere művelet ismételhető.

Run menü ·

Run:

·

Step Over és a Trace Into az F8 és az F7 már a TP-nél is ismertetett módon működik. A program lépésenkénti végrehajtására, azaz nyomkövetésre való. Ha az F8-cal lépkedünk a keretrendszerben, akkor a saját eljárásokat egyetlen utasításnak tekinti és végrehajtja, ha F7-tel, akkor azokba is belemegy és lépésenként azokat is ellenőrizhetjük a segítségével.

Futtatja a programot. Ha a program szövege megváltozott, akkor előbb automatikus fordításra és szerkesztésre kerül sor (jegyezzük meg az F9 billentyűt!).

Eszköztár

Szélességállító sáv

Elempaletta

Palettaváltó fül

19. ábra A Delphi főablaka

Ha a képernyőfelbontás miatt nem fér el az összes a palettaváltó fül, akkor a jobboldalán találunk egy balra és egy jobbra mutató nyilacskát, amivel gördíthetjük a füleket. Az főablak címsorában a „Project1” felirat olvasható a Delphi 5 után. Emlékezzenek rá, hogy a TP-ben a „NONAME00.PAS” volt olvasható. Ez itt a projekt neve. Itt a Delphiben már nem egyszerűen egy „PAS” fájlról van szó, amikor programot fejlesztünk, hanem egy gyűjtőnévként használt Projekt-ról.

Paletta fül gördítése 20. ábra

Ez itt azt jelenti, hogy amikor egy új programot fejlesztünk, akkor a főprogram, az OOPnak megfelelően inicializálja a programot, futtatja, majd befejezi. Ennyit tesz, csak ez a dolga. A többi modul már unitokban van kihelyezve. Azaz minden form, és program modul egy-egy különálló unitban van. mint ezt majd látni fogjuk a mentésnél is. A Delphi nagyon megkönynyíti a programozó munkáját, és a kezdőknek, ha evvel nem is foglalkozunk, csak követjük majd e modulfüzet utasításait, akkor lehet 4GL-es sikerélményük. Ha követik a modulfüzet utasításait, akkor látni fogják, hogy (első ránézésre) szinte gyerekjáték egy program megírása. Az eszköztár A főablak baloldalán található gombcsoport azokat a funkciókat tartalmazza, amiket egyébként menüből is meghívhatunk, de innen gyorsabb a funkció elérése. Ha az eszköz felett időzünk az egérkurzorral, akkor egy kis címkében megjelenik a gomb funkciója illetve, ha tartozik hozzá gyorsbillentyű, akkor zárójelben annak a neve is, mint pl.: a mentés a Ctrl+S. Az eszköztár nyomógombjai kísértetiesen hasonlítanak a Wordnél megszokott gombokra, de kiegészülnek újabbakkal is. Így ez sem lehet annyira idegen a kedves Olvasónak, mert e modulba való belépés előfeltétele volt.

128

129

Az eszköztár gombjain, ha végigfutnak egérrel és időznek egy picikét, hogy a címke megjelenjen, akkor a következőkkel találkozhatnak: Az első sorban

Az elempaletta

21. ábra Az eszköztár

·

New

Ugyanaz mint a fájl menüben a New…

Nézzük az elempaletta főbb részeit.

·

Open

Megnyit egy formot vagy unitot

A Paletta és a palettaváltó fülei

·

Save

Elment egy kiválasztott formot vagy unitot

·

Save all

Elmenti a projektet

·

Open project

megnyit egy projektet

·

Add file to project

Hozzácsatol a projekthez egy már meglévő formot vagy unitot.

·

Remove file from project

Eltávolítja a kiválasztott formot vagy unitot a projektből.

·

Help contents

Kézikönyv tartalomjegyzék (A súgó)

A második sorban

130

Az elempalettán található nyomógombok az ablakok tervezését segítik. A kiválasztott elempaletta gombjára kattintva, majd az ablakra kattintva az elem az ablakra kerül. A paletták felsorolásánál csak a mintaprogramjainknál felhasználtakat mutatom be, mert a rendelkezésre álló paletta nyomógomboknak pusztán csak a végignézése is már komoly időt vesz igénybe.

·

View unit

A használt projekt illetve unitok listája, ha nincs megnyitva a kódszerkesztőben azonnal elérhetővé teszi

·

View form

Csak a formok listáját mutatja meg

·

Toggle form/unit

Az F12-es billentyűnél már ismertettem. Vált a formszerkesztő és kódszerkesztő között.

·

New form

Egy új form-ot szúrhatunk az alkalmazásunkba

·

Run

A programunk futtatása

·

Pause

Futás megállítása egy pillanatra

·

Trace into

Lépésenkénti végrehajtás az eljárásokba is belelép.

·

Step over

Lépésenkénti végrehajtás külön nem lép be az eljárásokba, hanem egyben lefuttatja azokat

22. ábra A paletta Mindegyik fül alatt más-más komponensek találhatók. Viszont, ha megnézzük a legelső gombot, az a nyíl eszköz. Ez arra való, hogy egy elemet kiválasszunk. Mik ezek a komponensek? Adott feladatra tervezett elemek, amelyeket Object Pascal-ban írtak meg, s amelyek forráskódjához a Delphi bizonyos verzióiban hozzá is férhetünk. A komponenseket a nevük elé írt T betűről ismerhetjük fel. A komponenseket az űrlapon (formon) helyezhetjük el. Maga a form komponens neve TForm, a ráírt szöveg TLabel, a ráhelyezett nyomógomb pedig TButton stb. A Standard – szabványos elemek Itt a leggyakrabban használt elemek találhatók meg. mint például a menü, a felbukkanó menü, a címke, a szerkesztő mező, az egyszerű feljegyzés szövegdoboza, a nyomógomb, jelölőnégyzet, a választó kör, a lista, a legördülő lista, a csúszka a csoportosító elem, és így tovább, hogy néhányat emeljünk ki. Az „Additional” egyéb elemek között megtalálható a képes nyomógomb, a védett beviteli mező, a geometrikus rajz, az eszköztár nyomógomb, a kép beszúrása, és még rengeteg más elem. Az objektum-felügyelő

23. ábra Az objektumfelügyelő

A Delphi következő ablaka az objektum-felügyelő (16. ábra). Ez az elemek gyors beállítására és az eseménykezelő rutinok félautomatikus elkészítésére, hozzárendelésére szolgál. Használatát, az elemekkel együtt a modulfüzet következő részeiben fogjuk tárgyalni a mintaprogramok elkészítésénél.

131

Az ablak Az ablak a formszerkesztő ablak. A Delphi az ablakokat helyezi előtérbe. A fejlesztés gyakorlatilag ezek kialakí-tásával és viszonylag egyszerű programozásból áll. A forrásszerkesztő ablak Az egyes modulok forrásnyelvi kiegészítései a forrásszerkesztő ablakban lehetséges. Mint már említettük, úgy is nézhetjük a programokat, hogy minden program egyforma, csak az egyedi dolgokat, különbségeket kell leprogramozni. Ebben az ablakban, csak a létrehozott ablakok 24. ábra A forrásszerkesztő egységeinek, elemeinek a forráslistája jelenik meg. A többi tulajdonképpen rejtve marad a programozó elől, de ez nem feltétlenül van így. Ha megfigyeljük egy új projektnél, a forrásablakban előre meg van már írva az unit váza. Ha készítjük a mintaprogramokat, akkor időnként kapcsoljunk át ide és nézzük meg, hogy hogyan változik a programunk forrása.

1. FELADAT Ha elindította a Delphit, akkor most zárja be a fájl menü Exit parancsáva. ha rákérdez a mentésre, akkor a „Nem”-re kattintson. Ha kész a program leállítása, akkor indítsa el ismét a már ismertetett módon, hogy tiszta lappal induljunk a nagy útra. Hívjon meg egy intézőt (Win+E). Hozzon létre egy könyvtárat a „C:\Delphi_Munka” néven és helyen. Ebben hozzon létre egy „elso” nevű könyvtárat, majd zárja be az intézőt. Most a Delphi fájl menü „Save all” menüpontra kattintson. Mentsen el mindent, természetesen a fájl típusánál figyeljen arra, hogy éppen mint ment. Azaz ha unitot ment, akkor annak megfelelő nevet adjon, ha projektet, akkor annak megfelelő nevet adjon. Egyszerű programoknál az unit neve lehet az amit felkínál, csak a projektnek illik a programra jellemző nevet adni. Most adjon a projektnek „elso” nevet. Igen, jól olvassa a kedves Olvasó, ékezet nélkül írtam a fájl nevét. ha ez megvan, akkor ugorjon át a következő oldalra és válaszoljon az önellenőrzés kérdéseire, majd a következő kompetenciánál máris elkezdünk egy egyszerűbb programot összerakni és írni Delphiben. Ha kész, akkor zárja be a projektet a fájl menü „Close all” menüpontjával. Ezzel bezártuk a projektet. A következő kompetenciafejezetnél ezt fogjuk alapul venni. Ott megnyitjuk majd ezt a projektet és ebben fogjuk első programunkat elkészíteni.

A formok A Delphi alapeleme a Form vagy magyarosan fogalmazva az űrlap. Az űrlap komponens neve TForm. A Delphi indításakor kapott üres ablak egy TForm komponens, amelyen pontozott rács helyezkedik el. A rács segíti a munkánkat, a szükséges komponenseket elhelyezni az űrlapra, azaz megkönnyíti a komponensek pozícionálását. Amikor egy alkalmazást/programot készítünk először, ennek a TForm objektumot kell megszerkesztenünk a komponenseket elhelyeznünk majd a tulajdonságokat és eseménykezeléseket megadnunk. Minden komponensnek van neve. Azaz minden komponens egy önálló objektum, amire névvel hivatkoztunk majd. Az objektumok tulajdonságaira majd az objektum nevével és tulajdonságának a nevével tudunk majd hivatkozni. Ezeket a tulajdonságokat beállíthatjuk tervezési időben is és futási időben is értéket kaphatnak. Ha elhelyezünk egy címkét (Label) a Formunkra, akkor annak a Caption tulajdonságával tudjuk beállítani, hogy mit írjon ki a képernyőre, hogy hogyan jelenjen meg. De ezt futási időben is megváltoztathatjuk, ha a programunkban a következő utasítást adjuk majd ki: Label1.Caption := ’Szia kedves gazdám!’;

Ekkor a felirata megváltozik a „Szia kedves gazdám!”-ra. Ha az objektum-felügyelőben megváltoztatjuk a nevét „Címke1”-re, akkor a következőképpen kell a fenti sort megírnunk. Cimke1.Caption := ’Szia kedves gazdám!’;

132

133

Önellenőrzés

?

1. Mit tartalmaz az IBM SAA/CUA szabványa? ........................................................................................................................................................... ........................................................................................................................................................... 2. Milyen főbb ablakai vannak a Delphinek? ........................................................................................................................................................... 3. Mit tartalmaz a főablak? ........................................................................................................................................................... ........................................................................................................................................................... 4. Mi az objektum-felügyelő szerepe? ........................................................................................................................................................... ........................................................................................................................................................... 5. Mire való a form-szerkesztő ablak? ...........................................................................................................................................................

Válaszok 1. Mit tartalmaz az IBM SAA/CUA szabványa? Egységes felhasználói felületet minden alkalmazás számára. Megkülönböztetünk terminál, karakteres (pl: DOS) ablakos és grafikus programok egységes felületét. Mindez arra való, hogy ne kelljen mindig újat tanulni, ha más programmal dolgozunk. 2. Milyen főbb ablakai vannak a Delphinek? Főablak, objektum-felügyelő, form szerkesztő, kódszerkesztő. 3. Mit tartalmaz a főablak? Eszköztárat, komponenspalettát. 4. Mi az objektum-felügyelő szerepe? A kontrollok fejleztési időben való beállítását és a hozzájuk tartozó események szerkesztésének lehetőségét. 5. Mire való a form-szerkesztő ablak? Itt fejleszthetjük ki majdan megjelenő ablakokat. 6. Miért van neve egy kontrollnak? Hogy hivatkozni lehessen rá. 7. Megváltoztatható-e egy formra helyezett komponens neve? Meg. Például a Label1 átnevezése Cimke1-re. (Vigyázzunk! Ékezetes nevek használatát kerüljük.)

........................................................................................................................................................... 6. Miért van neve egy kontrollnak? ........................................................................................................................................................... 7. Megváltoztatható-e egy formra helyezett komponens neve? ........................................................................................................................................................... ...........................................................................................................................................................

134

135

3. Program készítése Delphiben A Delphiben fejlesztett program egy vagy több forrásnyelvi tárgykódú vagy más formátumú modulból állhat. Ezek összessége a projekt. A teljes projektállomány vagy más néven főprogram írja le a használt modulok hivatkozásait, és a program indítását végző igencsak rövid részt tartalmazza. Ezt a Delphi teljesen automatikusan elvégzi helyettünk. Az előző kompetenciafejezet végén az 1. feladatnál elmentettünk egy projektet. Most ezt nyissuk meg a Fájl menü projekt megnyitása (Open Project…) parancsával vagy a „Reopen”nél válasszuk ki a legutoljára használt projektet. Ha a megnyitást az eszköztár gombjával végezzük, akkor a megnyitás gomb melletti kis lefelé mutató nyílra kattinthatunk a legutoljára használt projekt megnyitásához. Most már készen is állunk a nagy munkára. Kattintsunk a Form1 tervező ablak közepére. Így kiválasztottuk azt. Most a Form1 ablak tulajdonságait tudjuk az objektum-felügyelő ablakban beállítani, illetve magán a Form1 ablakon is végezhetünk némi módosításokat. Méretezzük át az ablakot. Legyen egy picit kisebb, mint a jelenlegi. A címsoránál fogva helyezzük át egy kicsit jobbra és egy kicsit lejjebb. Most térjünk át az objektum-felügyelőbe és nézzük meg, hogy milyen tulajdonságait tudjuk beállítani a Form1 ablaknak. Az első, amit beállítunk az az ablak címe lesz. Ehhez válasszuk ki a Caption tulajdonságot és a szerkesztőmezőjébe írjuk be, hogy „Első programom” a „Form1” helyére. Figyeljük meg a Form1 ablak címsora megváltozott. Görgessünk lejjebb az objektum-felügyelőben amíg meg nem jelenik a „Height” vagy a „Width” tulajdonság. Most a Form1 ablakot méretezzük át és közben figyeljük a két érték valamelyikét. Vegyük észre, hogy azok folyamatosan változnak amikor az ablakot átméretezzük. Ez a két érték is az ablak egy-egy tulajdonsága. Azaz minden objektumnak, komponensnek, kontrollnak, amiből a programunk felépül rengeteg tulajdonsága van, ami meghatározza, hogy az adott dolog hogyan jelenjen meg a képernyőn, hogyan viselkedjen bizonyos események bekövetkezésekor, azaz milyen legyen. Azaz az alapbeállításaitól el lehet térni valamelyest a saját, egyéni ízlésünknek és a feladatnak megfelelően. Most helyezzünk egy nyomógombot a Formunk közepére. Ehhez válasszuk ki a „Standard” komponenspaletta „Button” gombját, (egy OK feliratú nyomógomb formájú ikon) majd kattintsunk a Form1 közepére. A gomb megjelent „Button1” felirattal. Tegyünk még egy gombot a „Button1” alá. Most fogjuk meg egérrel a „Button1”-et és vonszoljuk arrébb. Helyezzük át az ablakunk alsó széléhez és a másikat is e mellé. Most kattintsunk a „Button1”-re. Nézzük meg az objektum-felügyelőt. Kattintsunk a Form1 közepére, ahol nincs semmi, majd kattintsunk az első nyomógombra, amit a formra helyeztünk. 136

Elmondhatjuk, hogy az objektum-felügyelőben, azoknak az objektumoknak a tulajdonságai láthatóak és állíthatóak be, amelyikek éppen ki vannak jelölve a Formszerkesztő ablakon. Kattintsunk az első nyomógombra. Az objektum-felügyelőben most állítsuk be a gomb feliratát a Caption tulajdonságnál „Köszön” –re. A másik gombnak adjunk „Bezárás” feliratot. A „Bezárás” gombot válasszuk ki, ha még nem lenne kiválasztva és az objektumfelügyelőn most kattintsunk az „Events” (események) fülre. Itt tudjuk beállítani, hogy a gomb milyen eseményekre reagáljon.

Eseménykezelés Az eseménykezelés nem más, mint a felhasználó reakciója a program számára, ami eseményeket jelent, melyekre reagálni kell. Esemény például egy leütött billentyű, az egér gombjának a lenyomása. Az eseményekkel a felhasználó valamilyen műveletet akar végeztetni a programmal, amelyek feladata ezeket értelmezni, természetesen csak az értelmesekre, hasznosakra reagálni. Vannak olyan esetek, amikor bizonyos eseményekre semmilyen válasszal nem reagál a program. Az esemény további részekre nem bontható, azaz pl. a szerkesztés egy editor ablakban nem egy esemény, hanem események, billentyűleütések sorozata. Az eseményeket itt tudjuk kiválasztani az objektum-felügyelő ablak „Events” füle alatt, hogy pl. a nyomógomb, amit most a Formra helyeztünk mit is tegyen, amikor a felhasználó megnyomja azt. Milyen események lehetnek a nyomógomb-hoz? Természetesen a működéséből kifolyólag más 25. ábra Az első programunk az objektumfelügyelő és más kontrollokhoz, eseménykezelő fülével ahogy más tulajdonságok úgy más események is tartoznak. Mit is jelentenek ezek az események itt az objektumfelügyelőben. Például az OnClick esemény jelenti, ha a felhasználó rákattint a gombra, az OnContextPopup, ha a felhasználó a jobb egérgombbal kattint rajta, hogy a helyzet-érzékeny popup (felbukkanó) menüt kérje le és így tovább…

137

Nekünk most az OnClick eseményhez kell utasítást rendelnünk. Minden objektumnak, amit a Formra helyezünk van egy alapértelmezett eseménye, amit úgy is elérhetünk, hogy kétszer rákattintunk a gombra. Először az objektum-felügyelőn keresztül állítsunk be egy eseményt, hogy mit tegyen, hogy ha a felhasználó rákattint. Kattintsunk kettőt az OnClick szerkesztőmezőjében és máris a kódszerkesztő ablakában találjuk magunkat egy begin – end páros között, ahova begépelhetjük az utasításokat. Most gépeljük be azt, hogy Close;

Az utasítás, ami akkor fog bekövetkezni, amikor a felhasználó megnyomja a gombot, akkor a prograunk be fog záródni. Ezt az utasítást, egy már előkészített metódus törzsébe írtuk be. Láthatjuk, hogy milyen kevés programozással milyen sok mindent oldottunk meg. Gondoljunk csak bele, hogy mennyi mindent kellene leprogramoznunk a hagyományos eszközökkel, ha az egérkezléstől kezdve a gomb megnyomásának emulálásáig mindent le kellett volna programozni. De ezeket a standard dolgokat a Delphi biztosítja számunkra. Máris beigazolódott, hogy minden program egyforma, csak az egyedi esetek szerint kell módosítani, átírni, kiegészíteni a programokat. procedure TForm1.Button2Click(Sender: TObject); begin Close; end;

Egy pillantás még vessünk a metódusunk automatikus elnevezésére. TForm1.Button2Click-re. Ebből kiolvasható, hogy a Tform1-en van és a neve Button2, melynek a Clikk eseményét programoztuk le a begin – end blokkban. Neve van? Igen. Minden objektumnak van neve, amit a Delphi automatikusan megad, amikor egy komponenst a formra helyezünk. (Természetesen a Formnak is van neve: Form1) Jó, de akkor ez a név honnan tudható meg? Mire használható a neve? meg tudjuk-e változtatni a nevét? Nézzük ezeket szép sorjában. Az objektum neve az objektum-felügyelő Name tulajdonságából olvasható ki és ott is változtatható meg. Hogy mire használható? Amikor a programunk fut, akkor egy objektumra a nevével lehet hivatkozni. Akkor most futás közben változzon meg a „Bezár” gomb felirata „Szia”-ra. Először is meg kell tudnunk, hogy mi a neve a „Bezár” gombnak. Kattintsunk rá egyet, hogy kiválasszuk. Az objektum-felügyelőben keressük ki a tulajdonságoknál a Name tulajdonságát. „Button2” olvashatjuk. Erre kell majd hivatkoznunk. Most kattintsunk a „Köszön” gombunkra és az objektumfelügyelőnél az eseményekre. Ott az OnClick eseményt hozzuk létre, úgy hogy a szerkesztőmezőjében duplán klikkelünk az egérrel.

138

Most a következő programrészletet írjuk be a begin-end blokkba:. Button2.Caption := ’Szia’;

Mentsük el a projektet és futtassuk le a programot az eszköztáron található Run nyomógombbal vagy az F9-es billentyűvel. Futás közben nyomjuk meg a „Köszön” gombot és figyeljük meg, hogy mi történik a „Bezár” gombbal. A felirata megváltozott „Szia”-ra. Most nyomjuk meg a „Szia” gombot. Ekkor a programunk bezáródik és visszatérünk a hívó keretrendszerbe. Azért mert a gomb egy tulajdonsága megváltozott, azért még azt az eseményt fogja végrehajtani, amit parancsoltunk neki azt, hogy zárja be a programot (Close). Ezzel el is készítettük első Delphiben írt programunkat. Ugye nem is olyan nagy ördöngőség az egész. 1. FELADAT Készítsünk egy szemtelen, kiviccelő programot. A program írjon ki a képernyőre (formra) egy szemtelen kérdést és jelenítsen meg két nyomógombot. Az a nyomógomb, amelyikkel a kínos kérdésre jó választ tudnánk adni, az mindig tűnjön el akkor, amikor a felhasnáló föléje viszi az egérkurzort. A másik gombbal természetesen simán be kell zárni az ablakot (Close;). Megoldási javaslat: Helyezzünk három gombot egy formra és egy feliratot. A Felirat legyen a következő: Önnek 58-as lába van? Az „Igen” gombhoz rendeljük a bezárás parancsot (Close;). A másik két gombhoz a „Nem” szöveget, de az egyik gombnál a visible tulajdonságot állítsuk be False-ra. Ekkor ez futás közben nem fog látszani. Amikor a felhasználó a látható „Igen” gomb fölé viszi az egérkurzort, akkor az tűnjön el, azaz a visible tulajdonsága legyen False és a másik gombbé, ami eddig nem látszott azé legyen True. A másik gombbal is ugyanezt végezzük el, persze fordított esetre. Azaz, ha felhasználó föléje viszi az egérkurzort, akkor az tűnjön el és a másik jelenjen meg. Javaslom az onMouseOver esemény használatát. Csak ízelítőnek: Button2.Visible := False; Button3.Visible := True;

139

Önellenőrzés

?

1. Hogyan tud megnyitni egy elmentett projektet?

Válaszok

...........................................................................................................................................................

1. Hogyan tud megnyitni egy elmentett projektet? A File menü, Reopen-nel vagy az Open-nel.

2. Hogyan lehet megváltoztatni a Form címsorát?

2. Hogyan lehet megváltoztatni a Form címsorát? Form1.Caption := ’Másik címsor’;

........................................................................................................................................................... 3. Milyen utasítással lehet bezárni egy programot?

3. Milyen utasítással lehet bezárni egy programot? Close;

...........................................................................................................................................................

4. Mi az eseménykezelés lényege? A program reagálása a felhasználó eseményeire.

4. Mi az eseménykezelés lényege?

5. Mire használható az onClick esemény? Ha ráklikkel a felhasználó.

........................................................................................................................................................... ........................................................................................................................................................... 5. Mire használható az onClick esemény? ........................................................................................................................................................... ...........................................................................................................................................................

6. Mire használható a Name tulajdonság? Megváltoztatható-e? Hivatkozni lehet vele egy komponensre, objektumra. Igen. (Természetesen ezután az új névvel kell az objektumra hivatkozni.) 7. Mire való a „visible” tulajdonság? Az objektum láthatóságát kapcsolja ki és be.

6. Mire használható a Name tulajdonság? Megváltoztatható-e? ........................................................................................................................................................... ........................................................................................................................................................... 7. Mire való a „visible” tulajdonság? ........................................................................................................................................................... ...........................................................................................................................................................

140

141

4. Egy egyszerű Delphi alkalmazás elkészítése Elérkeztünk a nagy pillanathoz, hogy egy kicsit komolyabb programot írjunk. Hasonlóan fogom végigvezetni a kedves Olvasót Ez a feladat nem egy konkrét (úgymond valamilyen igényt kielégítő program lesz), hanem egy form-ra minél több komponenst fogunk felhelyezni és azokkal valamilyen feladatot elvégeztetni. Akkor most indítsuk el a Delphit. Első lépésben mentsük el a projektünket a c:\delphi_munka\gyakorlat_komponensekkel\ alkönyvtárába gyakorlat_komponensekkel néven. Először adjunk címet a formunknak. Kattintsuk a formon egy üres helyre, majd az objektum-felügyelőben a Caption tulajdonságnál állítsuk be a „Gyakorlat komponensekkel” értékre.

feliratot. Látható, hogy a „C” betűje alá van húzva. A „&” jel azt jelenti, hogy amelyik betű előtt szerepel a „&” jel, az lesz a feliratban aláhúzva. Vajon mire jó egy ilyen aláhúzás. Ha egy párbeszédablakot billentyűvel kezelünk, akkor a (baloldali) Alt+aláhúzott betűvel azonnal ki tudjuk választani az adott kontrollt (vezérlőelemet) az ablakon és nem kell a TAB-bal odáig lépkednünk. Ezzel egy kicsit meggyorsíthatjuk az ablakunk kezelését. Ha a fentiek szerint változtatjuk meg a Caption értékét, akkor most az „M” betű lett aláhúzva, tehát a gomb felirata a „Mégse” lett. Mivel a gombunk kind tulajdonságát átállítottuk bkClose-ra így ennek a gombnak a megnyomás eseményével most nem kell foglalkoznunk. Ha most lefuttatjuk a programunkat és megnyomjuk a „Mégse” gombot, akkor a program bezáródik. A két gombot helyezzük el esztétikusan a formon, körülbelül középre, szépen egymás mellé. Ha szükséges, akkor méretezzük át egy picit a „Page Control”-t vagy a formunkat, hogy a gombjaink szépen, esztétikusan elférjenek. Most válasszuk ki az „Első fül”-et, kattintsunk rá. Majd A komponenspalettáról egymás után válasszuk ki és helyezzük el az ábrán látható komponenseket a formunkra.

Egy picit méretezzük át a formunkat a jobb alsó sarkánál fogva valamivel nagyobbra, hogy jól elférjenek a különböző kontrollok a képernyőn. Állítsuk be a Position tulajdonságát „poScreenCenter”-re, ami azt jelenti, hogy az ablak, amit tervezünk a képernyő közepén és nem a tervezés helyén fog megjelenni futás közben. Most kattintsunk a Win32 fülre a komponenspalettán és válasszuk ki a PageControl komponenst, majd kattintsunk a formunkra. Ekkor egy téglalapnak látszó eszközt helyez el a Delphi a formra. A téglalapot a közepénél fogva mozgassuk a formunk bal felső sarkába. A téglalap jobbalsó sarkánál fogva pedig méretezzük át a formunk jobb széléig és a magasságát is úgy állítsuk be, hogy a formunk alján maradjon körülbelül egy 2 centiméteres üres hely. A formon apró pontocskák láthatók, ezek mint egy mágnesként viselkedve, vonzzák a komponenseket, ha szükséges, akkor a formunkat egy picit méretezzük szűkebre, hogy ugyanannyi hely legyen a Page Control jobb oldalán is mint a baloldalon látható. Ennek a Page Controll-nak a közepére, jobb egérgombbal kattintva a popup menüből kérjünk egy új lapot a „New Page” menüponttal. Most megjelenik egy új lapfül ezen a téglalapon. Kattintsunk a „nagy téglalap” közepére és a Caption értékét írjuk át „Első fül”-re. Adjunk hozzá még két lapfület a komponenshez, melyek feliratát rendre „Második fül” és „Harmadik fül”-re nevezzük el. A form alsó két centis szabad helyére tegyünk az „Additional” fülről „BitBtn” komponenst. Ez egy bitképes nyomógomb (bitmap button). Ez a nyomógomb legyen az „OK” gomb. A Kind (mi féle?) értékét állítsuk be „bkOK”-ra. Ekkor a felirata automatikusan „OK” lesz és megjelenik egy zöld pipa is a gombon, ami egyébként a jóváhagyás, a nyugtázás jelképe. Az „OK” gomb ebben az esetben egy alapértelmezett gomb lett, amit egyéb esetben a Default tulajdonságnál lehet beállítani (TRUE/FALSE). Most tegyünk még egy bitképet nyomógombot az „OK” gombunk mellé és annak a „Kind” értékénél válasszuk ki a „bkClosel” értéket. Látható, hogy a kind beállításával „Close”-re íródott át a gomb felirata, amit a „Caption”-nál változtassunk meg „&Mégse”-re. Vegyük észre, hogy a Caption-nál a Close” előtt megjelenik egy „&” jel. Nézzük meg a Close gomb142

ScrollBar

TrackBar 26. ábra - Az első lapfül a komponensekkel

A különböző komponensek nevét a formra való felhelyezéskor a fejlesztőrendszer automatikusan megadja és a Caption értékét is ennek megfelelően választja ki a Delphi.

143

Egy program természetesen nem hagyható így, ebben az állapotban, meg kell változtatni a feliratokat. Kattintsunk a megfelelő kontrollra és a Caption értékét változtassuk meg a következő ábrán olvashatókra. Az Edit1…Edit3 szerkesztőmezők képernyőre kiírt értékét a Text tulajdonságuk hordozza, így ott nem a Caption-t, hanem a Text értékét kell átírni. Írjuk át a Label1, Label2, Label3 értékét „Vez.név:”, „Ker.név:” és „Teljes név:”-re. Kattintsunk a label1-re, majd a shift billentyűt nyomvatartva pontosan kattinsunk a Labe2-re és label3-ra. Így együtt kijelöltük őket. Most az Edit menü, Align… -ra. Ez az igazítás párbeszédablakot nyitja meg. A kijelölt komponenseket most igazítsuk horizontálisan jobbra a „Right sides” választó kör kiválasztásával, majd nyomjuk meg az OK gombot. Még mindig ki vannak jelölve a Label-ek. A Ctrl+mozgató nyilakkal finoman tudjuk mozgatni a kijelölt három feliratot. A „Memo1” sorait a Lines tulajdonságban tudjuk beállítani tervezési időben. Kattintsunk rá az objektumfelügyelőben és a tulajdonság értéke melletti „…”–os (három pontos) picinyke gombocskára. A megjelenő szerkesztőablakban a szövegszerkesztés szabályainak megfelelően töröljük ki a beírt szöveget. Íme a minta, amely szerint a feliratokat állítsuk be:

A „Vez.név:” és a „Ker.név:” az a mező amelybe majd beírjuk egy vezetéknevet és egy keresztnevet. A teljes név az amelyben majd megjelenik a teljes név az előző két mező szerint. A „Csoport 1”-es csoportban lévő „1. kérdés?” vagy másodikkal szeretném szemléltetni, hogy oda a valós életben bármilyen kérdés szerepelhet, vagy bármilyen olyan felirat, amire igennel vagy nemmel lehet válaszolni. Azaz a bejelölt állapota jelentheti az IGEN választ és a nem bejelölt a NEM választ. A választóköröknél, mint tudjuk csak egy lehet bejelölve az öszszes közül, ezért is van az őket csoportba foglaló keret. Mindegyik csoporthoz tartozik egy nyomógomb, amivel majd a megfelelő értékeket kiíratjuk a Memo1-be. A következő két gördítő sáv a ScrollBar és a TrackBar, melyekkel százalékosan tudunk értéket beállítani és a hozzájuk tartozó gombbal ki is tudjuk íratni az értéket. Ami eddig kimaradt: Az „Edit3” szerkesztőmező Enabled (engedélyezett) értékét tiltsuk le False értékkel. A RadioButton1 („A kérdés?” „Igen” válasza) választókör Checked (bejelölt) értékét állítsuk be True-ra így az bejelölt lesz. A programozás: Először az „OK” gomb megnyomásakor történő eseményt írjuk meg a már ismert módon. Kattintsunk rá kétszer és a megjelenő kódablakban a Begin – End közé írjuk be a Close; parancsot. Ha most lefuttatjuk a programunkat (F9), akkor figyeljük meg az Edit3 mező engedélyezett (Enabled) tulajdonságát. Futás közben nem tudjuk szerkeszteni, mert bele sem tudunk kattintani. Azaz a mező csak olvasható. Ezt a mezőt majd a hozzátartozó nyomógombbal fogjuk feltölteni értékkel. Akkor most menjünk szépen sorba a nyomógombokhoz tartozó programrészletek megírásával. A „Button1”-re kattintsunk duplán és írjuk be a következőt: begin Memo1.Lines.Add(Edit1.Text); Edit1.Text := ''; Edit1.SetFocus; end;

Ez a három sor azt jelenti, hogy a Memo1 sorait a Lines tulajdonságával szeretnénk valamit csinálni. Az Add metódus, az amely hozzáad egy sort, amit a neki paraméterként megadunk. Jelen esetben az Edit1 szerkesztőmezőbe írt értéket, amelyet (már tudjuk) a Text tulajdonsága tartalmazza, adjuk hozzá a Memo1 az utolsó sora után. Ezt az értéket közvetlenül adtuk át az Add metódusnak. 27. ábra - Az első lapfül a képernyőre beállított komponensekkel

A második sor az Edit1 tartalmát változtatja meg üres sztringre. Azaz kitörli a tartalmát.

A nyomógombokkal egy picit most zavarban lehetünk. A „>>” jelenti majd, hogy az adott kontroll változtatható tulajdonságát majd írja be a jobboldalon látható nagy szövegsorokat megjelenítő „Memo1”-be.

A harmadik utasítás az Edit1-et helyezi a fókuszba. Ezt úgy vesszük észre, hogy a kurzor a gomb megnyomása után benne villog, nem kell külön odakattintani.

144

145

Most legyen az a feladat, hogy csak akkor lehessen megnyomni a gombot, ha van írva valami az Edit1-be, ha üres, akkor legyen letiltva a gomb.

procedure TForm1.Button4Click(Sender: TObject); begin

Az első lépés, hogy letiltsuk a Button1-hez való felhasználói hozzáférést. Azután az Edit1 valamelyik eseményét kell erre beállítanunk, hogy figyelje önmagát, és ennek függvényében engedélyezze vagy tiltsa a Button1-et.

Memo1.Lines.Add('-----');

A megoldáshoz, kattintsunk a Button1-re. Az Enabled tulajdonságát állítsuk False-ra. Itt már tervezési időben tiltjuk a gombot.

else

Most kattintsunk az Edit1 mezőre majd az objektum-felügyelőnél az események fülre. Ott kattintsunk duplán az onChange esemény szerkesztőmezőjére, hogy az Edit1 szerkesztőmezőben történő változásokat azonnal nyomon tudjuk követni. Az eseményhez tartozó kódrészlet a következő:

Memo1.Lines.Add('1. kérdés: BEJELÖLVE') Memo1.Lines.Add('1. kérdés: NINCS BEJELÖLVE'); if CheckBox2.Checked Then Memo1.Lines.Add('2. kérdés: BEJELÖLVE') else Memo1.Lines.Add('2. kérdés: NINCS BEJELÖLVE');

procedure TForm1.Edit1Change(Sender: TObject); begin if Edit1.Text = '' Then Button1.Enabled := False else Button1.Enabled := True; end;

Ha a mező Text tulajdonsága, azaz a beírt szöveg értéke nulla hosszúságú sztring, akkor a Button1 legyen letiltva, ha nem üres sztring, azaz van valamilyen szöveg a mezőben, akkor legyen engedélyezve a Button1-es gomb. A következő kódrészletben figyeljük meg, hogy az else után egy begin áll. Azért van szükség erre, mert, ha minden rendben van, akkor két utasítást kell végrehajtani és ezeket foglalja csoportba a begin-end páros. procedure TForm1.Button3Click(Sender: TObject); begin if ((Edit1.Text = '') Or (Edit2.Text = '')) Then MessageDlg('Hiányzó vezeték- vagy keresztnév!', mtWarning,[mbOk], 0) else begin Edit3.Text := Edit1.Text + ' ' + Edit2.Text; Memo1.Lines.Add(Edit3.Text); end; end;

Az újdonság a kódrészletben a MessageDlg függvény. Ha a kódszerkesztőben a kurzor épp fölötte parkíroz, akkor nyomjunk F1-et, hogy a további lehetőségeiről olvassunk. Most nézzük meg a jelölőnégyzeteket. A hozzájuk tartozó gombbal írassuk ki a Memo1-be, hogy épp milyen az állapotuk. A kódrészlet a következő:

146

//Egy választóvonal húzása

if CheckBox1.Checked Then

if CheckBox3.Checked Then Memo1.Lines.Add('3. kérdés: BEJELÖLVE') else Memo1.Lines.Add('3. kérdés: NINCS BEJELÖLVE'); end;

A fenti kódban találkozunk egy új jelöléssel „//” dupla perrel bevezetve. A Delphiben a megjegyzéseket íly módon is be tudjuk vezetni. Azaz a „//” jel mögötti rész megjegyzésként van értelmezve. Hasznos lehet ez, akkor is amikor próbálkozunk valamely utasítással és épp nem akarjuk végrehajtatni, akkor egyszerűen a sort elejére csak be kell írni a „//” jelet. A jelölőnégyzetek jelöltségét a Checked tulajdonsága tárolja. Ezt lehet lekérdezni és akár futás közben az értékét beállítani a következő utasítással pl.: CheckBox.Checked := True;

vagy CheckBox.Checked := False;

Gondolom, hogy az eddigi ismeretekre alapozva már nincs szüksége a kedves Olvasónak a kódrészlet elmagyarázására. Most jöjjenek a választókörök Mivel a RadioButton-ok (jelölőnégyzetek) csoportba vannak foglalva így a csoporton belül csak egyetlen egy körben lehet pötty. A kódrészlet hasonlóan fog alakulni, mint a CheckBox-oknál. procedure TForm1.Button5Click(Sender: TObject); begin Memo1.Lines.Add('-----'); if RadioButton1.Checked Then Memo1.Lines.Add('Rádiógomb: Igen'); if RadioButton2.Checked Then Memo1.Lines.Add('Rádiógomb: Nem');

147

if RadioButton3.Checked Then Memo1.Lines.Add('Rádiógomb: Talán');

Önellenőrzés

end;

Ha az első van bejelölve, akkor csak az első feltétel teljesül, ha a második, akkor csak a második és a neki megfelelő üzenet lesz kiírva. A TrackBar Mint láttuk minden kontrollnak van neve. Ennek az objektumnak a nevét is ki tudjuk keresni az objektum-felügyelőből a Name tulajdonságnál. A TrackBar értékét a Position mezője tartalmazza.

?

1. Melyik mező tartalmazza a TLabel képernyőn megjelenő feliratát? ........................................................................................................................................................... 2. Melyik tulajdonság tartalmazza a TEdit szerkesztőmezőbe írt szöveget? ...........................................................................................................................................................

procedure TForm1.Button6Click(Sender: TObject); begin Memo1.Lines.Add('A csúszka pozíciója: '+IntToStr(Csuszka1.Position)); end;

Egy kis magyarázatra szorul a kódrészlet. A Position típusa egész szám. Ezt át kell alakítanunk szövegessé. Ezt az IntToStr függvénnyel lehet. Ha elemezzük a függvény nevét, akkor könnyen rájöhetünk, hogy mi lehet az ellenekező konverzió (StrToInt). Most írjuk át a TrackBar1 nevét Csuszka1-re. A ScrollBar gombjához tartozó kódrészlet: procedure TForm1.Button7Click(Sender: TObject); begin

3. Hogyan lehet beállítani egy TCheckBox jelölőnégyzetet bejelöltre? ........................................................................................................................................................... 4. Milyen tulajdonságából olvasható ki a TracBar aktuális értéke? ........................................................................................................................................................... 5. Hogy lehet egy TMemo kontrollhoz új sort beilleszteni? ...........................................................................................................................................................

Memo1.Lines.Add('A ScrollBar pozíciója: '+IntToStr(Csuszka1.Position)); end;

Ez szinte teljesen ugyanaz, mint az előbbi.

6. Hogyan íratható be egy TMemo kontrollba három TRadioButton értéke?

Az eddigiekben az „Első fül”-re pakoltunk fel néhány komponenst. Most kattintsanak a „Második fül”-re és most ott fogunk dolgozni, illetve a „Harnmadik fül”-ön. A „Második fül” közepére tegyünk egy címkét (Label), majd a „Harmadik fül”-ön belül tegyünk egy Edit szerkesztőmezőt és egy nyomógombot. A nyomógomb felirata legyen „Átír” a szerkesztőmező tartalma legyen üres. Legyen az a feladat, hogy ha megnyomjuk a gombot, akkor a „Második fül”-ön lévő címke felirata legyen az, ami az újonnan felhelyezett szerkesztőmezőé. A nyomógombhoz tartozó kódrészlet a következő: procedure TForm1.Button8Click(Sender: TObject); begin Label5.Caption := Edit4.Text; end;

Most futtassuk le a programunkat és győződjünk meg róla, hogy jól dolgoztunk-e. Ha beírunk valamit a szerkesztőmezőbe és megnyomjuk a gombot, akkor válasszuk ki a „Második fül”-et. A beírt szöveg lett a címke (Label) felirata.

148

149

Válaszok

Eseménykezelés

1. Melyik mező tartalmazza a TLabel képernyőn megjelenő feliratát? Caption

Bevezetés

2. Melyik tulajdonság tartalmazza a TEdit szerkesztőmezőbe írt szöveget? Text 3. Hogyan lehet beállítani egy TCheckBox jelölőnégyzetet bejelöltre? CheckBox1.Checked := True;

4. Milyen tulajdonságából olvasható ki a TracBar aktuális értéke? Position 5. Hogy lehet egy TMemo kontrollhoz új sort beilleszteni? Memo1.Lines.Add(’Az új sor szövege’);

6. Hogyan íratható be egy TMemo kontrollba három TRadioButton értéke? … if RadioButton1.Checked Then Memo1.Lines.Add('Rádiógomb: Igen'); if RadioButton2.Checked Then Memo1.Lines.Add('Rádiógomb: Nem');

Ebben a kompetenciafejezetben az Olvasó megismerkedik az alapvető eseményekkel, kezelésükkel. A következő oldalakon ismertetésre kerül néhány, gyakran használt esemény. Tulajdonképpen, ha az Olvasó megoldotta a modulfüzet eddigi gyakorlati feladatiat, akkor elmondhatja, hogy már találkozott az eseményekhez rendelt programozással. Az eseményeket egyszerűbb példákon, kisebb feladatokon keresztül lesznek bemutatva. A tanulási feladatok elvégzése után a hallgató: · Ismerni fogja az esemény fogalmát. · Ismerni fogja az üzenet fogalmát · Képes lesz néhány gyakran használt eseményhez programkódot írni, és így teljesebb, összetettebb programot készíteni · Képes lesz megoldani néhány feladatot instruktori beavatkozás nélkül Rész célkitűzések 1. Az esemény-vezérelt programozás 2. Az üzenet (Message) 3. A TForm eseményeinek bemutatása

if RadioButton3.Checked Then Memo1.Lines.Add('Rádiógomb: Talán');

…

150

151

1. Az esemény-vezérelt programozás A Delphi keretrendszer célja, hogy alapvető vázat biztosítson a felhasználói programok megírásához. A programozónak csak arra kell öszpontosítania, hogy hogyan töltse fel tartalommal ezt a vázat. Eddigiekben megismerkedtünk néhány, a képernyőn megjelenő komponenssel és a alapvető kezelésükkel. Ez mondhatnám, hogy a képernyőn megjelenő ablakok, komponensek egy általános program 80-90%-át teszik ki, de ezek a mögöttük lévő háttérprogramok nélkül nem sokat érnének, és ezekhez a különböző eseményekhez, melyekhez a programozó utasításokat rendel. Ilyen esemény például, amikor a felhasználó az egérrel kattint, az ablakot mozhatja, a szerkesztőmezőbe beír valamit vagy javít, töröl; esetleg egy listadobozból választ egy tételt. Ebben a fejezetben az a célunk, hogy bemutassuk, hogy hogyan lehet programunkat az események köré csoportosítva felépíteni. Először is meg kell ismerkednünk az eseményvezéreltség fogalmával. Egy hagyományos Pascal programban erre egy ciklust készítenének, hogy az figyelje történt-e valamilyen esemény. A felhasználó kattintott-e az egérrel vagy lenyomott-e egy billentyűt. Nézzünk, akkor egy ilyen példát. Repeat C := ReadKey; Case C Of

lezáródni, elmozdulni és aktivizálódni etc… A menü tudja, hogyan kell megnyílni, kommunikálni és lezáródni. A vezérlő gomb tudja, hogy hogyan kell aktivizálódnia, kommunikálni a többi gombbal és szinét megváltoztatni. Egy inaktív ablak aktívvá tudja tenni önmagát mindenféle programozói beavatkozás nélkül. Az események természete Az eseményeket úgy kell elképzelni, mint egy kis információs csomagokat, amelyek által a meghatározott esetekre a felhasználói programoknak reagálniuk kell. Az eseményeket nem lehet további kisebb részekre bontani. Ha például a felhasználó begépel egy szót, akkor az nem egy esemény, hanem események sorozata, sok-sok gomnyomásból álló események sora. Az események tulajdonképpen semmilyen műveletet nem végeznek csak információt továbbiítanak az objektumainknak. Az események ezért rekord struktúrában tárolódnak.

2. Az üzenet (Message) Az üzenet egy rekord, melyet a Windows rendszer állít elő, és adatai az őt kiváltó esemény típusára, paramétereire vonatkoznak. Nézzünk egy példát, milyen üzenet keletkezik akkor, amikor kattintunk az egér bal gombjával vagy amikor lenyomjuk az „A” billentyűt. Az esemény átalakítása üzenetté: Az egér gombjának lenyomása:

Azonosítója: WM_LBUTTONDOWN Adatok: X,Y pozíció, a többi egérgomb és a Ctrl és a Shift billentyűk állapota

Az „A” betű:

Azonosítója: WM_KEYDOWN Adatok: a billentyű virtuális kódja ($0041) az ismétlések száma (folyamatos lenyomás után) a billentyűzet helyzeti kódja (scan code) Az Alt állapota, etc…

’r’ : Rajzolas; ’s’ : Szerkesztes; ’k’ : Kilep := True; End; Until Kilep;

Az eseményvezérelt program szerkezete sem különbözik lényegesen e példától. Egy interaktív program is e fenti technikát használja. A Delphi alkalmazásban sem kell a felhasználó inputját külön leprogramozni, hanem ezt elvégzi helyettünk a keretrendszer. Azaz a programunk összerakja a bejövő adatokat egy esemény rekordba. Ezt eseménynek nevezzük.A progrtamunk ezt az eseményrekordot továbbítja a programban a megfelelő objektumhoz, kontrollhoz. Ez azt jelenti, hogy a programozónak csak azt kell tudnia, hogy hogyan bánjon a lényeges input adatokkal, és nem kell a bejövő adatok közül keresgélni a megfelelőt. Tegyük fel, hogy a felhasználó rákattint egy inaktív (háttérben lévő) ablakra. A programunk beolvassa az egérműveletet, melynek a felhasználásával felépíti az esemény rekordot, majd ezt az esemény rekordot továbbítja az inaktív ablakhoz. Az ablak az előtérbe kerül és megrajzolja a képernyőt az ablak beltartalmával, azaz megjelenik a másik ablak(ok) előtt. A megjelenített objektumok (ablak, form, gomb, lista és minden ami a képernyőn megjelenik) képes a felhasználói inputot önálóan lekezelni. Az ablak tudja, hogyan kell megnyílni,

152

Az üzenetek típusai Minden eseményből minimum egy üzenet képződik a Windows rendszer bejáratánál. Ezeket külső üzeneteknek nevezzük, mivel valamelyik perifériáról érkeznek a rendszerbe. Ezek kétfélék lehetnek: helyzetiek vagy fókuszáltak. Helyzeti üzenet akkor, ha fontos jellemzője a pozíciója a képernyőn pl. az egérrel való kattintás. A fókuszált üzenetre nem jellemző a pozíció, pl. egy lenyomott billentyű esetén a billentyű kódja érdekel minket és nem az egér pillanatnyi koordinátája. Üzenetek a rendszeren belül is keletkezhetnek például akkor, amikor elmozdítunk egy ablakot, akkor pl. az ablakot ismét meg kell rajzolni. A fókuszált üzenetet a fókuszban lévő ablak fogja megkapni és feldolgozni úgy, ahogy azt az ablak tervezői elgondolták.

153

A helyzeti üzenetet általában az az alkalmazás, illetve az alkalmazásnak az az ablaka kapja, amelynek a felületén történt.

3. A TForm eseményeinek bemutatása

?

Az üzenetek feldolgozása Az előzőekben már bemutatásra került az eseményvezérelt programozás elve, ami nem más volt, mint egy ciklus, ami állandóan pörög és figyeli, hogy van-e valamilyen esemény amit le kell kezelni.

Azt már tudjuk, hogy az objektum-felügyelőnek két füle van. Az egyikben a komponensek tulajdonságait tudjuk beállítani, a másikban a hozzájuk tartozó eseményeket tudjuk leprogramozni.

A Windows-os programokban is minden szálban megtalálható egy „üzenetkezelő ciklus”. Feladata az, hogy kiolvassa a sorban álló üzenetet, majd továbbítsa ezeket a megfelelő ablakhoz. Pl.:

Indítsuk el a Delphit és a megjelenő új (még névtelen) projektben kattintsunk az üres Form közepére, hogy biztosan a hozzá tartozó tulajdonságokat és eseményeket lássuk az objektumfelügyelőben.

Repeat Üzenet kiolvasása a sorból Üzenet esetleges átalakítása Üzenet továbbítása a megfelelő ablakfüggvénynek Until amíg nincs vége az alkalmazásnak;

Minden ablaknak van minimum egy ablak függvénye, melyben feldolgozza a neki szánt üzeneteket. pl: Case Üzenet Of egér : Kattintás esetén; bill : Billentyűzet lenyomása esetén; End;

Röviden ennyit az eseményekről és az üzenetekről. A következő kompetenciafejezetben olvashatunk egy-két gyakrabban használt eseményről. A mintafeladatokon keresztül egy picit jobban elméllyedünk az eseményvezérelt programozásban. Majd röviden megismerkedünk néhány multimédiás komponens kezelésével, navigációjával.

Válasszuk ki az „Events” (események) fület. A gördítővel tudjuk gördíteni az események listáját. Amelyik eseményhez szeretnénk programkódot rendelni annak a szerkesztő-mezőjébe kattintsunk kettőt. A kódszerkesztőben már csak meg kell írnunk a megfelelő kódot. Nézzünk néhány eseményt: Amikor lefuttatjuk az alkalmazásunk, már akkor rengeteg esemény generálódik és ezek rendre a következők: OnCreate, OnShow, OnPaint, onActivate, (OnPaint, OnResize, OnDeactivate), OnCloseQuery, OnClose, OnDestroy. A zárójelben azok az események vannak, amik a már megjelent ablak, futó program esetén következnek be. A zárójel előtti szakaszban az ablak megjelenése előtti, a zárójel utáni szakaszban az ablak bezárását követő események olvashatóak. Például, ha a felhasználó az ablakot be kívánja zárni, akkor az onCloseQuery eseménynél még megkérdezhető, hogy tényleg be szeretné záni az ablakot vagy sem. itt még visszafordítható az ablak bezárása. Ha például egy log-ot (naplózást) szeretnénk elkészíteni a programunk futtatásáról, akkor az OnCreate eseményhez írjuk be azt a kódot, ami a program indításának időpontját rögzíti egy fájlba és az OnClose-ba írjuk, amikor bezárják a programot. Nézzük ezeket az eseményeket, egy picit részleteseben: OnCreate

: Inicializáláskor.

OnShow

: Megjelenéskor.

OnActivate

: Aktivizáláskor

OnPaint

: Újrarajzoláskor

OnDeactivate

: Az űrlap háttérbe kerülésekor következik be.

OnCloseQuery : Az űrlap bezárása előtt következik be. Itt még megakadályozható a bezárás.

154

OnClose

: Az űrlap bezárásakort következik be. Ebben az eseményjellemzőben beállíthatjuk az esemény kódját.

OnDestroy

: Az űrlap megszűnésekor következik be.

155

Önellenőrzés 1. Mit jelent az eseményvezérelt programozás? ........................................................................................................................................................... 2. Írjon példát, hogy hagyományos Pascal programban hogyan oldaná meg az eseményvezéreltséget?

Válaszok 1. Mit jelent az eseményvezérelt programozás? Az eseményeket úgy kell elképzelni, mint egy kis információs csomagokat, amelyek által a meghatározott esetekre a felhasználói programoknak reagálniuk kell. 2. Írjon példát, hogy hagyományos Pascal programban hogyan oldaná meg az eseményvezéreltséget? Repeat C := ReadKey; Case C Of ’r’ : Rajzolas; ’s’ : Szerkesztes; ’k’ : Kilep := True; End; Until Kilep;

3. Milyen típusai vannak az üzeneteknek? ........................................................................................................................................................... ........................................................................................................................................................... 4. Mit tartalmaz a Windows szálaiban az üzenetkezelő ciklus? Írjon egy-egy bemutató példát:

3. Milyen típusai vannak az üzeneteknek? Helyzetiek vagy fókuszáltak. Helyzeti üzenet akkor, ha fontos jellemzője a képernyőn a pozíciója pl. az egérrel való kattintás. A fókuszált üzenetre nem jellemző a pozíció, pl. egy lenyomott billentyű esetén a billentyű kódja érdekel minket és nem az egér pillanatnyi koordinátája. Üzenetek a rendszeren belül is keletkezhetnek például, akkor amikor elmozdítunk egy ablakot, akkor pl. az ablakot ismét meg kell rajzolni. A fókuszált üzenetet a fókuszban lévő ablak fogja megkapni és feldolgozni úgy, ahogy azt az ablak tervezői elgondolták. A helyzeti üzenetet általában az az alkalmazás, illetve az alkalmazásnak az az ablaka kapja, amelynek a felületén történt. 4. Mit tartalmaz a Windows szálaiban az üzenetkezelő ciklus? Írjon egy-egy bemutató példát: Repeat Üzenet kiolvasása a sorból Üzenet esetleges átalakítása Üzenet továbbítása a megfelelő ablakfüggvénynek Until amíg nincs vége az alkalmazásnak;

… Case Üzenet Of

4. Milyenesemény az OnDeactivate? Mire használható? ........................................................................................................................................................... ...........................................................................................................................................................

156

egér : Kattintás esetén; bill : Billentyűzet lenyomása esetén; End;

4. Milyenesemény az OnDeactivate? Mire használható? Az ablak háttérbe kerülésekor következik be.

157

Multimédia assetek kezelése 1. Multimédiás lehetőségek, hangok lejátszása Bevezetés Ebben a kompetenciafejezetben a kedves Olvasó megismerkedik majd a hangok és videók lejátszásával, valamint a Windowsos alkalmazások közötti kommunikációval Ami számunkra fontos lesz majd, hogy hogyan lehet majd a Windows MediaPlayer-ét beilleszteni egy Delphis alkalmazásba. Ha már megismerte az alkalmazások közötti kommunikáció néhány alapfogalmát; feltételezem, hogy könnyedén adaptálni tudja majd egy másik 4GL-es fejlesztőrendszer által nyújtott környezetben. A tanulási feladatok elvégzése után a hallgató: · Ismerni fogja a különböző alkalmazások közötti kommunkációt · Képes lesz hangot lejátszani elő- és háttérben egy Delphi alkalmazásból · Képes lesz videót lejátszani a Delphi alkalmazásból · Képes lesz egy MediaPlayert és egy OLE objektumot beilleszteni a saját alkalmazásába Rész célkitűzések 1. Multimédiás lehetőségek, hangok lejátszása 2. Az alkalmazások közötti kommunikáció 3. Multimédiás lehetőségek, videók lejátszása OLE konténerben

Ahhoz, hogy a multimédiás lehetőségeket ki tudjuk használni, természetesen a Windows alatt telepítve kell, hogy legyenek például a hangkártya és a videókártya driverek. A Windows egy erre a célra kifejlesztett API-val a Multimédia API-val támogatja a különböző multimédiás funkciókat, mint például a CD lejátszás, a hang a MIDI valamint a videó lejátszási lehetőségeket. A Delphi is egy különálló komponmenssel a Médialejátszó komponenssel támogatja a multimédiás eszközök használatát. Ennek az eszköznek a használata nem bonyolult. Mielőtt megnéznénk ennek a használatát, nézzük meg a számítógépünkből, hogyan tudunk hangokat kicsalogatni. A Windows alapértelmezett hangjai

Eddigiekben, ha a felhasználó figyelmét hanggal is fel szerettük volna hívni, akkor a számítógépbe épített pici hangszóróból kértünk egy dudaszót. A Delphiből a Windows API MessageBeep függvényét hívhatjuk meg. MessageBeep(0);

A Windows alapértelmezett hangjait meg is változtathatjuk a Vezérlőpult Hangok beállításainál.

28. ábra - Az alapértelmezett hangok beállítására szolgáló ablak a Windows vezérlőpultjában.

A paraméterül adott szám, ha 0 vagy –1, akkor a számítógép hangszóróját szólaltalja meg. A számok helyett használhatunk konstansokat is, melyek a következők:

158

mb_IconAsterix

Üzenetablak

mb_IconExclamation

Figyelmeztetés

mb_IconHand

Előugró menü

mb_IconQuestion

Kérdés

mb_Ok

Alapértelmezett hang 159

Ezek a konstansok a Windows alapértelmezett hangjai (a vezérlőpultban beállított hangok alapján). Annak megállapításához, hogy van-e telepített hangkártya-meghajtó a számítógépen egy multimédia függvényt használhatunk. if WaveOutGetNumDevs > 0 then MessageDlg('A hang használata támogatva van',mtInformation, [mbOk], 0) else MessageDlg('Nem támogatott a hang használata',mtError, [mbOk], 0);

Természetesen ez nem azt jelenti, hogy van hangkártya is a gépben, hanem csak azt, hogy van-e telepített meghajtó program. Ugyanis a sima beépített hangszóróhoz is léteznek meghajtóprogramok a szebb hangok kicsikarására.

érték pontos beállításával, többek között az egyik legismertebb az avi videófájlok és az audió CD. Ebben az esetben ki kell választani a dtAVIVideo vagy a dtCDAudio vagy a dtWaveAudio értéket. Ha beállítottuk a fájl nevét és az eszköztípust, akkor megnyithatjuk az eszközt vagy beállíthatjuk az AutoOpen tulajdonságát TRUE-ra és akkor automatikusan nyílik meg. A komponensen nem feltétlenül jelenik meg az összes gomb, amelyet az adott eszköz értelmezni tud. Három fontos tulajdonság vonatkozik a gombokra, a VisibleButtons a gombok láthatóságára vonatkozik, a ColoredButtons a gombok színes megjelenésére vonatkozik és az EnabledButtons, ami a gombok engedélyezését szabályozza.

A PlaySound API függvénnyel a nemcsak beépített hangokat játszhatjuk le, hanem tetszőleges wav fájlokat is.

A komponens sok eseményt lekezel. Nekünk szinte alig marad feladatunk egy jó program elkészítéséhez. Azért nézzünk meg egy-két eseményt. Például az OnClick, melynek az első paramétere megadja, hogy melyik gombot nyomták meg és a másodikkal az alapértelmezett működést kapcsolhatjuk ki.

Ha a hangfájlok ugyanabban a könyvtárban találhatók, mint a programunk, akkor a függvényünk így néz ki:

Az OnNotify esemény értesíti a kontrollt arról, hogy sikeres volt-e a gomblenyomással elindított folyamat vagy sem.

PlaySound(’hang.wav’,0,snd_Async);

… vagy … PlaySound(’MenuPopup’,0,snd_Async);

Ekkor a rendszerhangok közül hívunk egy felbukkanó menühöz rendelt hangot. (A programunk meghívja az MMSystem unitban lévő függvényt.) Az első paraméter a hang neve. A második paraméter megadja, hogy az előzőekben megadott adat hol található meg. A harmadik paraméterrel pedig a lejátszás folyamatát szabályozhatjuk. A fenti példában azt adtuk meg, hogy a zene elindítása után azonnal visszakapjuk a vezérlést és a hang lejátszása a háttérben folyik. ha az snd_Sync értéket adjuk meg, akkor a függvény csak akkor tér vissza, amikor a zene véget ért. Egy hosszú lejátszás megszakításához a PlaySound függvény újbóli meghívásával, egy nil értékkel hívjuk meg az első paraméterben: PlaySound(nil,0,0);

Ha folyamatosan szeretnénk a zenét lejátszani a háttérben, akkor a harmadik paramétert a következő módon kell megadni: PlaySound(’hang.wav’,0,(snd_Async or snd_loop)); A médialejátszó komponens

A médialejátszó kontroll szinte mindent képes lejátszani, amit a Windows médiakezelő felülete képes lejátszani. Evvel az eszközzel a multimédiás eszközöket magas szinten programozhatjuk. Az egyik legfontosabb tulajdonsága ennek a kontrollnak a DeviceType. Az alapértelmezett értéke a dtAutoSelect amely a FileName megadása után a fájl kiterjesztésének figyelembevételével automatikusan játsza le a megadott fájlt. De megadhatjuk pontosan a hangkezelőt is az

160

Az OnPostClick esemény vagy a lejátszás kezdetekor vagy a végén következik be, a Wait tulajdonság beállításától függően. Ezzel a tulajdonságal tudjuk szabályozni, hogy a lejátszás a háttérben történjen-e meg vagy sem. Videók lejátszása

Feltételezem, hogy minden számítógépen fel van telepítve a Microsoft Video for Windows, az új operációs rendszerekben már eleve benne is van így nem kell külön telepíteni. Ebben az esetben nem sokkal bonyolultabb egy videó lejátszása mint egy hangfájlé. Helyezzük a formunkra a médialejátszó komponenst, válasszuk ki a lejátszandó fájl nevét, AutoOpent állítsuk igazra és futtassuk le a programot. A play gomb megnyomásakor a Delphi egy különálló ablakban játsza le a videót. A Display értékénél adhatjuk meg, hogy hol jelenjen meg a a videó. Megadhatjuk önmagát is, ekkor a gombok helyett jelenik meg ami elég butácskán fest. Inkább tegyünk a formra egy Panel-t, vagy bármiylen ablak jellegű kontrollt és ezt adjuk meg a Display értékeként. A következő részekben olvashatunk egy másik megjelenítő objektumról is az OLE-ról. 1. FELADAT Kössze ösze a megfelelőkonstansokat a magyar megfelelőjükel: mb_IconAsterix

Figyelmeztetés

mb_IconExclamation

Kérdés

mb_IconHand

Alapértelmezett hang

mb_IconQuestion

Üzenetablak

mb_Ok

Előugró menü

161

?

Önellenőrzés

Válaszok

1. Hol tudja beállítani a Windows alapértelmezett hangjainak beállítását?

1. Hol tudja beállítani a Windows alapértelmezett hangjainak beállítását?

...........................................................................................................................................................

Vezérlőpulton belül a „Hangok és audióeszközök”-nél

2. Hogyan lehet lekérdezni, hogy van-e valamilyen hangkártya driver a gépre telepítve?

2. Hogyan lehet lekérdezni, hogy van-e valamilyen hangkártya driver a gépre telepítve? … if WaveOutGetNumDevs > 0 then MessageDlg('A hang használata támogatva van',mtInformation, [mbOk], 0) else MessageDlg('Nem támogatott a hang használata',mtError, [mbOk], 0); …

3. Hogyan lehet zenét a háttérben lejátszani, és hogyan lehet megállítani a lejátszást? … //Lejátszani a háttérben

3. Hogyan lehet zenét a háttérben lejátszani, és hogyan lehet megállítani a lejátszást?

PlaySound(’hang.wav’,0,(snd_Async or snd_loop)); //(Természetesen itt a hang.wav-nak az aktuális könyvtárban kell lennie) //Megállítani a lejátszást PlaySound(nil,0,0); …

4. Mire van szükség a videók és egyéb médiák lejátszására? Telepítve kell lennie a Microsoft Video for Windows-nak, de az újabb operációs rendszereken már telepítve van. 4. Mire van szükség a videók és egyéb médiák lejátszására? Telepítve kell lennie a Microsoft Video for Windows-nak, de az újabb operációs rendszereken már telepítve van. 5. Mik a legfontosabb tulajdonságai a médialejátszó komponensnek? Tulajdonság:

Leírás:

5. Mik a legfontosabb tulajdonságai a médialejátszó komponensnek? Tulajdonság: VisibleButtons ColoredButtons EnabledButtons

Leírás: : a gombok láthatóságát szabályozza : a gombok színességét szabályozza : a gombok engedélyezését vagy letiltását állíthatjuk be vele

........................................: ................................................................................................................. ........................................: ................................................................................................................. ........................................: .................................................................................................................

162

163

Az OLE (Object Linkink and Embedding)

2. Az alkalmazások közötti kommunikáció Amikor a Windowsban egyszerre több programot futtatunk, néha felmerül az igény, hogy az egyik program a másiknak valamilyen formában adatot, üzenetet, parancsot tudjon küldeni. Illetve vannak olyan esetek, amikor nem kell mindkét programnak egyszerre futnia. Ennek a megvalósítására nézzük meg, hogy milyen lehetőségek kínálkoznak. Közös fájl használata Az első, ami leginkább az adatbáziskezelés szemszögéből lehet fontos, az a közös fájl használata. Például, az egyik alkalmazásból kiíratunk egy szöveges (txt) fájlt és azt a másik programból beolvassuk. Ekkor a két program között egy adatokat kiexportáló és beimportáló kapcsolatot alakítottunk ki, hogy konkrét esetet írjak, az egyik program saját adatszerkezetet használ, mint például a Foxpro, a dBase vagy a Clipper, amelyek (dbf) fájlt használnak. Ha Pascalból írunk egy adatkezelő programot, ami természetesen alapból nem kezeli a .dbf fájlokat, akkor talán a legegyszerűbb megoldás az adatok átvitelére, ha az xbase környezetből kiexportáljuk egy vagy több txt fájlba az adatokat, és a Pascal programunkból ezt a txt fájlt megnyitjuk és beolvassuk az adatokat a Pascal program saját adatszerkezetébe.

Az OLE objektumok csatolása és beágyazása, a programok közötti adatcsere legfejlettebb formája. Segítségével programjainkat kiegészíthetjük más, létező program egy-egy komponensével. Képzeljük csak el, hogy egy Word dokumentumba beillesztünk egy MSPainttal (ismertebb nevén Paint) készült képet. Ha erre a képre duplán klikkelünk, akkor a Wordben szerkeszthetjük, rajzolhatjuk a képet és közben figyeljük meg, hogy a Word menüje és eszköztára kicserélődött a Paintéra. Ha a képen kívülre kattintunk, akkor evvel befejezzük a kép szerkesztését és visszatérünk a Wordbe, azaz az anya programba. A DDE-vel szemben itt nem teljesen két független alkalmazás között folyik az adatcsere és az utasítások küldése, hanem egy alkalmazás (konténer) szerves részévé tudunk tenni olyan elemeket és ezek szolgáltatásait (objektumokat), amelyek csak egy másik alkalmazás képes kezelni (szerver). A két alkalmazást itt konténernek és szervernek hívjuk. A konténer tartalmazza a beágyazott vagy csatolt objektumot (videó, kép, …), a szerver pedig az objektumot kezelni tudó alkalmazás. A Delphiben készíthetünk OLE konténer és OLE szerveralkalmazásokat is. A szerverek ActiveX, OCX vezérlőelemek formájában hozhatók létre.

Vágólap A másik lehetőségnél a programok közötti kommunikációra vágólap (clipboard) hazsnálata. Bizonyára mindenki használta már a vágólapot, amikor például egy szöveget jelölt ki a szövegszerkesztőben és illesztette be egy másik programban, pl. PowerPoint egy szövegdobozába. De olyan is előfordult már, hogy a táblázatkezelőből másolta a táblázatrészletet a vágólapra és onnan illesztette be egy szövegszerkesztőbe.

1. FELADAT

A Delphiben is számos eszköz létezik a vágólap kezelésére pl. a CopyToClipBoard, CutToClipBoard, PasteFromClipBoard metódusok és így tovább.

2. FELADAT

A DDE (Dinamic Data Exchange) A dinamikus adatcsere inkább a szöveges adatok cseréjét teszi lehetővé a párhuzamosan futó programok között. Itt kliens- és szerver-alkalmazásról beszélhetünk. A kliens (ügyfél) felkéri a szervert (kiszolgálót) egy kommunikációs csatornán keresztül az adatok cseréjére. DDE kliens alkalmazás

küldött kérés >> << kért adat

DDE szerver alkalmazás

29. Ábra - A DDE csatornán keresztül beszélgető alkalmazások

Keressen mintafeladatokat az interneten, amelyek két különböző alkalmazás között közös fájl használatával kommunikálnak.

Keressen mintafeladatokat az interneten, amelyek két különböző alkalmazás között DDE használatával kommunikálnak. 3. FELADAT Keressen mintafeladatokat az interneten, hogy az OLE-nak milyen változatai vannak és melyek ezek? (1.0; 2.0; OLE automatizmus) 4. FELADAT Keressen mintafeladatokat az interneten, hogy a vágólapon milyen jellegű, típusú információk tárolhatók?

Nézzünk egy példát a DDE kapcsolatra. Ha egy körlevelet készítünk Wordben és az adatainkat egy Acces adatbázis egy táblájából vagy lekérdezéséből szeretnénk a körlevél mezőinek beszúrni, akkor a Word felkéri az Accest, amely program akkor a háttérben elindul és működik, majd a parancsok végrehajtása után, de a Word bezárásakor biztosan az Access is bezárul a háttérben.

164

165

Önellenőrzés

?

1. Írjon egy példát, amikor a különböző programok közös fájlt használnak az adatcsere lebonyolítására? ........................................................................................................................................................... ........................................................................................................................................................... ...........................................................................................................................................................

Válaszok 1. Írjon egy példát, amikor a különböző programok közös fájlt használnak az adatcsere lebonyolítására? Amikor egy könyvelőprogram olyan adatszerkezetet használ, amit egy másik program nem, akkor legkézenfekvőbb például TXT formátumban kiexportálni az adatokat az egyik programból és a másikba ezt a TXT fájlt beimportálni. 2. Milyen adatokat helyezhetünk a vágólapra (minimum 4-5 példát írjon)? Szöveges, Képi, Hang, Videó, Táblázat, Formátum, …

2. Milyen adatokat helyezhetünk a vágólapra (minimum 4-5 példát írjon)? ........................................................................................................................................................... ........................................................................................................................................................... ........................................................................................................................................................... 3. Milyen szereplői vannak a DDE kapcsolatnak? ........................................................................................................................................................... ...........................................................................................................................................................

3. Milyen szereplői vannak a DDE kapcsolatnak? Kliens és szerver 4. Írjon példát az OLE-ra? Egy excel táblázat-részt beillesztünk egy Word dokumentumba. Ha szerkeszteni kívánjuk a táblázat-részletet, akkor duplán rá kell klikkelni, és ekkor az Excel menüje veszi át a Word menüjének a helyét. Ha a táblázat-részleten kívülre kattintunk, akkor kilépünk az Excelből és visszatérünk a Word-be. 5. Mi az OCX? A Delphiben készíthetünk OLE konténer és OLE szerveralkalmazásokat is. A szerverek ActiveX, OCX vezérlőelemek formájában hozhatók létre.

4. Írjon példát az OLE-ra? ........................................................................................................................................................... ........................................................................................................................................................... ........................................................................................................................................................... ........................................................................................................................................................... 5. Mi az OCX? ........................................................................................................................................................... ........................................................................................................................................................... ........................................................................................................................................................... ...........................................................................................................................................................

166

167

akkor a vezérlőgombok automatikusan letiltódnak vagy nem, annak megfelelően, hogy éppen lejátszunk-e valamit vagy sem.

3. Multimédiás lehetőségek, videók lejátszása OLE konténerben

A MediaPlayer néhány fontosabb tulajdonsága Indítsuk el a Delphi keretrendszert. Mentsük el c:\Delphi_munka\ole_media könyvtárba ole_media néven.

az

üres

projektünket

a

AutoEnable

A vezérlő gombok automatikus engedélyezése/tiltása a használat közben. Például, amég nem játszuk le a médiát, addíg nem nyomható meg a pillanat álj gomb, ha lejátszunk egy médiát, akkor nem nyomható meg a lejátszás mindaddíg amíg meg nem állítjuk.

AutoOpen

Automatikusan megnyitja a médiafájlt, ahogy elindítjuk a programunkat. Lehetőség van a fájl megnyitással is kiválasztani egy videófájlt és csak akkor lejátszani, ha már kiválasztottuk.

A komponenspaletta System fülén keressük meg a MediaPlayer komponenst és helyezzük rá a formra, majd mozgassuk a form alsó széléhez közelebbi pozícióra. Láthatjuk, hogy ez egy videómagnó vezérlőelemeihez hasonló gombsor.

AutoRewind

Ha lejátszottuk a médiafájlt, akkor automatikusan az elejére megy a pozíció. Olyan ez, mint a videókazetta visszatekerése, ha végére ért a kazetta.

Természetesen, ha nem hangot, hanem videót is le szeretnénk játszani, akkor igénybe kell vennünk egy megjelenyítő komponenst is. Mivel ez a Delphiben közvetlenünl nem található, de a Windows MediaPlayerében igen, akkor használjuk ki ezt a lehetőséget.

ColoredButtons Értékér részletesen be lehet állítani, hogy melyik gomb legyen színes és melyik ne, azaz fekete.

A már ismert módon helyezzünk egy nyomógombot az ablakunk alső részébe és rendeljünk hozzá bezárás parancsot. (Például egy közönséges nyomógombbal és a Close paranccsal, vagy egy BitBtnnel és a Kind tulajdonságát bkClose-ra kell állítani.) A gomb feliratát állítsuk be „Be&zár”-ra. Mint tudjuk az „&” a feliratnál az aláhúzott betűt jelenti, mely ebben az esetben az Alt+Z lenyomásával közvetlenül is elérhető.

OLE konténer

Helyezzünk a formunkra egy OLE konténert, amiben majd megjelenítjük a videónkat. A Height-et (magasság) és a Width-et (szélesség) adjuk MediaPlayer meg. A Videó magassága legyen 288 és a szélessége legyen 352. Ez megfelel a szabványos negyed PAL-os méretnek. (Mint tudjuk a teljes PAL méret a 704x576 (valójában 30. ábra - A médialejátszós ablakunk 720x576) képpont és ez most pontosan a negyede ennek, ezért negyed PAL-os az elnevezése.) Ha mindezzel készen vagyunk, akkor esztétikusan rendezzük el a komponenseket, méretezzük át a formunkat az ábra szerintire vagy tetszés szerint szabadon. Állítsák át a MediaPlayer, AutoOpen tulajdonságát TRUE-ra. A FileName értékénél a három pontos nyomógombbal válasszuk ki a lejátszani kívánt fájlt. Ami természetesen lehet hang fájl is és videó is. Most a Windows könyvtárunkból válasszuk ki a Clock.avi-t. Még nem mondtuk meg a MediaPlayernek, hogy hol jelenítse meg a videót. A Display tulajdonságnál a legördülő listából válasszuk ki a OleContainer1-et. Mentsük el a projektünket és kész is vagyunk az első videólejátszó programunkkal. Ha lefuttatjuk a programunkat (F9),

168

DeviceType

dtAutoSelect, dtAviVideo, dtCDAudio, … itt lehet megadni a lejátszani kívánt média típusát. Autó esetén automatikusan választja ki a típust.

Display

Ez az egyik legfontosabb, ha videót kívánunk lejátszani. A példánkban válasszuk ki az OleContainer1-et, hogy a lejátszani kívánt videófájl melyik OLE konténerben játszódjon le.

Enabled

Úgy mint a legtöbb kontrollnak ez a tulajdonsága határozza meg, hogy a felhasználó elől le van-e tiltva vagy sem.

EnabledButtons A nyomógombokat külön-külön lehet letiltani illetve engedélyezni. FileName

A lejátszani kívánt fájl neve.

Height

A gombsor magassága.

Name

Úgy mint minden objektumnak az egyedi neve, amire hivatkozni lehet.

Visible

Látható-e vagy sem.

VisibleButtons

A gombokat egyenként lehet letiltani, illetve engedélyezni a megjelenését.

Width

A gombsor szélessége.

Nézzünk meg egy olyan tulajdonságot is, amit az objektum-felügyelőből közvetlenül nem tudunk állítani az időformárum beállítása: MediaPlayer1.TimeFormat := tfFrames;

Néhány további lehetséges érték: tfMilliseconds

Millisekundumban megadott 4-bájtos egész számban tárolva

tfHMS

Óra, Perc és másodperces formátum 4 bájtos egész számban tárolva

tfMSF

Perc,másodperc és képkocka 4 bájtos egész számban tárolva

169

tfFrames

Képkockák 4 bájtos egész számban tárolva

tfSMPTE24

24 kockás SMPTE14 formátumban megadott 4 bájtos egész számban tárolva

tfSMPTE25

25 kockás SMPTE formátumban megadott 4 bájtos egész számban tárolva

tfSMPTE30

30 kockás SMPTE formátumban megadott 4 bájtos egész számban tárolva

tfSMPTE30Drop 30 kockás SMPTE formátumban megadott, ahol az eldobott kockák és bele vannak kalkulálva a lejátszásba, 4 bájtos egész számban tárolva tfTMSF

1. FELADAT Válassza ki a formon lévő az OLE komponenst és az Align (igazítás) valamint az Anchor (horgony) tulajdonságokat változtassa tetszés szerint, majd figyelje meg, hogy mi történik a kontrollal a program futása közben, amikor átméretezi az ablakot. Ugyanezt a tulajdonságot a többi komponensnél is vizsgálja meg. Melyik objektum marad a helyén, melyik méreteződik át automatikusan az ablakkal együtt és hogyan? 2. FELADAT Törölje a Display értékét és figyelje meg, hogy mi történik egy videó lejátszásakor.

SMPTE

170

?

1. Melyik komponens paletta-fülön található a MediaPlayer kontroll? ........................................................................................................................................................... 2. Hol kell megadni, hogy hol jelenjem meg a lejátszani kívánt videó? ...........................................................................................................................................................

Sáv, Perc, másodperc és keret, 4 bájtos egész számban tárolva

Mit is jelent az előzőekben megemlített SMPTE a lábjegyzetében leírt mozaikszó, ami azt jelenti a videótechnikában, hogy az időegységet, milyen sablon alapján, milyen módon jellemezzék: 00:00:00:00, ahol az első két számjegy az órákat a következő két számjegy a perceket, a harmadik két számjegy a másodperceket és a negyedik két számjegy a másodpercen belüli képkockákat jelenti. Ha például egy PAL rendszerben megadott videóklippet lejátszunk, akkor a 00:02:19:21 azt jelenti, hogy 2 perc 19 másodperc 21. képkockáról van szó. A képkockák száma 0-tól 24-ig terjedhet, így számolható meg a 25 képkocka. A 00:00:02:07 SMPTE kód szerinti idő egész pontosan 2,28 másodpercet jelent. Javaslom, hogy barátkozzanak meg evvel a jelöléssel, mert a multimédia további szakaszaiban a videók vágásánál ezt a jelölést szokták alkalmazni.

14

Önellenőrzés

3. Mi a feladata az AutoEnable mezőnek? ........................................................................................................................................................... ........................................................................................................................................................... 4. Mit befolyásol a VisibleButtons tulajdonság? ........................................................................................................................................................... 5. Mit állíthatunk a TimeFormat tulajdonsággal? ........................................................................................................................................................... ........................................................................................................................................................... 6. Mekkora a negyed PAL-os képméret? Mit jelent ez? ........................................................................................................................................................... 7. Mit jelent az SMPTE? ........................................................................................................................................................... ...........................................................................................................................................................

Society of Motion Picture and Television Engineers Mozgókép és Televíziós Mérnökök Egyesülete

171

Válaszok


1. Melyik komponens paletta-fülön található a MediaPlayer kontroll? System fülön

Bevezetés

2. Hol kell megadni, hogy hol jelenjem meg a lejátszani kívánt videó? A Display értéke határozza meg 3. Mi a feladata az AutoEnable mezőnek? A vezérlő gombok automatikus engedélyezése/tiltása a használat közben. Például, amég nem játszuk le a médiát, addíg nem nyomható meg a pillanat álj gomb, ha lejátszunk egy médiát, akkor nem nyomható meg a lejátszás mindaddíg amíg meg nem állítjuk. 4. Mit befolyásol a VisibleButtons tulajdonság? A gombokat egyenként lehet letiltani, illetve engedélyezni a megjelenését.

Ebben részben egy komplett médiaplayerhez hasonló programot fogunk készíteni. Itt tulajdonképpen az előző kompetenciafejezetben elkezdett programunkat fogjuk továbbfejleszteni és egy-két vezérlőelemmel kiegészíteni. A tanulási feladatok elvégzése után a hallgató: · Képes lesz a lejátszandó médiafájl pozícióját numerikusan és grafikusan megjeleníteni a képernyőn. (TrackBar) · Képes lesz valamilyen vezérlő elemmel pozícionálni a médiafájlban Rész célkitűzések 1. Médialejátszó program csúszkával 2. Médialejátszó programunk kiegészítése hangerőszabályzóval

5. Mit állíthatunk a TimeFormat tulajdonsággal? Az időformátumot 6. Mekkora a negyed PAL-os képméret? Mit jelent ez? A teljes PAL-os képkocka negyedét, azaz a 704x576-nak a negyede 352x288-as képméret. 7. Mit jelent az SMPTE? Mit is jelent az előzőekben megemlített SMPTE a lábjegyzetében leírt mozakszó, ami azt jelenti a videótechnikában, hogy az időegységet, milyen milyen sablon alapján, milyen módon jellemezzék: 00:00:00:00, ahol az első két számjegy az órákat a következő két számjegy a perceket, a harmadik két számjegy a másodperceket és a negyedik két számjegy a másodpercen belüli képkockákat jelenti. Ha például egy PAL rendszerben megadott videóklippet lejátszunk, akkor a 00:02:19:21 azt jelenti, hogy 2 perc 19 másodperc 21. képkockáról van szó. A képkockák száma 0-tól 24-ig terjedhet, így számolható meg a 25 képkocka. A 00:00:02:07 SMPTE kód szerinti idő egész pontosan 2,28 másodpercet jelent. Javaslom, hogy barátkozzanak meg evvel a jelöléssel, mert a multimédia további szakaszaiban a videók vágásánál ezt a jelölést szokták alkalmazni.

172

173

Else TrackBar1.Enabled := True;

1. Médialejátszó program csúszkával

TrackBar1.Max

:= MediaPlayer1.Length;

TrackBar1.Frequency := MediaPlayer1.Length div 50;

Készítsük el a következő formot, a már ismert módon.

TrackBar1.Position

:= MediaPlayer1.Position;

Ez a minden egyes lefutáskor ellenőrzi, hogy a MediaPlayer állapota (Mode) épp lejátszás üzemmódban van-e vagy sem. Ha igen, akkor letiltja a TrackBar felhasználói elérését. Ha nincs lejátszásban, akkor engedélyezi. Miért is van ez így? Mert a TrackBar-nak nincs olyan eseménye, amivel figyelhetnénk, hogy a felhasználó lenyomta-e az egerét vagy sem. A TrackBar értékének a megváltozásának a figyelése pedig összezavarná önmagát.

OLE konténer

MediaPlayer

Timer

A médialejátszó a lejátszott médiának a hosszát, a pozícióját és a frekvenciát értékül adjuk a TrackBar-nak. A frekvencia a TrackBar beosztása. Amilyen számmal osztjuk (div 50), annyi értékre tudjuk beállítani a skálát.

TrackBar

A TrackBar-nek a felhasználó általi megváltoztatásakor, azaz ha a felhasználó a csúszkán arrébb mozgatja a marker jelet, akkor a média pozíciója is változzon meg arra a pozícióra. Ehhez a TrackBar OnChange eseményéhez írjuk be a következő sorokat. Természetesen itt egy ellenőrzés történik, hogy a média épp lejátszás alatt van-e vagy sem. Ha nem, akkor a TrackBar pozíciója legyen a média pozíciója. procedure TForm1.TrackBar1Change(Sender: TObject); begin If MediaPlayer1.Mode <> mpPlaying Then MediaPlayer1.Position := TrackBar1.Position;

31. kép a saját médialejátszónk TrackBar-ral

End;

A MediaPlayer gombjainak számát csökkentsük a képen látható gombokra. A Timer1 időzítését (Interval) állítsuk be 100-ra. Ez egy időzítő óra, amely a beállított időintervallumokban ciklikusan végrehajtja az OnTimer eseményéhez rendelt utasításokat. A Timer1 ki- és bekapcsolható az Enabled tulajdonságán keresztül. Ne felejtsük el bekapcsolni, ha használni szeretnénk. Ha például egy órát szeretnénk készíteni, ami a formunk címsorában állandóan mutatja a pontos (gép órájának megfelelő) időt, akkor csak annyit kellene tennünk, hogy az eseményéhez beírjuk a következő sort: Form1.Caption := TimeToStr(Now);

Amit azt jelenti, hogy a Formunk címsorának az értéke legyen a Now (most) függvény által visszaadott érték. Ezt az értéket kell átalakítanunk a TimeToStr (időből sztringgé alakít) függvénnyel, hogy a szöveges típusú adatként meg tudjuk jeleníteni a címsorban.

1. FELADAT Keressen olyan megoldást, amely a Fent említett Timer1-nél megadott média hoszszát, a TrackBar skálájának frekvenciáját nem 100 ms-onként frissíti, hanem csak egyszer állítja be, és csak a ténylegesen változó adatokat frissíti, mint például a lejátszott médiafájl aktuális pozíciója. Megoldási javaslat, hogy más kontroll valamely eseményéhez helyezze át a szükséges programorokat.

Egészítsük ki az alábbi sorokkal a Timer1 eseményét. If MediaPlayer1.Mode = mpPlaying Then TrackBar1.Enabled := False

174

175

Önellenőrzés

?

1. Milyen feladatokra használható a TrackBar? (Írjon 2-3 példát!) ........................................................................................................................................................... ........................................................................................................................................................... ........................................................................................................................................................... ........................................................................................................................................................... 2. Milyen feladatokra használható a Timer? (Írjon egy példát!) ........................................................................................................................................................... ...........................................................................................................................................................

Válaszok 1. Milyen feladatokra használható a TrackBar? (Írjon 2-3 példát!) Olyan esetekben, amikor vizuálisan kell/lehet állítani valamely tulajdonságot két érték között. 2. Milyen feladatokra használható a Timer? (Írjon egy példát!) Amikor valamilyen feladatot bizonyos időközönként el szeretnénk végeztetni. Az Interval tulajdonságnál állítható az intervalum értéke és természetesen engedélyezni kell a működését is az Enabled tulajdonsággal. 3. Hogyan lehet a pontos időt lekérdezni és kiiratni egy szöveges kontrollal? Label1.Caption := TimeToStr(Now);

4. Honnan tudható meg, hogy a MediaPlayer épp lejászó módban van? …

3. Hogyan lehet a pontos időt lekérdezni és kiiratni egy szöveges kontrollal?

If MediaPlayer1.Mode = mpPlaying Then Label1.Caption := ’Lejátszás’;; …

5. Hogyan kapcsolható ki és be a TTimer komponens? Az Enabled mezőjén keresztül az Objektum-felügyelőben vagy futás közben a következő kódrészlettel 4. Honnan tudható meg, hogy a MediaPlayer épp lejászó módban van?

… Timer1.Enabled := True; // vagy Timer1.Enabled := False; …

5. Hogyan kapcsolható ki és be a TTimer komponens? ...........................................................................................................................................................

176

177

2. Médialejátszó programunk kiegészítése hangerőszabályzóval

Itt felvettünk egy Volume változót a jobb olvashatóság kedvéért. Tulajdonképpen a függvényeket egymásba is ágyazhattuk volna a következő képpen: waveOutSetVolume(auxGetNumDevs(),Abs(65535-TrackBar2.Position));

A médialejátszónkat egészítsük ki egy Label-lel (címke) és egy még egy TrackBar-ral. A TrackBar Orientation tulajdonságát állítsuk át trVertical-ra, ekkor az elhelyezkedése függőleges lesz. A Max értékét 65535-re állítsuk be és a skáláját (Frequency) tetszés szerint. A képen láthaó esetben 1000-re állítottuk. Az új Labelt írjuk át „Hangerő”-re. A hangerő beállítása 2 bájtos, azaz az intervalluma 0 és 65535 közé esik.

Így kényelmesebb lett volna, de ez így nehezebben olvasható. A waveOutSetVolume API függvénnyel lehet a hangerőt beállítani. Abban az esetben, ha több hangkimenet van a gépünkben, akkor is van egy ami az alapértelmezett és ezt állapítjuk meg az első paraméterében az auxGetNumDevs() függvénnyel. Ez egy számot ad vissza, ha más nincs, akkor 0-át. Ahhoz, hogy ezeket a függvényeket használni tudjuk, az unitokhoz fel kell vennünk az MMSystem egységet. Íme a teljes program: unit Unit1; interface uses Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs, ComCtrls, ExtCtrls, MPlayer, OleCtnrs, StdCtrls, MMSystem; type TForm1 = class(TForm)

Az MMSystem egység

OleContainer1: TOleContainer; MediaPlayer1: TMediaPlayer; Timer1: TTimer; TrackBar1: TTrackBar; TrackBar2: TTrackBar; procedure Timer1Timer(Sender: TObject); procedure TrackBar1Change(Sender: TObject);

32. kép a saját médialejátszónk kegészítve hangerőszabályzóval

procedure TrackBar2Change(Sender: TObject); private

A függőleges TrackBar-on a hangerő állítása úgy kényelmes, ha alul a leghalkabb, azaz csendes és felül a leghangosabb a hang. De ez pont fordítva van a TrackBar esetében. Azaz fent van a 0 és lent van a maximális érték. Ennek a megfordítására lássuk a következő megoldást. A Maximális értékből vonjuk ki az aktuális pozíciót, és ennek vegyük az abszolút értékét. Lássuk hát a TrackBar2 OnChange eseményét: procedure TForm1.TrackBar2Change(Sender: TObject); Var Volume : Integer;

{ Private declarations } public { Public declarations } end; var Form1: TForm1; implementation

begin Volume := Abs(65535-TrackBar2.Position);

{$R *.DFM}

waveOutSetVolume(auxGetNumDevs(),Volume); end;

178

179

procedure TForm1.Timer1Timer(Sender: TObject);

Önellenőrzés

begin

?

Form1.Caption := TimeToStr(Now);

1. Mit határoz meg a TrackBar Min, Max és Frequency értéke?

If MediaPlayer1.Mode = mpPlaying Then

...........................................................................................................................................................

TrackBar1.Enabled := False Else

...........................................................................................................................................................

TrackBar1.Enabled := True; TrackBar1.Max

:= MediaPlayer1.Length;

2. Hogy lehet a függőleges TrackBart rávenni, hogy az alsó felében legyen a minimum és a felső felében legyen a maximum értéke?

TrackBar1.Frequency := MediaPlayer1.Length div 50; TrackBar1.Position

:= MediaPlayer1.Position;

end; procedure TForm1.TrackBar1Change(Sender: TObject); begin If MediaPlayer1.Mode <> mpPlaying Then MediaPlayer1.Position := TrackBar1.Position;

3. Hogyan lehet a hangerőt beállítani a Windows alatt?

end; procedure TForm1.TrackBar2Change(Sender: TObject); Var Volume : Integer; begin Volume := Abs(65535-TrackBar2.Position);

4. Milyen modult kell felvenni, hogy a hangerőt állítani tudjuk?

waveOutSetVolume(auxGetNumDevs(),Volume);

...........................................................................................................................................................

end;

5. Hogy lehet megoldani, hogy a MediaPlayer csak bizonyos gombokat mutasson meg, és a többit elrejtse?

end.

1. FELADAT Egészítse ki a programot egy Label-lel, amely kiírja a hangerő pontos értékét 0 és 100 közötti számmal.

........................................................................................................................................................... ........................................................................................................................................................... ...........................................................................................................................................................

180

181

Válaszok


1. Mit határoz meg a TrackBar Min, Max és Frequency értéke? A Min a legkisebb értéket a Max a legnagyobb értéket jelenti, amit be lehet állítani majdan vele. A Frequency pedig a skála felosztását.

Bevezetés

2. Hogy lehet a függőleges TrackBart rávenni, hogy az alsó felében legyen a minimum és a felső felében legyen a maximum értéke? //azaz a maximum értékéből ki kell vonni a csúszka aktuális értékét //és ennek kell venni az abszolút értékét //Ami a hangerőszabályzó esetében a következő Volume := Abs(65535-TrackBar2.Position);

3. Hogyan lehet a hangerőt beállítani a Windows alatt? Volume := Abs(65535-TrackBar2.Position); //A hangerő a következő API függvénnyel állítható be

Minden valamire való programnál követelmény, hogy az EMBER és a GÉP közötti jó kölcsönhatás biztosítva legyen. Ezt nevezzük interakciónak. Az interaktivitás eszköze a menü. A menüelemek (almenüelemek) egy-egy funkciót (adatbevitelt és/vagy feldolgozó programot) indítanak. Módja a dialógus- (párbeszéd-) ablak. Ez az elemi társalgási egység. Erre a társalgásra fogunk példákat látni a következő kompetencia-fejezetekben. A tanulási feladatok elvégzése után a hallgató: · Ismerni fogja az interaktív programok által támasztott követelményeket · Képes lesz interaktív programot írni: 1. menüvel ellátot keretrendszer programot írni 2. menüből meghívni dialógusablakokat 3. a dialógusablakokkal egyszerűbb műveleteket elvégeztetni 4. dialógusablakok által „beszélgetni” a felhasználókkal

waveOutSetVolume(auxGetNumDevs(),Volume);

4. Milyen modult kell felvenni, hogy a hangerőt állítani tudjuk? MMSystem (Az Uses utáni moduloknál kell felvenni).

Rész célkitűzések 1. Egyszerű párbeszédablakok 2. A menü 3. A Windows dialógusablakai

5. Hogy lehet megoldani, hogy a MediaPlayer csak bizonyos gombokat mutasson meg, és a többit elrejtse? A VisibleButtons –nél lehet gombonként beállítani, hogy melyek látszódjanak és melyek ne.

182

183

Az alkalmazására nézzünk egy példát.

1. Egyszerű párbeszédablakok

if MessageDlg('Menti a változtatásokat?', mtConfirmation, [mbYes, mbNo], 0) = mrYes then

Üzenetablakok

begin MessageDlg(’A Yes gombra kattintott.', mtInformation, [mbOk], 0);

ShowMessage eljárás

Close;

ShowMessage(’Szia kedves gazdám!’);

end;

Ez az egyszerű eljárás bármilyen üzenet megjelenítésére. Az ablak címsorában az alkalmazás neve olvasható.

Önellenőrzés

33. ábra- Üzenőablak

MessageDlg függvény (visszaadott értéke Word típusú) A MessageDlg függvény eredménye a következő párbeszédablak. Ugye ismerős. A paraméterek felsorolása nem szorul magyarázatra. Az első paramétere a megjelenített szöveg. A következő az ablak jellegére utal:

?

1. Írjon példát, hogy mire használható a MessageDlg függvény! ........................................................................................................................................................... 2. Milyen jellegű MessageDlg ablakok vannak?

mtWarning

Figyelmeztetés

...........................................................................................................................................................

mtError

Hibaüzenet

...........................................................................................................................................................

mtInformation

Információs ablak

mtConfirmation

Jóváhagyást kérő ablak

mtCustom

Egyéni

........................................................................................................................................................... ...........................................................................................................................................................

A harmadik a gombok halmaza. Lehetséges gombok, melyek a visszaadott értékeket is reprezentálják:

3. Milyen gombok lehetnek ezen az üzenőablakon? ...........................................................................................................................................................

mrNone

mrAbort

mrYes

mrOk

mrRetry

mrNo

...........................................................................................................................................................

mrCancel

mrIgnore

mrAll

...........................................................................................................................................................

A negyedik, a súgó index. 4. Hogy lehet lekérdezni, hogy melyik gombot nyomták meg?

34. ábra - Példa a MessageDlg függvényre

184

185

Válaszok

2. A menü

1. Írjon példát, hogy mire használható a MessageDlg függvény! Üzenőablakot nyit meg egy, kettő vagy három gombbal, ahogy a programozó a helyzetnek megfelelően eldönti. Általában három gombbal szokott megjelenni például, hogy „Szeretné-e menteni a dokumentumot?” kérdéssel és „Igen, Nem, Mégsem” gombokkal.

A legtöbb program, ami nem egy egyszerű dialógusdobozból áll, tartalmaz egy legördülő menüt. Ha csak egy párbeszéd dobozból áll a program, akkor inkább csak felbukkanó menüt tartalmaz. Igaz, hogy a legördülő menü általában az MDI alkalmazásoknál található meg, de most ettől a szokástól eltérően bemutatom, hogy hogyan lehet elkészíteni bármilyen programhoz.

2. Milyen jellegű MessageDlg ablakok vannak? mtWarning Figyelmeztetés

A komopetenciafejezet végén lévő feladatoknál feladatul kapja a kedves Olvasó, hogy készítsen egy MDI alkalmazást, menüvel, (nagyon egyszerű, csak a menüből ki kell választani.)

mtError

Hibaüzenet

mtInformation

Információs ablak

mtConfirmation

Jóváhagyást kérő ablak

mtCustom

Egyéni

3. Milyen gombok lehetnek ezen az üzenőablakon? mrNone mrAbort

Akkor most nézzük, hogy a mi alkalmazásunkhoz, hogyan lehet legördülő menüt készíteni. A komonens palettáról válasszuk ki a MainMenu kontrollt és helyezzük el valahova a formunk aljára úgy, hogy ne legyen útba a későbbi komponenseknek. (Persze bármikor áthelyezhető). Kattintsunk kettőt ezen a kis téglalap alakú komponensen és a következő menüszerkesztő ablakhoz jutunk.

mrYes

mrOk

mrRetry

mrNo

mrCancel

mrIgnore

mrAll

4. Hogy lehet lekérdezni, hogy melyik gombot nyomták meg? //Például: if MessageDlg('Menti a változtatásokat?', mtConfirmation, [mbYes, mbNo], 0) = mrYes then begin MessageDlg(’A Yes gombra kattintott.', mtInformation, [mbOk], 0); Close; end;

35. ábra - A menüszerkesztő segédablaka

Ebben az ablakban a kurzormozgató nyilakkal mozoghatunk. Ha elkezdünk gépelni, akkor azonnal megjelenik a menü feliratában, amit begépelünk. Először gépeljük be a „File” szót, majd nyomjunk lefelé nyilat. Ekkor az almenübe kerülünk. Oda gépeljük be a „Kilépés”-t. Most szerkesszük meg a többi menüt (nyilakkal és begépeléssel). Legyen egy „Súgó” menü, abban egy „Üzenet…” és egy „Névjegy…” almenü. Mi is kövessük az IBM SAA/CUA szabályait, hogy ha a menüpont nem hajt végre egy parancsot azonnal, hanem folytatódik egy másik ablakban, akkor a menüpont nevét kövesse három pont. Ha mindezzel végeztünk, zárjuk be („X”-szel) a menüszerkesztő ablakot. Ide bármikor visszatérhetünk, ha duplán klikkelünk a komponensre. Most már megjelenik a formunkon is a megszerkesztett menü. Ha a formunkon kiválasztjuk a File menüben a Kilépést, akkor azonnal a kódszerkesztőbe ugrik a Delphi, ahol megszerkeszthetjük a menüponthoz tartozó programrészletet.

186

187

Vajon mi lehet a különbség a két programrészlet között?

procedure TForm1.Kilps1Click(Sender: TObject); begin

Az első megoldás a Show metódus csak egyszerűen megjeleníti a Form2-t és közben rákattinthatunk a Form1 területére és akkor a Form2 a háttérbe kerül. Ha a ShowModal metódust hívjuk meg, akkor a Form2 modálisan nyílik meg. Ez azt jelenti, hogy amíg nem zártuk be a az ablakot addíg nem tudunk „mögé” kattintani. Ilyen ablakok például az üzenő ablakok, hogy a felhasználó nehogy valamit tegyen, amíg nem olvasta el az üzenetet, és ilyen a legtöbb párbeszédablak is.

Close; end;

Az üzenet menüponthoz írja meg a következő üzenőablak megjelenítését szolgáló parancsot: procedure TForm1.zenet1Click(Sender: TObject); begin ShowMessage('Szia kedves gazdám!'); end;

1. FELADAT Mensen el és zárjon be mindent (File menü, Save all, Close all). Készítsen egy MDI alkalmazást a File menü New… menüjét meghívva, majd a megjelenő ablakból válassza ki a Projects fület és abban a az MDI15 Applikációt. Nézze át a menü komponenst. Egészítse ki a menüt egy saját főmenüponttal majd írjon hozzá további két almenüt. Rendeljen hozzájuk egy-egy formot a tanultak alapján, amikre helyezzen egy bezáró gombot és egy feliratot a saját nevével.

36. ábra - A formunk a menü komponenssel és a megszerkesztet menüvel

Az eszköztár NewForm gombjával adjunk hozzá egy újabb formot. Ez lesz a Form2. Formázzuk meg a következő minta szerint és a nyomógombhoz írjuk meg a bezárását végrehajtó utasítást (Close;).

38. ábra - Az MDI alkalmazás kiválasztása 37. ábra - A második formunk

2. FELADAT

Most válasszuk ki a Form1-es Súgó menüjének a „Névjegy…” almenyüjét, hogy a hozzá tartozó kódot megírjuk, ami majd meghívja ezt a második formot.

Keresse meg az interneten, hogy mit is jelent pontosan az MDI és az SDI alkalmazás.

Form2.Show;

vagy Form2.ShowModal;

188

15

MDI Olyan alkalmazás mint például a Word, ahol egy program fut és több dukumentumot lehet benne megnyitni. Ellentéte az SDI alkalamazás, melynél egy programban egy dokumentumot lehet megnyitni, mint például az MSPaint (Paint), ahol egy rajzot tud egyszerre rajzolni a felhasználó. Ha egy másik rajzon szeretne dolgozni, akkor a Paintot mégegy példányban el kell indítani.

189

Önellenőrzés

?

1. Mit jelent a menüpontok utáni három pont? ........................................................................................................................................................... ........................................................................................................................................................... 2. Hogyan tud legördülő menüt beilleszteni egy alkalmazásba? ........................................................................................................................................................... ........................................................................................................................................................... 3. Hogyan tud utasítást rendelni egy menüponthoz? ........................................................................................................................................................... ........................................................................................................................................................... 4. Mi a különbség a modális és a nem modális ablakok között? ........................................................................................................................................................... ........................................................................................................................................................... ...........................................................................................................................................................

Válaszok 1. Mit jelent a menüpontok utáni három pont? Hogy folytatása következik. Ez általában egy párbeszédablak (dialógus doboz). 2. Hogyan tud legördülő menüt beilleszteni egy alkalmazásba? A menü komponenst kell elhelyezni a formra, majd dupla klikk után a menüszerkesztőben meg kell szerkeszteni a menüt. 3. Hogyan tud utasítást rendelni egy menüponthoz? A menüszerkeztő bezárása után megjelenik a szerkesztett menü a form-on. Ha ott kiválasztjuk a menüpontot, akkor azonnal a kódszerkeztőben találjuk magunkat, ahol megírhatjuk a menüponthoz tartozó kódot. 4. Mi a különbség a modális és a nem modális ablakok között? Ameddig a modális ablak a képernyőn van, addig az őt meghívó ablakra nem lehet kattintani, azaz csak akkor, ha bezártuk ezt az ablakot. A bezáráshoz általában egy OK gomb megnyomására van csak szükség. Ilyenek az általános üzenő ablakok, amelyeknek az a feladata, hogy a felhasználó addig ne tudjon mást tenni amíg el nem olvasta a feliratot és nem nyomta meg a megfelelő gombot (Pl.: Igen, Nem, Mégsem). A nem modális ablakokat meghívó ablakra i lehet kattintani és az az ablak fogadni tudja a felhasználó parancsait. 5. Hogyan lehet meghívni egy form-ot, hogy modálisan illetve nem modálisan jelenjenek meg? //Modálisan:

5. Hogyan lehet meghívni egy form-ot, hogy modálisan illetve nem modálisan jelenjenek meg? //Modálisan:

Form5.ShowModal; //és nem modálisan: Form5.Show;

//és nem modálisan:

190

191

3. A Windows dialógusablakai

Zárjuk be a menüszerkesztőt és rendeljük a „Megnyitás…” menühöz a következő kódot: procedure TForm1.Megnyits1Click(Sender: TObject);

A komponens paleta „Dialogs” fülére kattintva találjuk a Windowsban már megszokott rendszer párbeszédablakokat. Ebben a fejezetben csak a megnyitás dialógus dobozzal fogunk megismerkedni. A többi komponens használata is hasonló ehhez az ablakhoz. Ebben a fejezetben ismét egy médialejátszó programot fogunk készíteni. Egészítsük ki a programunkat a képen látható komponensekkel. (OLE konténer, Média lejátszó, Open).

begin OpenDialog1.DefaultExt := 'AVI'; OpenDialog1.Filename := '*.avi'; If OpenDialog1.Execute then Begin MediaPlayer1.Filename := OpenDialog1.Filename; MediaPlayer1.Open; End; end;

Itt futás időben adjuk meg a megnyitás (OpenDialog1) kiterjesztéséhez az értéket és a fájl nevét „*.avi”. A feltételben lekérdezzük, hogy a dialógusablak sikeresen lefutot-e és választotunk-e fájlt. Ha igen, akkor a médialejátszó fájlneve legyen az amit kiválasztotunk, majd nyissuk meg a médialejátszót az Open metódussal. Ha nem választottunk fájlt, vagy csak bezártuk az ablakot, akkor a feltétel magjában megírt kód végre sem hajtódik.

A Menü és az Open komponensek 1. FELADAT Készítsen egy „Bezár” menüpontot, amihez a MediaPlayer1.Close; metódust rendeli.

39. ábra - Az új médialejátszós alkalmazásunk

Ne felejtsük el az OLE konténert rendelni a médialejátszó Display tulajdonságához.

2. FELADAT Keressen az interneten mintaprogramokat, melyben a nyomtató beállítás komponenst meghívja a rendszer nyomtató beállítására szolgáló dialógusablakot. 3. FELADAT Keressen információkat az Interneten a Popup menü lehetőségeiről.

40. ábra - A „Megnyitás…” menü

Nyisuk meg a menüszerkesztőt. (Dupla klikk a MainMenü komponensre.) Egészítsük ki a programunk menüjét a képen látható „Megnyitás” menüvel.

192

193

Önellenőrzés

?

1. Milyen paletta fülön találjuk az Open (megnyitás) kontrollt?

Utószó Kedves Olvasó!

........................................................................................................................................................... 2. Hogyan tudja megívni az Open komponenst és lekérdezni, hogy a felhasználó választott-e fájlt vagy sem?

Remélem, hogy sikerült ízelítőt adnom a hagyományos Pascal programozáson keresztül a modernebb fejlesztő keretrendszerhez, a Delphihez. Mint az elején és a modulfüzetben többször is utaltam rá, hogy a rendelkezésre álló oldaszámokra hivatkozva nem állt módomban bemutatni a programozás, azon belül a Pascal programozás minden rejtelmét. Sajnos ezt most is meg kell jegyeznem, mert jómagam is már vagy 12-13 éve foglalkozom programozással, és higgye el a kedves Olvasó, hogy még mindig akadnak olyan feladatok, amelyek fejtörést okoznak. Egy tanárom azt mondta, hogy nem kell mindent fejben tartani, hanem elég azt megjegyezni, hogy hol találjuk meg a megoldást. Napjaink népszerű információszerző közege az Internet. A modulfüzet során többször is feladatul adtam, hogy keressen az interneten ezt vagy azt. Úgy tűnik, hogy az Internet lassan kiszorítja a többi médiumot, a napilapokat, az egyéb újságokat és lassan a televíziót is.

Válaszok 1. Milyen paletta fülön találjuk az Open (megnyitás) kontrollt? Dialogs 2. Hogyan tudja megívni az Open komponenst és lekérdezni, hogy a felhasználó választott-e fájlt vagy sem? OpenDialog1.DefaultExt := 'AVI'; OpenDialog1.Filename := '*.avi';

Aki eddig nem nagyon járt könyvtárba, de szeretne olvasni vagy információhoz jutni, az is most az Internet előtt ülve keresi a megfelelő választ a kérdéseire. Természetesen minden nem található meg az interneten, de nyugodt szívvel mondhatom, hogy nagyon sokminden viszont igen. Ha valaki szeretne további programnyelvekkel megismeredni, akkor javaslom, hogy látogasson el a http://prog.hu -ra vagy a http://ebbokz.hu -ra. Regisztráció után vagy anélkül is hatalmas tudásbázis található ezeken az oldalakon. Az utóbbin még oktatóvideók is letölthetők, ahol a Pascal programozást egy videófilmen keresztül sajátíthatjuk el, de ugyanakkor a legnépszerűbbek az Adobe PhotoShop kezelésén keresztül szinte bármilyen támáról tölthetünk le oktató videókat.

If OpenDialog1.Execute then Begin MediaPlayer1.Filename := OpenDialog1.Filename;

Varga Zsolt

MediaPlayer1.Open; End;

194

195

Ajánlott irodalom

Tartalom A MODULFÜZET ALAPADATAI................................................................................................................ 1

Szakkönyvek OBÁDOVICS J. GYULA

Matematika

URBÁN JÁNOS

Matematikai logika

BACH IVÁN

Formális nyelvek

BAILLIF, JEAN-CLAUDE

Logikai sziporkák

BLUM, WOLFGANG

A logika nyelvtana. Bevezetés a matematikába

FERENCZI MIKLÓS

Matematikai logika

PÁSZTORNÉ VARGA KATALIN, VÁRTERÉSZ MAGDA A matematikai logika alkalmazásszemléletû tárgyalása VINNAI PÉTERNÉ

A MODUL TÉMAKÖREI ............................................................................................................................. 3 ARITMETIKAI, LOGIKAI ÉS BITMŰVELETEK ALKALMAZÁSA ...................................................... 4 1. BEVEZETÉS A PROGRAMOZÁSI NYELVEK TÖRTÉNETÉBE .............................................................................. 5 2. ARITMETIKAI ALAPISMERETEK ................................................................................................................ 13 3. RELÁCIÓS MŰVELETEK: ÖSSZEHASONLÍTÁS .............................................................................................. 19 4. LOGIKAI FÜGGVÉNYEK ............................................................................................................................ 19 5. BITMŰVELETEK: A FORGATÁS .................................................................................................................. 28 NYELVI ELEMEK RENDELTETÉSSZERŰ HASZNÁLATA ................................................................. 33 1. A FEJLESZTŐRENDSZER (IDE) ELINDÍTÁSA ............................................................................................... 34 2. AZ ELSŐ PROGRAM BEGÉPELÉSE, MENTÉSE, BEZÁRÁSA, MEGNYITÁSA, FUTTATÁSA .................................... 37 3. A TURBO PASCAL PROGRAM FELÉPÍTÉSE .................................................................................................. 43 4. A PROGRAM NYELVI ELEMEINEK ISMERTETÉSE ......................................................................................... 50 5. EGYSZERŰ PROGRAMPÉLDÁK .................................................................................................................. 60

Matematikai fejtörõk. Játékosság, leleményesség, logika, matematika.

LINEÁRIS PROGRAMOZÁSI MÓDSZEREK ALKALMAZÁSA ........................................................... 64

A Delphiről szóló könyvek tárháza emberi léptékkel mérve szinte kimeríthetetlen. Javaslom, hogy látogasson el a http://www.konyvkereso.hu-ra és ott keresen rá a „Delphi” szóra.

1. A PASCAL NYELV UTASÍTÁSAI ................................................................................................................. 65 2. A PASCAL NYELV ADATTÍPUSAI ............................................................................................................... 84 3. PÉLDAPROGRAMOK ................................................................................................................................. 95 4. RENDEZÉSEK .......................................................................................................................................... 97 MODULÁRIS PROGRAMOZÁSI TECHNIKÁK ALKALMAZÁSA..................................................... 101

Mégis ajánlanék néhányat, melyet mindenképp érdemes elolvasni: ANGSTER ERZSÉBET

Turbo Pascal 6.0 2.jav.kiadás

ANGSTER ERZSÉBET

Programozás tankönyv I. Strukturált tervezés, Turbo Pascal nyelven 7.jav.kiad.

BAGA EDIT

Delphi, másképp…

MARCO CANTÚ

Delphi 5 mesteri szinten 1 és 2 kötet (A szerző megjelent könyvei a Delphi 3-hoz, 5-höz és a 7-eshez)

Webhelyek http://matematika.lap.hu/ http://www.gtbbp.hu/~szabol/tetelek/programming/A/matlog.html http://hu.wikipedia.org/wiki/ http://www.math.u-szeged.hu/~hajnal/courses/logika00/logika00.htm http://www.sulinet.hu/tart/fkat/Kco http://prog.hu http://ebbokz.hu

1. ELJÁRÁSOK ........................................................................................................................................... 102 2. FÜGGVÉNYEK ....................................................................................................................................... 107 3. UNITOK ................................................................................................................................................ 110 OBJEKTUMORIENTÁLT PROGRAMOZÁSI TECHNIKÁK ALKALMAZÁSA................................ 114 1. OBJEKTUMORIENTÁLT PROGRAMOZÁSI ALAPFOGALMAK ........................................................................ 116 2. A DELPHI KERETRENDSZER ................................................................................................................... 124 3. PROGRAM KÉSZÍTÉSE DELPHIBEN .......................................................................................................... 136 4. EGY EGYSZERŰ DELPHI ALKALMAZÁS ELKÉSZÍTÉSE ............................................................................... 142 ESEMÉNYKEZELÉS ................................................................................................................................ 151 1. AZ ESEMÉNY-VEZÉRELT PROGRAMOZÁS................................................................................................. 152 2. AZ ÜZENET (MESSAGE) ......................................................................................................................... 153 3. A TFORM ESEMÉNYEINEK BEMUTATÁSA ................................................................................................ 155 MULTIMÉDIA ASSETEK KEZELÉSE ................................................................................................... 158 1. MULTIMÉDIÁS LEHETŐSÉGEK, HANGOK LEJÁTSZÁSA .............................................................................. 159 2. AZ ALKALMAZÁSOK KÖZÖTTI KOMMUNIKÁCIÓ ...................................................................................... 164 3. MULTIMÉDIÁS LEHETŐSÉGEK, VIDEÓK LEJÁTSZÁSA OLE KONTÉNERBEN ................................................ 168 NAVIGÁCIÓS SÉMÁK PROGRAMOZÁSA ........................................................................................... 173 1. MÉDIALEJÁTSZÓ PROGRAM CSÚSZKÁVAL............................................................................................... 174 2. MÉDIALEJÁTSZÓ PROGRAMUNK KIEGÉSZÍTÉSE HANGERŐSZABÁLYZÓVAL ............................................... 178 INTERAKTIVITÁS PROGRAMOZÁSA ................................................................................................. 183 1. EGYSZERŰ PÁRBESZÉDABLAKOK ........................................................................................................... 184 2. A MENÜ ................................................................................................................................................ 187 3. A WINDOWS DIALÓGUSABLAKAI ........................................................................................................... 192 AJÁNLOTT IRODALOM ......................................................................................................................... 196

196

197

198

Lineáris és objektumorientált programozási alapismeretek. Varga Zsolt

Recommend Documents