TartalomjegyzékProgramozás története.............................................................................................................................................6Programozási nyelvek generációi............................................................................................................................7

Első generációs programozási nyelvek...............................................................................................................7Második generációs programozási nyelvek........................................................................................................8

FORTRAN.....................................................................................................................................................9ALGOL..........................................................................................................................................................9COBOL..........................................................................................................................................................9BASIC..........................................................................................................................................................10RPG..............................................................................................................................................................11

Harmadik generációs programozási nyelvek....................................................................................................11PL/1 (Programming Language I.)................................................................................................................11APL (A Programming Language)................................................................................................................12PASCAL.......................................................................................................................................................12MODULA-2.................................................................................................................................................12ADA.............................................................................................................................................................13C nyelv.........................................................................................................................................................13Objektum-orientált programozási nyelvek...................................................................................................13Tiszta objektum-orientált nyelvek................................................................................................................14

SmallTalk.................................................................................................................................................14Eiffel........................................................................................................................................................14

Vegyes nyelvek............................................................................................................................................14Turbo Pascal............................................................................................................................................14Borland C++............................................................................................................................................14

Specializált programozási nyelvek...............................................................................................................14Rendszer- és fordítóprogramok fejlesztése.............................................................................................15Formulakezelő nyelvek...........................................................................................................................15Szimbólum-feldolgozó nyelvek..............................................................................................................15Szimulációs nyelvek................................................................................................................................15Adatbázis-kezelő nyelvek.......................................................................................................................15Kiterjeszthető programnyelvek...............................................................................................................15

Negyedik generációs programozási nyelvek....................................................................................................15Lekérdező nyelvek.......................................................................................................................................15Programgenerátorok.....................................................................................................................................16Egyéb 4 GL nyelvek.....................................................................................................................................16

Programozási nyelvek osztályzása........................................................................................................................16Felhasználói kör szerint....................................................................................................................................16

Amatőr nyelvek............................................................................................................................................16Professzionális nyelvek................................................................................................................................16

Számítási modell szerint...................................................................................................................................16Neumann elvű nyelvek.................................................................................................................................16Automata elvű nyelvek................................................................................................................................16Funkcionális nyelvek...................................................................................................................................17Logikai nyelvek............................................................................................................................................17

Felhasználói közelség szerint...........................................................................................................................17Gépi kód.......................................................................................................................................................17Alacsonyszintű nyelv...................................................................................................................................18Magasszintű nyelvek....................................................................................................................................18

Egyéb osztályozások.........................................................................................................................................18"Compiler" illetve "Interpreter" nyelvek.....................................................................................................18Procedurális illetve nem procedurális nyelvek............................................................................................18Deklaratív nyelv...........................................................................................................................................18Utasításorientált nyelv..................................................................................................................................18

1

Kifejezésorientált nyelv...............................................................................................................................18Objektum orientált nyelv.............................................................................................................................18Párhuzamos programnyelv...........................................................................................................................18

Programozási alapfogalmak..................................................................................................................................19Algoritmus........................................................................................................................................................19Program.............................................................................................................................................................19Programozó.......................................................................................................................................................19Programozás.....................................................................................................................................................19Forrásprogram...................................................................................................................................................19Programozási nyelv..........................................................................................................................................19A programozás szintjei.....................................................................................................................................19Szintaxis és szemantika leírás...........................................................................................................................20Szintaxisleíró eszközök....................................................................................................................................20Fordítás és értelmezés.......................................................................................................................................20Programkészítés és futtatás menete..................................................................................................................20Byte-kód fordítás..............................................................................................................................................21Case-sensitive, case-insensitive nyelvek..........................................................................................................22Megjegyzések...................................................................................................................................................22Kulcsszavak......................................................................................................................................................22

Programstruktúrák.................................................................................................................................................22Program.............................................................................................................................................................22Programcsomag................................................................................................................................................22Párhuzamos folyamat (taszk)............................................................................................................................22Fordítási egység................................................................................................................................................22Export-, importlisták.........................................................................................................................................22Programegység.................................................................................................................................................22

Eljárás, függvény, operátor..........................................................................................................................23Deklarációs rész, törzs.................................................................................................................................23

Blokkstruktúra..................................................................................................................................................23Programkészítés elvei............................................................................................................................................23

Stratégiai elvek.................................................................................................................................................23Taktikai elvek....................................................................................................................................................24Technológiai elvek............................................................................................................................................24Technikai elvek.................................................................................................................................................25Esztétikai-ergonómiai elvek.............................................................................................................................25

Programkészítés lépései.........................................................................................................................................27Feladat meghatározása (specifikáció)...............................................................................................................27Algoritmuskészítés...........................................................................................................................................28

Algoritmus...................................................................................................................................................28Algoritmussal szemben támasztott követelmények.....................................................................................28Algoritmikus elemek....................................................................................................................................28

Program...................................................................................................................................................29Értékadó utasítás.....................................................................................................................................29Beolvasó utasítás.....................................................................................................................................29Kiíró utasítás...........................................................................................................................................29Megjegyzések..........................................................................................................................................29Utasításblokk - szekvencia......................................................................................................................29Elágazás - szelekció................................................................................................................................30Ciklus - iteráció.......................................................................................................................................30Eljárás, függvények, operátor..................................................................................................................31

Műveletek csoportosítása.............................................................................................................................32Algoritmus leíróeszközök............................................................................................................................32

Folyamatábra (blokkdiagram).................................................................................................................32Struktogram.............................................................................................................................................35

2

Jackson diagram......................................................................................................................................36Mondatszerű leírás..................................................................................................................................37

Kódolás.............................................................................................................................................................38Tesztelés, hibakeresés, javítás...........................................................................................................................38

Hibaüzenetek értelmezése............................................................................................................................41Hibakeresés (Bedugolás)..................................................................................................................................41

Bedugolás technikák....................................................................................................................................42Kivételkezelés...................................................................................................................................................42Hatékonyságvizsgálat.......................................................................................................................................42

Hatékonyság fogalma...................................................................................................................................42Hatékonyságvizsgálat szempontjai..............................................................................................................43Hatékonyságvizsgálat szintjei......................................................................................................................43Globális hatékonyság...................................................................................................................................43Lokális hatékonyság.....................................................................................................................................43Algoritmus hatékonysága.............................................................................................................................43Programkód hatékonysága...........................................................................................................................43

Dokumentálás...................................................................................................................................................43Dokumentáció fajtái.....................................................................................................................................44Dokumentáció tulajdonságai........................................................................................................................45Dokumentáció általános alakja....................................................................................................................46Példa dokumentációra..................................................................................................................................48

Strukturált program...............................................................................................................................................49Típusok..................................................................................................................................................................50Adatok, adatszerkezetek........................................................................................................................................51

Változó..............................................................................................................................................................51Konstans...........................................................................................................................................................51Definíció, deklaráció.........................................................................................................................................51Azonosító..........................................................................................................................................................51Védett azonosítók.............................................................................................................................................52Azonosítók átlapolása (túlterhelés)...................................................................................................................52Hozzáférési jog.................................................................................................................................................52Kezdőérték........................................................................................................................................................52Hatáskör............................................................................................................................................................52Láthatóság.........................................................................................................................................................52Élettartam..........................................................................................................................................................52Típus.................................................................................................................................................................52Értékhalmaz......................................................................................................................................................52

Adat csoportosítása................................................................................................................................................52Egész típus........................................................................................................................................................53Valós típus.........................................................................................................................................................54Logikai típus.....................................................................................................................................................54Karaktertípus.....................................................................................................................................................54Felsorolástípus..................................................................................................................................................55(Rész)Intervallumtípus.....................................................................................................................................55Valós résztípus..................................................................................................................................................56Rekord...............................................................................................................................................................56Vektor/Tömb.....................................................................................................................................................56Mátrix...............................................................................................................................................................57Halmaz..............................................................................................................................................................57Szöveg...............................................................................................................................................................57Sorozat..............................................................................................................................................................58

Számábrázolások...................................................................................................................................................59Számábrázolás..................................................................................................................................................59Fixpontos ábrázolás..........................................................................................................................................59

3

Lebegőpontos ábrázolás....................................................................................................................................60Programozási tételek.............................................................................................................................................61

Programozási tétel fogalma..............................................................................................................................61Tételek megfogalmazásának elemei.................................................................................................................61Tételek alkalmazásának lépései........................................................................................................................61Tételek csoportosítása.......................................................................................................................................61Egy sorozathoz egy értéket rendelő tételek......................................................................................................61

Összegzés tétele...........................................................................................................................................61Megszámlálás tétele.....................................................................................................................................62Eldöntés tétele..............................................................................................................................................62Kiválasztás tétele..........................................................................................................................................63

Egy sorozathoz egy sorozatot rendelő tétele....................................................................................................63Másolás, transzformálás tétele.....................................................................................................................63Kiválogatás tétele.........................................................................................................................................64

Egy sorozathoz több sorozatot rendelő tétel.....................................................................................................64Szétválogatás tétele......................................................................................................................................64

Több sorozathoz egy sorozatot rendelő tételek................................................................................................65Metszetképzés tétele....................................................................................................................................65Unióképzés tétele.........................................................................................................................................66Összefuttatás tétele (UNIÓ).........................................................................................................................66Összefuttatás tétele (METSZET).................................................................................................................68

Keresési tételek......................................................................................................................................................68Lineáris keresés tétele.......................................................................................................................................68Logaritmikus keresés tétele..............................................................................................................................69

Rendezések************....................................................................................................................................69Rekurzió******....................................................................................................................................................72Objektumorientált programozás............................................................................................................................73

Objektumorientált programozás fogalma.........................................................................................................73Objektumorientált program jellemzői, alapfogalmak.......................................................................................74Futóverseny példa.............................................................................................................................................77Objektum-orientált tervezés..............................................................................................................................78Ábrázolás osztálydiagramon.............................................................................................................................78Objektumosztály definiálása, objektumok létrehozása.....................................................................................78

Linux alapok..........................................................................................................................................................79Python....................................................................................................................................................................83

Első lépések......................................................................................................................................................83Számolás Pythonban.........................................................................................................................................83Adatok és változók...........................................................................................................................................83Változónevek és foglalt szavak........................................................................................................................83 Értékadás, hozzárendelés.................................................................................................................................84Változó értékének a kiírása...............................................................................................................................84Változók típusadása..........................................................................................................................................85Operátorok és kifejezések.................................................................................................................................85A műveletek prioritása......................................................................................................................................85

GUI tananyag***************..........................................................................................................................86Programok feladatok**************.................................................................................................................86

Specifikáció készítés.........................................................................................................................................86A specifikáció során használható szimbólumok..........................................................................................86

Algoritmus készítés..........................................................................................................................................87Egyszerű konzol feladatok................................................................................................................................91Programok.........................................................................................................................................................91Beolvasás, kiíratás............................................................................................................................................91Típuskonverzió.................................................................................................................................................91Egyszerű műveletek..........................................................................................................................................91

4

Elágazások........................................................................................................................................................91Ciklusok............................................................................................................................................................91Vegyes feladatok...............................................................................................................................................91Menü a programban..........................................................................................................................................91Eljárást tartalmazó............................................................................................................................................91Függvényt tartalmazó.......................................................................................................................................91Összetett adattípusok........................................................................................................................................91Tömb.................................................................................................................................................................91Mátrix...............................................................................................................................................................91Rekord...............................................................................................................................................................91Tételek..............................................................................................................................................................91Keresési tételek.................................................................................................................................................91Rendezési tételek..............................................................................................................................................91Műveletek fájlokkal..........................................................................................................................................91GUI programok.................................................................................................................................................95OOP programok................................................................................................................................................95

5

Programozás története

1822­ben Charles Babbage, az angliai Cambridge egyetem hallgatójaként felismerte, hogy az akkori számító­eszközök nagy része, (például a csillagászati táblázatok, vízállásdiagramok, hajózási térképek kritikus hibákatés hiányosságokat tartalmaznak. (A hibák gyakran a emberi életébe is került.) Mivel a pontatlanságok forrásá­nak az emberi tényezőt tartotta, az volt az elképzelése, hogy gőzgépek segítségével a táblázatok és a diagramokkészítéséből és karban­tartásából kiiktatja a találgatásokat.Az egyik ilyen gép, a Difference Engine néven emlegetett szerkezet Babbage életének hátralevő részében ren­geteg idejét lekötötte. Még a brit kormányt is felkereste, hogy pénzügyi segítséget kérjen: az első kéréssel a szá­mítógép­tudományi kutatás finanszírozásához kért kormányzati támogatást. A Difference Engine 10 évnyi fejlesztése után Babbage felismerte, hogy az egy­funkciós gép kizárólag egyetlenművelet végrehajtására képes. Rájött, hogy ez igen komoly korlátozás, és egy időre felfüggesztette a munkát asokoldalú Analytical Engine fejlesztésének kedvéért. Ez a gép a modern számítógép alapelemeit tartalmazta, ésmegalapozta Babbage számára a „számítógép atyja” nevet. Az Analytical Engine nem nyert széles körben elismerést, mivel Babbage ugyanazzal a problémával küzdött,ami évszázadokra megkeserítette a programozók és az informatikusok életét: képtelen volt világosan dokumen­tálni és ezáltal közkinccsé tenni ötleteit! 1854 a következő állomásunk, amikoris Charles Boole elkészítette a nevét viselő szimbolikus logikai rendszert(Boole­algebra),  amelynek  igen  jelentős  szerepe van  a programozásban.  A rendszer  bevezette  a  „nagyobb,mint”, „kisebb, mint”, „egyenlő” és „nem egyenlő” fogalmát, és egy szimbolikus rendszer segítségével megje­lenítette ezeket a fogalmakat. 1890­ben az Egyesült Államok népszámlálási hivatala versenyt írt ki. Az 1880­as népszámláláskor az adatokösszesítése 7 évet vett igénybe, valamint a lakosság is növekedett, így a becslések szerint az 1890­es népszám­lálási adatok feldolgozása nem fejeződött volna be az 1900­as népszámlálás előtt. Ezért a verseny célja az volta,hogy fellendítse a számítástudomány iránti érdeklődést, és ennek eredményeként előálljon egy adatfeldolgozóberendezés, amely a kormány munkáját segíti.A versenyt Herman Hollerith német származású amerikai statisztikus nyerte. Az ötletét a Jaquard­féle szövő­gépek lyukkártyás módszeréből merítette. Jacquard módszerének kulcsa egy kártyasorozat alkalmazása, ame­lyen lyukak vannak elhelyezve, mégpedig úgy, hogy azok a kívánt mintát rajzolják ki. Ennek láttán találta ki,hogy a Jacquard deszkalapjaihoz hasonló perforált kártyákat adatfeldolgozásra is lehet használni.Egy kártyára egy ember adatait lyukasztotta. Maga a lyukasztás kézi munkával történt. Az adatok feldolgozásá­ra olyan rendszert használt, ahol a lyukkártyák elektromos érintkezők között mentek át. Ahol a kártyán lyukvolt, az áramkör bezárult. Így a lyukakat meg lehetett számolni. Ezzel dolgozta fel az USA 1890­es népszámlálási adatait, mindössze négy hét alatt.A lyukkártyás módszer egyébként később, több programozási nyelv kialakulására is hatással volt. Miután bebizonyította a technológia eredményességét, Hollerith más országokban is vállalta népszámlálási in­formációk feldolgozását. Ennek sikere láttán alapította 1896­ban a Tabulating Machine Company nevű céget,amelyből aztán 1924­ben megalakult az IBM. 1935­ben Konrad  Zuse  programozás történetének újabb meghatározó alakja kifejlesztette  Z­1  névre hallgatószámítógépét. Ez volt az első számítógép, amely reléket használt, és a kettes számrendszer segítségével szá­molt. Ez a gép a számítógépek modern korának előfutára. Zuse volt az, aki a világ első programozási nyelve, a Plankalkül kifejlesztésével 1946­ban megalapozta a mo­dern programozást. A nyelv megjelenése azért volt nagy áttörés, mert modern nyelvek összetevőinek nagy ré­szét, többek között a táblákat és az adatstruktúrákat is tartalmazta. 1945 a számítástechnika történetében újabb fontos állomást jelentett, felbukkant az a szó, amelytől mindenki hi­degrázást  kap: a hiba! 1945­ben Grace Murray  Hopper  (később Hopper admirális) a Harvard egyetemen aMark II Aiken­féle átkapcsoló kalkulátoron dolgozott. A gépekkel akkortájt folyamatosan probléma volt, és azegyik ilyen kellemetlen eset során, 1945. szeptember 9­én az egyik technikus felfedezte, hogy egy moly került agépbe. Az esettel kapcsolatban a következő naplóbejegyzés született: „Az első eset, amely során tényleges hibát(bug) találtam.” Ebből a bejegyzésből született a „gép hibakeresése” (debugged), valamint a „számítógép hi­bakeresése” (debugging a computer) és a „számítógépprogram hiba­keresése” (debugging a computer program)

6

kifejezés is. A 20. század közepétől felgyorsult a fejlődés. Egyre több fejlesztés történt: rengeteg különböző programnyelvjött létre, amelyek mindegyike rendelkezik egyaránt előnyös és hátrányos tulajdonságokkal. Megjelent az Internet, amely szintén nyelvek seregét hozta magával. Az Internet másik nagy előnye, hogy meg­könnyíti az információk és a programok megosztását másokkal, így a programozás és a programozási nyelvekiránti érdeklődés egyre nő, és ezt az érdeklődést az információk, ötletek és alkalmazások akadálytalan cseréjemég inkább fellendíti, vagyis a fejlődés nem áll meg.1952­ben Neumann János tervei elkészül az EDVAC, az első Neumann­elvek alapján épített gép volt . Első­sorban matematikai problémák megoldására lett specializálva, a programok „gép­függőek” voltak , a programo­zás tulajdonképpen nem volt más, mint adott utasítások sorozatának leírása. A programok megírása sok időtvett igénybe.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ésevolt   az   igény,   szerettek   volna   számítógépen   ennél   összetettebb   feladatokat   is   megoldani.   A   nehézkesprogramozási módszerek és a gazdasági élet – amely a vállalatok döntéseit alapvetően befolyásolja – dinamikusváltozásai nem igazán voltak összhangban egymással.  A hosszú,  nehéz munkával készített programok igengyorsan   elavultak,   és   máris   lehetett   hozzákezdeni   a   következő   írásához.   Tehát   új,   gyorsabb,   egyszerűbbprogramfejlesztési módszerekre volt szükség.Ebben az időben jelentek meg az első magas szintű programozási nyelvek, amelyek már nem a számítógép,hanem   az   emberi   gondolkodás   logikája   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.   Most   márnemcsak a problémamegoldás egyszerűsítése volt a cél, a programok szerkezeti felépítése, az emberi logikaminél  hatékonyabb kihasználása   lett  az  újabb  fejlesztések   irányvonala.  Megjelentek  az  általános célú  és  aspecializá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 eszközökre volt szükség, amelyeksegítségével   a   programozók   gyorsan   tudnak   hatékony   és   megbízható   alkalmazásokat   írni.   A   gyorsprogramfejlesztés   céljait   egy   az   emberi   gondolkodáshoz   közel   álló  módszer   teszi   lehetővé,   ugyanakkor   aprogramnak nem szabad hatékonyságát elveszítenie, tehát minél elemibb egységekből kell felépíteni. Mindkétigényt kielégítette az objektum­orientált programozási technika, amely a valódi tárgyakhoz hasonlóan képeskezelni   a   rendszer   absztrakt   elemeit.   Azaz   a   programozónak   rendelkezésére   állnak   az   előre   definiáltprogramelemek, amelyekből összeállíthatja a működőképes programot. Annak érdekében, hogy a problémánakleginkább megfelelő  alkalmazást lehessen előállítani, az egyes elemek tulajdonságait a programozó   tetszéseszerint módosíthatja.A ’90­es évek második felére jellemző a legújabb programozási technikák kialakulása, amelyek esetében márnemcsak egy probléma megoldására nyílik lehetőség, komplex információs rendszereket kezelhetünk általuk.Ezen a szinten a programozónak már nem arra kell koncentrálnia, hogy hogyan oldja meg a problémát, sokkalfontosabbá  válik a mivel kérdése.  A legfejlettebb programozási  rendszerek már automatikusan generálják akódot, ezzel a programozónak már nem kell foglalkoznia. Ezek a rendszerek sok esetben nemcsak a programhelyességét  ellenőrzik,  hanem a problémamegoldás  hatékonyságát   is.  Ezáltal  a  programozónak kizárólag amegoldandó  probléma lényegére kell  figyelnie,  megkeresheti  a  kritikus pontokat a  programban,  és mindenkorábbi lehetőségnél hatékonyabban optimalizálhatja annak működését.Az évek során igen sok programozási nyelv alakult ki, amelyeket szemléletük, fontosabb jellemzőik alapjánnégy generációba soroltak.

Programozási nyelvek generációi

Első generációs programozási nyelvekAz   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   voltközvetlenül,   minden   átalakítás   nélkül   végrehajtani,   értelmezni.   A   problémákat   nagyon   precízen   kellettmegfogalmazni, lépésekre bontani. Emellett a nyelv erősen gépfüggő  volt, hiszen minden gépen más és másutasításokat  használt,  az adott  problémát  minden géptípus esetén másképpen kellett   leírni,  megfogalmazni,

7

alkalmazkodva   a   számolóegység   sajátosságaihoz.   (A   gépi   kód   mai   napig   sem   egységes   a   különbözőprocesszorok esetében.)A gépi nyelv olyan utasításokból állt, amelyek a gép számára közvetlenül értelmezhetőek voltak, az emberinyelvektől azonban igen messze állt a gépi logika.Hátrányai mellett néhány előnyt is meg kell említenünk:

• A leggyorsabb programot eredményezi, mivel nem tartalmaz felesleges utasításokat.• Az egyes utasítások egységes formában vannak leírva.• Az első generációs nyelvek nagy érdeme, hogy bevezették a kifejezés fogalmát. Itt jelenik meg az egész

és valós típus, illetve néhány egyszerű vezérlési szerkezet.Példa egy gép kódú utasításra:0B0A 0C0E 0D00Az első négy számjegy az utasítás, a második négy számjegy az első memóriacím, a második négy számjegy amá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, amelyektulajdonképpen segédeszközt jelentettek a gépi kódú utasítások egyszerűbb megfogalmazásában. Az egyes gépikódú  utasításokhoz egy­egy mneomnikus kódot rendeltek hozzá,  a  tárcímeket pedig a memória  kezdetéhezviszonyí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. Egy összeadás Assembly nyelven:ADD X, YAz 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ímszimbolikusan megadható, de a programozás logikája továbbra is követni a gépi logikát.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.   Az   Assemblyvirágkorában   az   operációs   rendszerek   tartalmazták   az   Assembly   fordítót.   A   fordítóprogramok   compilertípusúak  voltak.  Az Assembly   legtöbb utasítása  egyetlen  gépi  utasítást   reprezentált,  azaz  az Assembly 1:1tipusú nyelv. Volt néhány utasítás, amely több gépi kódú utasítást jelentett, ezeket makróknak nevezték.Az Assembly nyelv a gépi kódú programozás után igen nagy előrelépést jelentett, általa sokkal kényelmesebbévált a programfejlesztési munka. Napjainkra az alacsony szintű programozási nyelvek háttérbe szorultak. AzAssembly­t ma már csak olyan feladatok esetén használják, ahol hardver szintű vezérlést kell megvalósítani. Avisszaszorulásuknak sok oka mellett két fontosabbat szeretnék mindössze kiemelni:

• A processzorok utasításkészlete ma is különböző, ezért a gépi kódban írt program nem hordozható.• Az alacsony szintű programozási nyelvek aprólékos, átgondolt munkát feltételeznek egyszerű problé­

mák esetén is. A mai kor követelménye pedig a gyors, látványos, rövid idő alatt elkészülő programokfelé mutat.

Második generációs programozási nyelvekA 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ökken­té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 ésaz 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árnem 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. Minél függetlenebb egy programozási nyelv a gépi logikától, annál magasabbszintű, annál magasabb minőségi követelményeknek tud eleget tenni.A magas szintű programozási nyelvek 1:N típusú nyelvek, azaz egyetlen magas szintű programnyelvi utasítástö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, aforrásprogram sokkal áttekinthetőbb lett.A magas szintű  programozási  nyelvek már sokkal közelebb állnak az emberi logikához, mint elődük, jóvalegyszerűbben, világosabban le lehet írni segítségükkel a problémát. Egy összeadási művelet assembly­ben, il­letve magas szintű programozási nyelvben:

8

mov x,10mov y,12add x,ymov sum,x

X=10Y=12SUM=X+Y

FORTRANAz első magas szintű programozási nyelv az IBM cég által kidolgozott FORTRAN volt. 1957­ben jelent meg,elsősorban a műszaki­tudományos számítások legősibb nyelve. Nevét a Formula Translation szavak összevoná­sából kapta.Elsősorban matematikai formulákat tartalmazó elágazások kezelésére volt alkalmas, a numerikus algoritmusokszéles körét támogatta, viszont az I/O műveletek, és a karakteres adathalmazok kezelése szempontjából nem bi­zonyult hatékony nyelvnek. Az I/O műveleteket mindössze alapvető függvények által valósította meg, a nyelvelsődleges célja a matematikai problémák megoldása volt, ehhez a speciális területhez azonban nagyon haté­kony eszköznek bizonyult.A nyelv szerkezetét vizsgálva azt tapasztaljuk, hogy a programok két részből állnak:

• főprogramból, amely a PROGRAM és END utasítások között helyezkedik el.• egymásba  nem ágyazható   alprogramokból,   szubrutinokból,   amelyek  a  FUNCTION...END,   illetve   a

SUBROUTIN...END utasítások között helyezkednek el. A fordítóprogram az egyes szerkezeti elemeket külön fordítja, a különböző tárgyprogramokat kell összeszer­keszteni, hogy futtatható programot kapjunk.A FORTRAN képességeinek növelésén a fejlesztők igen sokat fáradoztak. A nyelvnek igen sok szabványosítottváltozata jelent meg. 1966­ban a FORTRAN 66, 1977­ben a FORTRAN 77 ANSI, és ezek mellett készültek ela FORTRAN II., IV. és V. változatok. Az utolsó szabványosított változat a FORTRAN 90 volt, melyek ma ishasználnak a tudományos számítások programozására.Bár napjaink igényei az univerzális nyelvek felé mutatnak, a FORTRAN mégis megmaradt a műszaki és tudo­mányos számítások nyelvének. Jelenleg folyamatban van ­ vagy már elkészült ­ a legújabb verzió, a FORTRAN2000.

ALGOLA FORTRAN­hoz hasonlóan, úttörő nyelv volt a magas szintű nyelvek sorában. 1955­ben fejlesztették ki, amatematikai, műszaki számítások célnyelveként.Az első véglegesnek tekintett változatot 1960­ban fogadták el egy párizsi konferencián, neve ALGOL 60 volt.Később, több lépcsőben történő fejlesztés után megjelent a nyelv egy újabb változata, az ALGOL 68.Mindkét változat támogatta a moduláris programozást és a dinamikus tárolóelhelyezést (hasonló a mai muta­tókhoz). Új lehetősége volt a rekurzív alprogramok írása.Az ALGOL viszonylag kis utasításkészlettel rendelkezett, azonban szintaktikája nagyon hasonlított az emberibeszédre (Bacus­Naur Forma). A nyelv szimbólumrendszere azonos volt a matematikában alkalmazott szimbó­lumrendszerrel,  ami az ilyen jellegű  problémák programozását  nagyon megkönnyítette.  A programban lévőblokkok önálló egységeket képviseltek, az alprogramokat egymásba lehetett ágyazni.Az ALGOL szabad formátumú nyelv, az utasítások tetszőleges helyre írhatók. Minden utasítást ;­vel kell lezár­ni. A főprogram kezdetét a PROCEDURE szó jelzi, a program végét az END. Mindkettő után meg kell adni aprogram nevét. A programban használt változókat deklarálni kell, a deklarációk a blokkok elején helyezkednekel.Az ALGOL nyelv elsősorban a kutatómunkában és az oktatás területén terjedt el. Első számú alkalmazási terü­lete az informatikai kutatás volt. Jelentősége azonban vitathatatlan, mivel számos később kialakult programozá­si nyelv alapjaként szolgált. Pl.: PASCAL.

COBOLAz eddigiekben tárgyalt programozási nyelvek elsősorban a matematikai, műszaki számítások területét támo­gatták sikeresen. Szükség lett volna egy olyan nyelvre is, amely az adatfeldolgozást, az információs rendszerekkezelését   segíti,   támogatja.  Az Amerikai Védelmi Minisztérium finanszírozásával 1959­ben  létrejött  a  CO­DASYL (Conference on Data Systems Language) bizottság, és lefektette az alapokat egy új, a gazdasági, keres­

9

kedelmi életben jól használható adatfeldolgozás­orientált programozási nyelv kifejlesztéséhez. 1963­ban szüle­tett meg a COBOL (Common Business Oriented Language), amely alkalmasnak látszott a gazdasági életben va­ló alkalmazásra is. Az Amerikai Szabványügyi Hivatal (ANSI) 1968­ban elfogadta, majd újabb fejlesztésekután 1974­ben szabványossá nyilvánította a nyelvet.A COBOL megjelenése után hamar népszerűvé vált, mert minden számítógéptípuson alkalmazható nyelv volt.Kiterjedt lehetőségeket biztosított az adatállományok létrehozására, karbantartására és lekérdezésére. A COBOL kötött szerkezetű programozási nyelv volt, 4 szerkezeti blokkból épült fel:

• Identification Division:Azonosító rész. Olyan információkat tartalmaz, mint a program és a programozó neve, készítési idő­pontja stb. 

• Environment Division:Környezethívó rész. A futási környezet meghatározását, az alkalmazandó perifériák hivatkozásait tartal­mazza. 

• Data Division:Adatleíró rész. Az alkalmazandó állományok és adatstruktúrák leírását tartalmazza. 

• Procedure Division:Az eljáráshívó rész. A feldolgozandó adatokkal végzett műveletek, utasítások leírása.

A COBOL nyelvet ma is használják az adatfeldolgozás területén. Az első változathoz képest a nyelv igen nagyváltozásokon ment keresztül, nagyon sokat fejlesztették az évek során. 1989­ben jelent meg a strukturált, né­hány évvel később az objektumorientált változata. A COBOL nyelv előnyeként meg kell említeni a kiváló do­kumentálási lehetőségeket, a komplex adathalmazok kezelésének jelentős könnyítését. Hátránya viszont, hogy aprogramok mérete igen nagy lesz, és az alapvető matematikai műveleteken túl nem támogatja a bonyolultabbszámítási feladatokat.

BASICA BASIC nyelv kialakulása a programozási nyelvek fejlődésének bölcsőjéhez vezet vissza, amikor a magyarszármazású Kemény János és munkatársa, Thomas Kurtz elhatározták, hogy kidolgoznak egy olyan programo­zási nyelvet, amelynek segítségével a programozás könnyen oktatható és tanulható. A köztudatban a BASICnyelv a kezdő programozók nyelveként vált ismertté.Az ötlet a 60­as évek elején született, amikor megjelentek az első Time­sharing (időbeosztásos) rendszerek, és aközponti számítógépen tárolt adatokhoz egyre több felhasználó férhetett hozzá. A felhasználóknak szükségükvolt egy olyan programozási nyelvre, amelynek segítségével megvalósíthatták a központi adatokhoz való inter­aktív hozzáférést. A FORTRAN és COBOL nyelvek batch üzemmódban készültek, ezért nem voltak alkalma­sak az adatok dialogikus feldolgozására, igény volt egy általános célú, interaktív, eljárás­orientált programozásinyelv létrehozására. Az első ilyen interpreter típusú nyelv a BASIC volt, amely nagymértékben egyszerűsítettea programok írását és tesztelését.A BASIC (Beginners All­Purpose Symbolic Instruction Code) nyelv első működő változata 1963­ban jelentmeg. A nyelv valójában a FORTRAN egyszerűsített változata volt, korlátozott utasításkészlettel és egyszerűszimbólumrendszerrel. A FORTRAN­nél lényegesen hatékonyabb támogatást nyújtott a karakteres adatok és az I/O műveletek keze­léséhez, szintaktikája közel állt az emberi gondolkodáshoz.Az első változatok utasításkészlete még nem tette lehetővé a struktúrált programozást, gyakran kellett alkalmaz­ni az ugró utasításokat (GOTO). A BASIC­ben a programok végrehajtása utasításonként történt (INTERPRE­TER módban), ami gyakorlatilag nagyon megkönnyítette a programok tesztelését.Az első változattól kezdve a nyelv nagyon sok változtatáson ment keresztül, nagyon sok változata jelent meg,újabb és újabb lehetőségekkel bővítve a nyelvet. A fontosabb változatok a QUICK BASIC, GFA BASIC, MS­BASIC, és a Pascal elemet is tartalmazó VISUALBASIC.A változatok közül egyedül a VISUAL BASIC­et tekintjük strukturált programozási nyelvnek, a programblok­kok és eljárások, függvények kezelése miatt.

10

RPGA 60­as évek végén jelent meg egy új, az IBM cég által kidolgozott programozási nyelv, amely a COBOL­hozhasonlóan az adatfeldolgozás támogatását tűzte ki célként, de a megvalósítás során teljesen eltérő filozófiát al­kalmazott. Ez a nyelv volt  az RPG (Report  Program Generator). Ellentétben az eddig tárgyalt  procedurálisnyelvekkel, az RPG a nyelvbe épített, előre definiált standard elemekkel dolgozott. A technikát arra alapozták,hogy minden üzleti típusú jelentés, kimutatás gyakorlatilag azonos felépítésű. Az RPG volt az első listagenerálóprogramozási nyelv. Lehetővé tette a bonyolult adatok gyors és egyszerű feldolgozását, és emellett viszonylagkis memóriát igényelt. Hátránya volt, hogy nem támogatta a bonyolultabb számításokat, ezek elvégzéséhez As­sembly rutinokat kellett beszúrni.A nyelvnek sokféle változata született, sokáig próbálták fejleszteni, piacon tartani. Ennek ellenére korlátozottfelhasználási területe miatt háttérbe szorult.

Harmadik generációs programozási nyelvekA 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 2 GL nyelvektöbbsége egy­egy problémacsoport megoldására specializálódott, ami a programok fejlesztése, javítása soránigen komoly akadályokat jelentett.A 60­as évek derekán kíséreltek meg először olyan programozási nyelvet fejleszteni, amely rendelkezik a 2 GLnyelvek jó tulajdonságaival is, emellett többféle problémacsoport megoldására alkalmas, univerzális. Az új kor­szakot a procedurális programozási szemlélet és az adatok struktúrájának hangsúlyozása jellemezte.Megszülettek az első 3 GL nyelvek, amelyeket még ma is használnak. Ezek a programnyelvek már igen sokféleprobléma megoldására alkalmasak, de minden problémára optimális programozási lehetőséget biztosító progra­mozási nyelv nem létezik. A 3 GL nyelveket három csoportra oszthatjuk:

• általános célú, magas szintű nyelvek• objektum­orientált nyelvek• specializált nyelvek

Az általános célú programozási nyelvek  családjába tartozó nyelvek széleskörűen alkalmazhatók a gazdaságiszámításoktól a rendszerprogramozási fejlesztésekig, széles a lehetőségek skálája. Néhány ismertebb, szélesebbkörben elterjedt 3 GL programozási nyelv: PL/1, APL, PASCAL, Modula­2, ADA, C.

PL/1 (Programming Language I.)A PL/1 programozási nyelvet az IBM cég fejlesztette ki, az első változata 1964­ben jelent meg. Ez a nyelv mégnem igazán sorolható a harmadik generációs programozási nyelvek közé, de mivel igen sokféle feladat megol­dására alkalmas, megérdemli a 3 GL elnevezést.A PL/1 szabad formátumú nyelv, amely a FORTRAN, az ALGOL és a COBOL nyelvek előnyeit egyesíti ma­gában. Egyaránt alkalmas az adat­feldolgozási és a számítási problémák megoldására, emellett a program szerkezeteegyszerű és követhető, formai előírásai nem túl szigorúak.A programok blokk­szerkezetű felépítése már a strukturáltság koncepcióját vetíti előre. A program tartalmazegy főprogram részt, amely külön blokkokban több alprogramot foglalhat magába, az alprogramok egymásbaágyazhatók. A fordító a deklarációkat utólag helyezi el a program elején.A PL/1 előnyei:

• mindenféle alkalmazáshoz jól használható• könnyen tanulható, egyszerű nyelv• bonyolult feladatok megoldására is alkalmas• szabad formátumú programozást tesz lehetővé• blokkszerkezete jól illeszkedik a struktúrált programozási szemlélethez, az eljárások, függvények jól el­

választhatók egymástólAz első verziót újabb és újabb változatok követték, 1976­ban jelent meg az oktatáshoz is jól alkalmazható vál­tozata a PL/C.Bár a PL/1 univerzális programozási nyelv, mégis csak az IBM gépek alkalmazói körében terjedt el, aminek

11

oka a megjelenés időpontjában keresendő. Ekkorra már a programozók többsége megismerte a FORTRAN és aCOBOL használatát, és nem kívántak egy újabb nyelvre áttérni, főleg mivel ez a nyelv az előző kettő integráci­ójának tekinthető, igaz tartalmaz néhány újdonságot.

APL (A Programming Language)Az APL egy a matematikai problémák megoldására orientálódott, többcélú (de nem általános) programozásinyelv volt. A nyelvet Kenneth Iverson, amerikai matematikus dolgozta ki, elsősorban műszaki, tudományos al­kalmazások fejlesztése céljából. Az APL programok egyik sajátossága, hogy kezelik a görög betűket, beépített (implicit) lehetőségei közé tar­toznak az egy­ és többdimenziós tömbökkel végzett műveletek. A nyelv szimbólumrendszere és szerkezete szabad formátumú. Az APL programok írásához speciális billentyű­zetre van szükség (a görög betűk és a speciális operátorok miatt). Az APL nyelv nem támogatja a struktúráltprogramozást, így nagyobb feladatok megoldását nehézkessé teszi, de a nagy számban rendelkezésre álló beépí­tett operandussal kiválóan alkalmas prototípusok gyors készítésére.A 70­es, 80­as években műszaki, tudományos és gazdasági problémák megoldásra egyaránt hatékonyan hasz­nálták.Az újabb változatok (APLG) támogatják a grafikus feldolgozást is, manapság a numerikus számítógépek műkö­désének leírásához használják.

PASCALA PASCAL nyelv volt az első igazi és legteljesebb körű megvalósítása a strukturált szemléletű programozás el­veinek.Niklaus Wirth professzor, a zürichi Műszaki Főiskola oktatója dolgozta ki a nyelvet a 70­es években, és BlaisePascal francia matematikus­filozófusról nevezte el.Wirth professzor az ALGOL programozási nyelv alapján definiálta a PASCAL szabályait, a cél egy az AL­GOL­hoz hasonló, de általános célú programozási nyelv elkészítése volt.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.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 fog­lalt szóval érnek véget. Minden utasítás végére ;­t kell tenni. A PASCAL nyelv támogatja a moduláris progra­mozást, függvények és eljárások definiálhatók a FUNCTION és a PROCEDURE foglalt szavak segítségével. Afüggvények, eljárások egymásba ágyazhatók, sőt a nyelv támogatja a rekurziót 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. APASCAL nagyon jó alapot biztosít más programozási nyelvek tanulásához, a strukturált programozás alapelvei­nek megértéséhez.

MODULA­2Amint a nevéből is lehet következtetni, olyan programozási nyelvről van szó, amely igen magas szinten támo­gatja a moduláris programozás módszerét, azaz a feladatok részfeladatokra bonthatók és az egyes részeket kü­lön lehet programozni, fejleszteni. Az egyes modulok az utasítások mellett tartalmazzák a modul során felhasz­nált adatokat, változókat, konstansokat is.A modulok hierarchikus felépítésűek, tehát  egymásba ágyazhatók. Célszerű  élni ezzel a lehetőséggel, annakérdekében, hogy az egyes alprogramok egymással megfelelően tudjanak kommunikálni. A nyelv támogatja arekurzív alprogramok mellett, a párhuzamos vezérlőszerkezetek készítését is. Ez utóbbi lehetőség a verseny­helyzetben álló folyamatok programozásánál lehet hasznos (multitasking). A nyelv egyik nagy előnye, hogy amoduláris felépítésű programok könnyen áttekinthetők, értelmezhetők egy esetleges módosításkor. Manapság isnépszerű nyelv, majdnem minden operációs rendszerhez beszerezhető a fordítóprogramja.

12

ADAA ’70­es évek közepén fejlesztették ki ezt a Pascal­hoz hasonló nyelvet, amely nagyon hatékonyan alkalmazha­tó mind a rendszerszintű programok írása során, mind a komplex gazdasági számítások megoldásakor. A nyelvAugusta Ada Byron­ról kapta a nevét, akit Charles Babbage munkatársaként az első női programozóként említaz informatika története.Az ADA nyelv fejlesztésének célja egy hatékony, teljes gépfüggetlenséget biztosító programozási nyelv létre­hozása volt. Éppen ezen törekvések miatt az ADA nyelv nagyon sok lehetőséget biztosít, a fontosabbak: mult­itasking, kommunikáció, megszakítás­kezelés. Az ADA programok moduláris felépítésűek, az egyes modulokatPackage­nek nevezzük. Ezek az egységek gyakorlatilag egymástól függetlenül elkészíthetők és lefordíthatók. Amodulok hivatkozhatnak egymásra a USE kulcsszó segítségével.A nyelv sajátossága, hogy az egymástól csak néhány ponton eltérő modulokat a GENERIC és NEW kulcssza­vak segítségével egymásból  származtathatjuk. Ez a tulajdonság már az objektum­orientált  nyelvek irányábamutat előre.A nyelv előnye, hogy támogatja a multitaskos működést, amely ma már alapvető követelménynek számít. Amegírt program áttekinthető, könnyen módosítható, a moduláris felépítés miatt. A nyelv szerteágazó lehetőségeiszinte minden területen használhatóvá teszik, ugyanakkor ebben a komplexitásban kereshető a nyelv hibája is.Az ADA egyik gyenge pontja, hogy bonyolult és sajátságos szemantikával rendelkezik, amely más nyelvek ese­tén nem jellemző, ezért tanulása elég nehéz feladat.

C nyelvA rendszerprogramozás fejlődése során mérföldkőnek tekinthetjük az 1972­ben megjelent C nyelvet. Megalko­tó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ű for­dítóprogramokat. A nyelv különlegessége, hogy egyesíti magában a hardverközeli programozás és a magasszintű 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 se­gí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 is­meri. Az eljárásokat visszatérési érték nélküli függvényként definiálhatjuk. Lehetőség van rekurzív alprogra­mok készítésére is.A C nyelv nagyon erősen támaszkodik a mutatókra. Előnyös a C programok írása során kihasználni a mutatókadta lehetőségeket, mert programunk ezáltal gyorsabb, hatékonyabb lehet.Típuselőírásai sokkal engedékenyebbek, mint azt a Pascal nyelv esetén tapasztaltuk, bár az automatikus típus­deklarációt nem támogatja, a konverziók terén igen nagy szabadságot biztosít a programozónak.A C nyelv utasításai mindössze a strukturált programok készítéséhez szükséges utasításokra korlátozódnak:

• Összetartozó utasítások (utasításblokk {})• Kétirányú elágazási szerkezet (if … else)• Esetszétválasztás (switch … case … )• Ciklusszervező utasítások

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örbenhasználják, első számú alkalmazási területe a rendszerprogramozás. A mai követelményeknek megfelelő C vál­tozatok a C++, az objektum­orientált lehetőségekkel bővített C nyelv, és a Concurent C, a párhuzamos folya­matok programozását segítő eszköz.

Objektum­orientált programozási nyelvekAz utóbbi években kezdett széleskörűen elterjedni egy új szemléletű programozási technika, az objektum­orien­tált  programozás,  amely az elődeinél  egyszerűbbé,  hatékonyabbá,  biztonságosabbá   teszi  a  programkészítésimunkát.Az objektum­orientált programozási nyelvek absztrakt adattípusokkal és a hozzájuk tartozó előre definiált algo­ritmusokkal segítik a programozó munkáját. Az objektum­orientált nyelvek az adatokat és az őket kezelő eljá­

13

rásokat, függvényeket egységbe foglaltan ún. objektumként kezelik.Az objektum­orientált programozás lényege, hogy a programozás során felhasznált elemeket a nyelv előre de­finiá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ése – illetve a feladatnak megfelelő elvárások szerint – megváltoztatnia.Egy egyszerű példán szemléltetve:A nyelvben előre definiált objektum a Kor, amely egy kör rajzolását teszi lehetővé. A Kor objektum:Type Kor=object

Szin: Integer;Sugar: Integer;X: Integer;Y: Integer;

        Procedure Rajzol;End;A Kor objektum felhasználása:…Kor.Szin:= Green;Kor.Sugar:= 120;Kor.X:= 200;Kor.Y:= 300;Kor.Rajzol;…Ez a programozási technika sokkal közelebb áll az emberi gondolkodáshoz, mint a procedurális programozás.Az objektum­orientált  programozás  elterjedésével  sok új  nyelv  jött   létre,  amelyek  tiszta objektum­orientáltnyelvek, más technikát egyáltalán nem támogatnak. Sok nyelvet kibővítettek az objektum­orientált technika al­kalmazásának lehetőségével, ezek az ún. vegyes nyelvek.

Tiszta objektum­orientált nyelvekSmallTalkA ’70­es évek elején fejlesztette ki Adele Coldberg és munkatársa Alan Kay azzal a céllal, hogy egy rugalmas,felhasználóbarát programozási környezetet biztosítson a fejlesztők számára. Manapság is széles körben használtprogramozási nyelv.

Eiffel1988­ban dolgozta ki a nyelvet Bertold Meyer. Objektum­orientált, erősen típusos nyelv. A hordozhatóság ér­dekében a megírt programot C nyelvre is le lehet fordítani. A szakemberek szerint az egyik legjobb objektum­orientált programozási nyelv.

Vegyes nyelvekTurbo PascalA 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. A6.0 verzióba már került egy előre definiált objektumrendszer – TVISION – is, amely a szöveges felületű prog­ramok készítése során használható fel hatékony segédeszközként.Borland C++A C++ elnevezés a hagyományos C nyelv objektum­orientált lehetőségekkel bővített változatát jelenti. A Bor­land C++ 3.1 verzió már támogatja az objektum­orientált technika alkalmazását. Hasonló környezetet és objek­tumrendszert biztosít, mint a Turbo Pascal 6.0.

Specializált programozási nyelvekMa már a számítógépet a tudományos és kutatómunka igen sok területén is felhasználják. Ezek a területekolyan speciális igényeket támasztanak a számítógépekkel szemben, amelyek megoldásához hasonlóan speciáliseszközökre van szükség. Ezen problémák támogatása érdekében fejlesztették ki a specializált  programozási

14

nyelveket, amelyek sokszor csak igen szűk problémacsoportok megoldására alkalmasak. Ez mégsem említhetőhátrányként, hiszen éppen ezért alkották őket: egy­egy probléma megoldásához hatékony segítséget biztosíta­nak.Rendszer­ és fordítóprogramok fejlesztéseA programfordítók fejlesztéséhez olyan magasszintű 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 biten­kénti műveletek végzését, mégis rendelkezik a magasszintű nyelvek előnyeivel.Ilyen nyelvek: B, C, BCPL, Pascal.Formulakezelő nyelvekNagy pontosságot igénylő, bonyolult matematikai, műszaki számítások számítógép által történő elvégzéséhezbiztosítanak hatékony segítséget ezek a nyelvek.Például: FORMAC, REDUCE, MACSYMA.Szimbólum­feldolgozó nyelvekNagy mennyiségű szöveges információk, hosszú listaadatok értékelésére, elemzésére kidolgozott célnyelvek.Felhasználási területük az információkutatás, a matematikai kutatások.Például: PROLOG, CONVERT, LISP, SNOBOL, COGENT.Szimulációs nyelvekNagyon sok területen használatos nyelvek, kísérletek, folyamatok eredményeinek előrejelzését segítő eszközök.Például: SIMSCRIPT, SIMULA, GPSS.Adatbázis­kezelő nyelvekAdatbázisokban tárolt adatok kezelését segítő programozási nyelvek. Segítségükkel lekérdezhetjük, módosít­hatjuk, karbantarthatjuk az adatbázisban tárolt adatokat.Kiterjeszthető programnyelvekA harmadik generációs programozási nyelvek legfejlettebb változatai. A programozási feladat megoldásához anyelv csak egy minimális bázist definiál előre. A hiányzó eszközöket azonban a programozó maga állíthatja előa már létező elemek segítségével.Például: LOGO, FORTH.

Negyedik generációs programozási nyelvekA XX. század második felében a számítástechnika forradalmi változáson ment keresztül. A Neumann elvekmegjelené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 fej­leszté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. A hardver eszközök rohamos fejlődésére támaszkodva kezdett ki­alakulni a programozás során egy új szemlélet, mely az eddigi alapelvekkel szöges ellentétben állt.A 4 GL nyelvek előnyösen egyesítik a procedurális és a non­procedurális nyelvek elemeit, lehetőségeit, kihasz­nálva mindkét nyelv előnyeit, és kiküszöbölve a hátrányok jelentős részét. A programok (programrendszerek)tervezése során a programozónak már nem a hogyan kérdésre kell válaszolnia, csak azzal kell törődnie, hogymit szeretne megvalósítani. A legújabb programozási nyelvek esetében már nem az algoritmust, hanem az el­érendő célt kell megfogalmazni, a kód generálását legtöbb esetben a fejlesztő rendszer automatikusan végzi el.Fontos jellemzője a nyelveknek, hogy nemcsak a program szintaktikai helyességét ellenőrzik, hanem megvizs­gálják a program hatékonyságát, rendszerbe illeszthetőségét is.Meg kell említenünk a 4 GL nyelvek nyilvánvaló előnyei mellett néhány rossz tulajdonságot is. A program ha­tékonyságának növekedésével egyenes arányban nő a program hardverigénye – elsősorban memória – igényeis, a lefordított program méretéről nem is beszélve. A gyakorlati alkalmazások kb. 25%­a fejleszthető optimáli­san a 4 GL programozási nyelvek valamelyikével, a maradék 75% esetében továbbra is hatékonyabb eszköznekbizonyulnak a 3 GL nyelvek.

A 4 GL nyelvek osztályozásaLekérdező nyelvekBiztosítják az adatbázisok adataihoz történő hozzáférést, akár egyszerű lekérdezésről, akár az adatok módosí­

15

tásáról, rendezéséről, vagy az adatbázis bővítéséről van szó.ProgramgenerátorokLehetővé teszik, hogy a felhasználó egy előre definiált minta alapján egyszerűen és hibátlanul hozzon létre egyharmadik generációs programnyelvi alkalmazást.Egyéb 4 GL nyelvekEbbe a csoportba sorolhatjuk a döntéstámogató   rendszerek fejlesztésére használatos nyelveket,  a  prototípusnyelveket (modellezést, tervezést segítő nyelvek), és a formális specifikáció nyelveit.

Ötödik generációs programozási nyelvekA XX. század második felében a számítástechnika forradalmi változáson ment keresztül. A Neumann elvekmegjelené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 fej­leszté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. A hardver eszközök rohamos fejlődésére támaszkodva kezdett ki­alakulni a programozás során egy új szemlélet, mely az eddigi alapelvekkel szöges ellentétben állt. 

• •  Párhuzamos programozás • •  Hálózatok programozása

Programozási nyelvek osztályzásaFelhasználói kör szerintAmatőr nyelvek(Pascal, Logo, Elan, Prolog 1. része, Basic)

• mérnök, tanár, közgazdász, stb. használja,• egyszerű programszerkezet,• sok nyelvi elem (a felhasználót így nem kell terhelni az alapeljárások megírásával),• sok gépfüggő elem (saját gépen saját célra való felhasználás miatt),• interaktivitás (könnyen, gyorsan lehessen kipróbálni, módosítani a programokat, mivel a nemhivatásos

programozó több hibát ejt),• gyors fejlődés.

Professzionális nyelvek(Pascal, Prolog 2. része, Modula­2, Ada)

• programozó használja,• kevés nyelvi elem, szűkebb utasításkészlete (mindent a programozónak kelljen megírni),• modularatás (modulokra bonthatóság),• hordozhatóság (gépfüggetlenség),• viszonylagos stabilitás (nem jó, ha nagy programokat gyakran újra kell írni, viszont jó, ha az újabb vál­

tozatok felülről kompatibilisek a régivel).

Számítási modell szerintNeumann elvű nyelvekA Neumann elvű nyelvek mögé egy Neumann elvű számítógépet képzelünk:

• címezhető, írható­olvasható memória: az adatok és a program a memóriában van,• program végrehajtása   utasítások szekvenciális végrehajtása,⇔• változó fogalmának megjelenése, értékadás, adatok beolvasása, kiírása, memóriacímre való ugrás, el­

ágazás, ciklusok szervezése,• a mai nyelvek többsége ilyen; pl. Fortran, Pascal, Basic stb.

Automata elvű nyelvek• végrehajtója (elvben) egy automata (ipari robot, festőautomata, lángvágó),

16

• az automata rendelkezik állapotokkal, s az állapotok közötti átmenetet leíró függvényekkel,• egy­egy állapot az összes globális "változó" ill. jellemző pillanatnyi értékét tartalmazza; ezek az álla­

potkomponensek,• utasítások: állapotmódosító illetve állapotlekérdező,• minden állapotváltozás relatív, hiszen a változás az előző állapothoz képest történt,• nincs változó, nincs értékadás (helyette állapotkomponens változtatás van),• nincs beolvasás (helyette eljárások paraméterezése, ill. állapotlekérdezés szerepel),• nincs kiírás (helyette az eredmény az állapotváltozások nyoma (pl. teknőc rajza)),• elágazások, ciklusok paraméter illetve állapotfüggők   egyszerűbbek, mint a Neumann­elvű nyelvek⇒ ­

ben. A ciklus vagy adott lépésszámú ciklus vagy rekurzív eljárás lehet,• pl. Logo teknőcgrafika.

Funkcionális nyelvek• a program egy függvény, a program végrehajtása a függvény kifejtéséből áll,• programstrukturálás:

• függvénykompozíció f ( x ) = g o h ( x )• alternatív függvény f ( x ) = [ g ( x ) ha p ( x ) [h (x) ha nem p (x)• rekurzív függvény f ( x ) = [ g ( x ) ha nem p ( x) [ h o f o i (x) ha p (x)

• nincs memóriacímzés,• nincs változó (helyette függvényparaméter van, ez lehet újabb függvény is),• nincs értékadás,• nincs ciklus,• nincs beolvasás (helyette függvényparaméterezés van),• nincs kiírás (helyette a kiszámított függvényérték automatikus kijelzése történik),• pl. Logo.

Logikai nyelvek• a program egy logikai formula,• a program végrehajtása a logikai függvény kiértékelése,• a program eredménye: FALSE vagy TRUE ill. azon paraméterek megadása, melyekre a TRUE teljesül,• nincs memória,• nincs változó,• nincs értékadás,• nincs beolvasás (helyette paraméterezés van),• nincs kiírás,• nincs szekvencia, elágazás, ciklus, őket logikai formulákban szereplő "és", "vagy", "nem" műveletek he­

lyettesítik. A program struktúrája:• f ( x ) ha h ( x ) é s g ( x )  ­egymás utáni végrehajtás• f ( x ) ha h ( x ) vagy g ( x )  ­alternatív végrehajtás• f ( x ) ha g ( x ) vagy i ( x ) é s f ( x )  ­rekurzív formula

• pl. Prolog.

Felhasználói közelség szerintGépi kód

• ez a legalacsonyabb szintű nyelv. Ez az a nyelv, amit a számítógép processzora közvetlenül megért,• a gép lehetőségeinek maradéktalan kihasználása (memóriacímek, regiszterek, verem,   megszakítások,

op.r. változói közvetlenül elérhetők),• gépi kódú utasítás (bináris szám).

17

Alacsonyszintű nyelv• Minden gépi kódú utasításnak megfelel egy alacsonyszintű nyelvi utasítás, amelyet azonban már egy

szimbolikus elnevezés takar (ezek állhatnak több gépi utasításból is).• Adatokat, adatok helyfoglalását, a programkód memóriába helyezését definiáló utasítások megjelenése.• Memóriacímek azonosítóval való ellátása, adatok kezdőcímének elnevezése (a rájuk való hivatkozás a

változófogalom első megjelenése).• elágazás, ciklus szervezhető, de a nyelvnek nem eleme,• kiegészítés:

• minden lehetőség kihasználható, amit a hardware nyújt,• változó = kezdőcím (megjelenik a változó fogalma, de még az adatoknak nincs szerkezetük),• azonosító = memória cím neve,• utasítás = azonosító,• feltételes vezérlésátadás. Visszatérés,• általában gyorsabb mint egy magas szintű nyelv,• primitívebb,• minden gépi utasításhoz nyelvi utasítást rendel.

Magasszintű nyelvek• magas szintű nyelvek  feladatorientált nyelvek,⇔• kifejezés­. változó­. típusfogalom­. elágazás­. ciklus­. eljárás megjelenése,• kiegészítés:

• faladatorientált,• változó memóriatartpményt jelöl,• típusfogalom,• kifejezések,• az algoritmusban felhasznált utasítások a nyelv elemi utasításaival kódolhatók,• elágazás, ciklus, értékadás, I/O,• eljárások = programegységek,• paraméterek.

Egyéb osztályozások"Compiler" illetve "Interpreter" nyelvekArra utal, hogy egyes nyelvekhez gyakrabban készítenek interpretert (értelmezőprogramot), míg másokat szintekizárólag compilerrel (fordítóprogrammal) használnak.Procedurális illetve nem procedurális nyelvekprocedurális: a program írásban a megoldó algoritmus leírására törekszik (pl. Neumann­elvű illetve automata­elvű nyelvek) nem procedurális: a program írásban nem a megoldó algoritmus leírására törekszik; a megoldóalgoritmust a nyelv kiértékelési szabálya tartalmazza. (pl. funkcionális és logikai nyelvek)Deklaratív nyelvOlyan nyelv, amelyben csak a specifikációt adjuk meg, s a rendszer ennek alapján automatikusanállít elő meg­oldást. (pl. logikai nyelvek)Utasításorientált nyelvOlyan programnyelv, melynek alapelemei utasítások,s a program végrehajtása ezek egymás utáni elvégzésébőláll. (pl. Pascal, Elan)Kifejezésorientált nyelvOlyan programnyelv, melynek alapelemei kifejezések,s a program kifejezések kiértékeléséből áll.Objektum orientált nyelvOlyan programnyelv, mely az objektum orientált programozás eszközeivel rendelkezik. (pl. Delphi)Párhuzamos programnyelvOlyan programnyelv, mely a párhuzamosság kezelésére szolgáló eszközökkel rendelkezik. 

18

Programozási alapfogalmak

AlgoritmusLépések sorozata, amellyel egy feladat kiindulásától a megoldásáig jutunk.

ProgramAz algoritmus megfogalmazása a számítógépek, vagy a fordító programok számára érthető nyelven.

ProgramozóA programozó a matematikushoz hasonlóan formális nyelveket használ az okfejtések (vagy az algoritmusok)leírására. A mérnökhöz hasonlóan terveket gondol ki, az alkotó részekből szerkezeteket állít össze, és értékeliazok  teljesítményét.   Mint   a  tudós  megfigyeli  az  összetett   rendszerek   viselkedését,  magyarázatokat  vá­zol  föl, ellenőrzi a jóslatokat. A programozó fő tevékenysége a problémamegoldás. Ez különböző képességeket és ismereteket igényel: 

• egy problémát különböző módokon kell tudnunk meg/újrafogalmazni, • innovatív és hatékony megoldásokat kell tudnunk elképzelni, • ezeket a megoldásokat világosan és komplett módon kell tudnunk kifejezni. 

ProgramozásA számítógép programozása lényegében abból áll, hogy részletesen „megmagyarázzuk” egy gépnek, (ami nem „ért meg”,  az emberi nyelvet, csupán karaktersorozatok automatikus kezelésére képes) hogy mit kell tennie. A program előre rögzített konvenciók – ezek együttesét programozási nyelvnek nevezzünk ­ szigorú betartásá­val kódolt utasítások sorozata. A gép rendelkezik egy eljárással ami úgy dekódolja ezeket az utasításokat, hogy a nyelv minden „szavához” egy pontosan meghatározott akciót rendel. Programozás alatt szűkebb értelemben a kódolást értjük, tágabb értelemben a feladat kigondolásától kezdődően a kész program leírásáig minden lépés ide tartozik.

ForrásprogramA programot,  ahogyan azt  egy szerkesztő  programmal   (egyfajta  specializált   szövegszerkesztővel)  megírjukmostantól fogva forrásprogramnak (vagy forráskódnak) nevezzük.

Programozási nyelvA  programozási nyelv nagyon pontos szabályokhoz rendelt (önkényesen választott) kulcsszavaknak a készlete.Azt írja le, hogyan rakhatjuk össze ezeket a szavakat olyan „mondatokká”, amiket az interpreter vagy a compi­ler a gép nyelvére (bináris számokra) le tud fordítani.

A programozás szintjeiGépi kódúA számítógép számára közvetlenül érthető nyelv a gépi kód. A nyelv elemei közvetlenül a processzor számáraismert gépi kódú utasítások. Mind az utasítások, mind az adatok bináris kódúak. A memóriában tárolt adatok el­helyezkedésének és helyes felhasználásának összes gondja a programozót terheli.Assembly nyelvA nyelv utasításkészlete szinte teljesen egyezik a gépi kódú programozáséval, de az utasításokat könnyebbenmegjegyezhető angol nevekkel látták el, valamint az adatokat és memóriacímeket sem kell binárisan megadni,hanem használható a sokkal kényelmesebb hexadecimális számrendszer is. Természetesen az assembly nyelvűprogramok közvetlenül nem értelmezhetőek a processzor számára, hanem egy fordító program segítségével gé­pi kódúvá kell lefordítani ahhoz, hogy futtatható legyen.Magas szintű programozási nyelvekMagasabb szintű utasításkészlet, amely már nem a processzor utasításkészletéhez áll közel, hanem inkább az

19

emberi gondolkodáshoz. Az adatok kezelésével kapcsolatos gondok nagy részét átveszi a fordítóprogram. Ezek­kel a nyelvekkel fogunk részletesebben foglalkozni.Újabb generációs nyelvekAz emberi gondolkodáshoz még közelebb álló programozási nyelvek.

Szintaxis és szemantika leírásSzintaxisnak nevezzük egy programozási nyelven írt program formai helyességére vonatkozó szabályok gyűjte­ménye. A szemantika pedig ugyanennek a jelentését, tartalmi helyességét leíró szabályokat tartalmazza.

Szintaxisleíró eszközökA szintaxis leírására sokféle eszköz szolgál, ezek közül gyakran használt a BNF (Backus­Naur forma), szinta­xisgráf,  és axiómákkal és következtetési szabályokkal való leírás.BNF – metanyelvNagyon kevés szimbólumot használ. A definiálandó fogalmakat <, > jelek közé kell tennünk, a definiálás jelea ::=, az alternatív definíciókat a |­jellel választjuk el egymástól, a megismétlendő elemeket pedig a {,}­jelekközé tesszük.Példák:<Program> ::= Program: {<Utasítás>} Program vége.<Értékadás> ::= <Változó> := <Kifejezés><Adat> ::= <Változó> | <Konstans>Szintaxisgráf – vasútdiagramA szintaxisgráf csomópontjait nyelvi elemek alkotják, s ezek lehetséges sorrendjét az irányított gráf élei jelölikki.Példák:Program

Értékadás

Fordítás és értelmezésAhhoz, hogy egy számítógéppel „beszéljünk”, olyan fordító rendszereket kell alkalmaznunk, melyek képesek aszámunkra érthetőbb kulcsszavakat (rendszerint angol szavakat) alkotó karaktersorozatokat bináris számokkáalakítani. Fordításnak nevezzük azt a folyamatot, amikor egy adott nyelven (forrásnyelven) megírt programot egy prog­ram (fordítóprogram – compiler) lefordít egy másik nyelvre (célnyelvre). A célnyelvi program futtatásához ez­után sem a forrásnyelvi programra, sem a fordítóprogramra nincs szükség.Az értelmező (interpreter) a programszöveget nem alakítja át, hanem utasításonként olvassa, elemzi, a a felis­mert utasítást azonnal végre is hajtja, majd megkeresi a végrehajtásban következő utasítást.

Programkészítés és futtatás meneteInterpreteres nyelvek esetén (pl. Basic, script)1. Program megírása egy programozási nyelven, ez az úgynevezett forrás program.2. Forrás program futtatása egy futtató program (interpreter) segítségével.

20

vagy (pl. JAVA)1. Program megírása egy programozási nyelven, ez az úgynevezett forrás program.2. Forrás program lefordítása egy köztes kódra (ezt a fordítót is szokás compiler­nek nevezni).3. Köztes kód futtatása egy futtató program segítségével.

Compileres nyelvek esetén(pl. C, C++, Pascal, Delphi) 1. Program megírása egy programozási nyelven, ez az úgynevezett forrás program.2. Forrás program lefordítása a fordító program segítségével gépi kódú programmá.3. A gépi kódú program futtatása.

A compiler­es nyelvek előnye: gyorsabb, hátránya: a lefordított kód csak ugyanolyan architektúrájú gépen futtatható, mint amelyiken fordították.Az interpreter­es nyelvek előnye: a program hordozható minden olyan helyre, ahol van interpreter, hátránya: lassabb.

Byte­kód fordításEgyes modern nyelvek megpróbálják a két módszert kombinálni, hogy mindegyikből a legjobbat hozzák ki. Eza helyzet a Python és a Java esetében is. Amikor egy forráskódot adunk át, az először egy gépi kódhoz hasonlóközbenső  kódot ú.n. bytecode­ot hoz létre, amit aztán egy interpreternek ad át  végrehajtásra. A számítógépszempontjából  a    bytecode­ot nagyon egyszerű  gépi nyelven  interpretálni.  Ez  az  interpretáció   tehát   sokkalgyorsabb lesz, mint egy forráskód interpretációja. 

21

Ennek a módszernek az előnyei érzékelhetőek:• Az, hogy állandóan rendelkezünk egy interpreterrel, lehetővé teszi bármilyen kis programrészlet   köz­

vetlen tesztelését.   Egy   alkalmazás   bármelyik   alkotójának   helyes   működését   igazolhatjuk   an­nak   létrehozását követően. 

• A   lefordított  bytecode  interpretációja   nem   olyan   gyors,   mint   egy   igazi   bináris   kódé,   deszámos   program számára, beleértve a grafikus programokat is, nagyon megfelel. 

• A bytecode portábilis. Ahhoz, hogy egy Python vagy egy Java program különböző gépeken végrehaj­tódjon elég ha mindegyik gépen rendelkezésre áll egy adaptált interpreter.

Case­sensitive, case­insensitive nyelvekA case­sensitive nyelvek megkülönböztetik a kisbetűket és a nagybetűket, a case­insensitive nyelvek nem, azaz mindegy, hogy valamit kisbetűvel vagy nagybetűvel írunk.

MegjegyzésekA megjegyzéseket a fordító nem veszi figyelembe. Azt a célt szolgálja, hogy a programot olvasó könnyebben eligazodjon a programban, ezzel segítve a kód újrafelhasználását. Megjegyzésekkel szokás magyarázni 

• a fontosabb változók szerepét,• a függvények szerepét, hívásának módját, paramétereit, eredményét• modul tartalmát,• egyes trükkösebb megoldásokat.

KulcsszavakA nyelv rögzített jelentéssel bíró szavai, amelyet más célra nem lehet használni.

Programstruktúrák

ProgramA program utasítások olyan sorozata, amely a számítógépen önállóan képes megoldani egy feladatot. A prog­ram háttértáron futtatható formában egy fájlban található.ProgramcsomagRokon programok halmaza, amelyek egy feladatkör megoldására szolgálnak.Párhuzamos folyamat (taszk)Egyes programok a feladat megoldására olyan programrészeket használnak, amelyek egymással párhuzamosanvégrehajthatók, a megoldás során egymással kommunikálnak, működésüket szinkronizálni kell, s meg kell ol-dani a közös erőforrások megosztását. Ezeket a párhuzamosan működő programrészleteket nevezzük folyama-toknak.Fordítási egység(Modul, unit, szegmens)A program önállóan, a többi résztől függetlenül lefordítható legkisebb nyelvtani egységét nevezzük fordításiegységnek. Ez a fordítóprogram egyszeri végrehajtásával lefordítható. Nem tévesztendő össze azzal, amikoregy fájlban több fordítási egységet helyezünk el, s azokat egyszerre fordítjuk.Export­, importlistákEzek a fordítási egységek olyan részei, amelyek leírják egyrészt, hogy az adott egység mely azonosítóit hasz-nálhatja más modul, másrészt, hogy ő mely modulokat, azokat, azoknak mely objektumait használja. Nem csaka modulnevet kell megadni, hanem azt is, hogy abból a modulból mire van szükségünk.ProgramegységEgy részfeladatot megoldó utasítások összefüggő csoportja. A programegység egyben, egységként hajthatóvégre, a külvilágtól valamilyen mértékben elzárt, azzal változókon, paramétereken keresztül kapcsolatot tartó,lokális típusokkal, változókkal konstansokkal, a blokkstruktúrájú nyelvekben lokális programegységekkel ren-delkező utasításcsoport.

22

Eljárás, függvény, operátorGyakorlatilag háromfajta programegységet használunk : az eljárást, a függvényt, valamint a függvény egy spe-ciális fajtáját: az operátort.Az eljárás olyan programegység, amely egy utasítást helyettesíthet a programban. A függvény értékével egy ki-fejezésben szereplő értéket reprezentálhat. Az unáris vagy bináris operátort szintén kifejezésekben használhat-juk.Ezek a programegységek, az ún. alprogramok paraméterezhetők. Definíciójukban formális paraméterekethasználunk, a ezeket híváskor feleltetjük meg az aktuális paramétereknek.Deklarációs rész, törzsEgyes programozási nyelvekben önálló programegységként szerepel a típusdefiníció, vagy blokk.A programegység egy (ELAN) vagy két (Pascal) részből áll. A deklarációs rész adatok, típusok, blokkstruktúrá­jú nyelvekben ezeken kívül más programegységek definícióit tartalmazza, a törzs pedig végrehajtható utasítá­sok sorozatát.Ha e két rész nincs elkülönítve, akkor azt a szabályt kell betartanunk, hogy egy dolog használatát meg kell hogyelőzze a definiálása.Néhány nyelvben a programegységek egy harmadik részt is tartalmaznak, a kivételkezelés.BlokkstruktúraProgramok programegységeit kétféleképpen helyezhetjük el. Az egyik, egyszerűbb elv szerint a program prog-ramegységek sorozata, melyek sorrendje lényegtelen.A Neumann-elvű nyelveknél gyakoribb esetben a programegységek deklarációs részeiben tartalmazhatnakújabb programegységeket. A programegységek egymásba ágyazásával előállt struktúrát hívjuk blokkstruktúrá-nak.

Programkészítés elvei

Stratégiai elveinekTaktikai elvekTechnológiai elvekTechnikai elvekEsztétikai­ergonómiai elvek

Stratégiai elvekEgyik legfontosabb, sokféleképpen alkalmazható elvünk „oszd meg és uralkodj” elve alapján fogalmazhatómeg: oszd részekre, majd a részek független megoldásával az egész feladatot könnyebben oldhatjuk meg. Ígyprogramunk könnyen kézben tarthatjuk.Lépésenkénti finomításA feladat megoldását először átfogóan végezzük el, nem törődve a részletekkel, részfeladatra bontjuk. Úgy ismondhatnánk: a feladatot megoldjuk a legfelső szinten. Ezt az eljárást fogjuk követni az egyes részfeladatokmegoldásakor is mindaddig, amíg olyan utasítások szintjéig nem érünk, amelyeket gépünk (kódolás után) márvégre tud hajtani. (Piramis elv)Pontosan ki kell jelölni, hogy az adott részműveletek milyen adatokat kezel, milyeneket állít elő, és ezeket mi­ként kell egymáshoz rendelni.Két azonos szinten definiált részfeladat között biztosítani kell a harmóniát úgy, hogy a végrehajtásban előbb kö­vetkező az utána következő adatait szolgáltassa.Program felülről lefelé való kifejtése (top­down programozás)A bemeneti adatokból indul ki és a kimeneti adatokat próbálja előállítani. Ez a leggyakrabban használt mód­szer, ezt segítik az eljárások, függvények és elemi programozási tételek is.Program alulról felfelé való felépítése (bottom­up programozás)A kimeneti adatokból indul ki és próbálja meghatározni az előállításukhoz szükséges bemeneti adatokat és amegfelelő utasítássort.

23

Taktikai elvekMilyen elv alapján hajtsuk végre a lépésenkénti finomítást.Párhuzamos finomítás elveA szint összes részfeladatára kell elvégezni a finomítást. Nem szabad előre sietni valamelyik könnyebbnek vélt ágon, mert előfordulhat, hogy munkánk kárba vész.Vissza az ősökhöz elvErre akkor van szükségünk, amikor körültekintő megfontolásaink ellenére zsákutcába kerülünk. Ekkor vissza kell lépni az előző szinthez (őshöz), és újra végig kell gondolni a részfeladatokra bontást, és tapasztalatainkat.

Technológiai elvekEzek az elvek az algoritmus (és a kód) írására, annak szabályaira vonatkoznak.Algoritmusleírási szabályokKevés, de egyértelmű szabályt kell kialakítani az algoritmusok leírására.Az adatokat beolvasó és kiíró utasítások az „ablak” szerepét játsszák a külvilág felől, illetve a program felhasz­nálója felé.A program változóinak értékkel való ellátását az értékadó utasítások végzik.A feltételektől függő végrehajtást teszik lehetővé az ún. feltételes utasítások, elágazások.A számítógépre szánt feladatok mindegyike feltételezi bizonyos részfeladatok ismételt elvégzését. A számító­gép erősségét, a gyorsaságot éppen a „mechanikus” ismétlések használják ki a legjobban! Ezek ciklusutasításoksegítségével valósulnak meg.A program adott szintjén elemi utasításként felhasznált, meghatározott, de nem finomított részprogramok (eljá­rások, függvények, operátorok) beépítését (az ún. eljáráshívást) is meg kell oldanunk nyelvünkben.Természetesen a felhasznált és még hiányzó eljárások finomítása (másként szólva: az eljárás kifejtése) sem hiá­nyozhat.Az algoritmusleírás mellett e nyelvek rendelkeznie kell az adatok (konstansok, változók) és típusok leírásáraszolgáló eszközökkel is.Értelmes sorokra tördelés – világos tagolásKérdés, hogy mit írjunk egy sorba, mit több sorba. Alapelképzelésünk lehetne például az, hogy minden utasítástkülön sorba kell tenni. Ezt a következőképpen módosítjuk: kerüljenek egy sorba azok az utasítások, amelyekszervesen összekapcsolhatók, és egy sorba írásukkal a program még áttekinthető marad.Bekezdéses leírásAz algoritmikus gondolatainkat, az algoritmus főbb eseményeit, epizódjait jól  láthatóan el kell különíteni aprogramban. A program teljes levezetése (finomítása) után a program szerkezetének vissza kell tükröznie aszintekre tagozódást: egy szint elemi utasításai a bekezdések azonos szintjeit alkossák!Egyes nyelvi szövegszerkesztők automatikusan a bekezdéses leírásnak megfelelően tördelik programunkat.Összetett struktúrák zárójelezéseAz algoritmusokban szereplő elágazások, ciklusok, eljárások, valamint az összetett adatstruktúrák úgy ismerhe­tők fel könnyen, ha nemcsak az elejüket jelzi valamilyen nyelvi elem, hanem a végüket is egyértelműen rögzít­jük.A „beszédes” azonosítók elveA konstansoknak, változóknak, típusoknak, eljárásoknak, függvényeknek, operátoroknak olyan nevet érdemesadni, ami utal arra, hogy mire használjuk. Ez kizárja az azonosítók keveredését: hiszen a név sugallja funkciót,az algoritmusban betöltött szerepet. Nagy segítséget nyújt a kódoláskor is, például lehetővé teszi, hogy minimá­lis számú változót rendeljünk az adatokhoz, hiszen a munkaváltozókhoz azonos neveket is rendelhetünk.Nem minden esetben a hosszú azonosítók a beszédesek, például ha egy fizikai képlettel (E=m*g*h) dolgozunk,akkor éppen ezek az egybetűs jelölések a beszédesek, ha pedig mátrixösszeadásra definiálunk egy operátort, ak­kor azt célszerű a + jellel jelölni.

24

Technikai elvekA program kódjával kapcsolatosak. Inkább úgy mondhatjuk, hogy az előzőek a program megírásához szükségesek, ez utóbbiak pedig a program használhatóságához elengedhetetlenek. Ilyen értelemben beszélhetünk a „csak” helyes programról, amely a feladat logikája szempontjából tökéletes, és a jó programról, amely ezen túl elő is segíti saját felhasználását.Barátságosság, udvariasságAz udvarias program bemutatkozással kezdi (tájékoztató), és ezzel tudatja a felhasználójával képességeit, szol­gáltatásait, használatának mikéntjét. Az udvariasság másik fontos megnyilvánulása, hogy a program futása so­rán megjelenő kérdések bárki számára – azaz a nem informatikus szakemberek számára is – érthetők, és a vála­szok a lehető legegyszerűbben megadhatók legyenek.BiztonságosságA „bolondbiztos” program az, amit a kísérletezni vágyó vagy éppen balszerencsés felhasználó sem képes ellen­őrizetlen vágányokra terelni azáltal, hogy nem a megfelelő módon, vagy nem a megfelelő pillanatban válaszol afeltett kérdésére. Ennek érdekében a program kritikus pontjait, azaz ahol a felhasználó közvetlenül avatkozik bea program további menetébe, nagy odafigyeléssel kell megírni. Az esetleges hibalehetőségekre fel kell készítenia programot úgy, hogy a felhasználónak lehetősége legyen a helyesbítésre is. (Itt használjuk ki a specifikációelőfeltétel részében leírtakat.)Nem támaszkodhatunk a számítógép, illetve az értelmező vagy fordítóprogram eleve meglévő hibajelzéseire.Ezek ugyanis arra valók, hogy segítségükkel felderíthessük és kijavíthassuk az esetleges programhibákat, teháta program írója, nem pedig a használója számára készültek.Jól olvasható programA program módosításakor, továbbfejlesztésekor óriási előnyt jelent, ha nem kell a programunk minden mellé­kes vonását  újra feltérképezni a megértéshez, hanem a lényeges tulajdonságai a program megfelelő  helyénkönnyen kiolvasható formában megtalálhatók, és így biztos kézzel nyúlhatunk bele a program legérzékenyebbrészeibe is.Már két idevágó elvet is említettünk: a bekezdéses leírás és az összetett utasítások zárójelezése elveket Ezt kiegészíthetjük a kódoláskor különösen nagy jelentőségűvé váló „jó magyarázatok (kommentek)” elvével.A programozási nyelvre való áttéréskor ugyanis – a programozási nyelv kötöttségei miatt – sok, az algoritmustnagyban jellemző tulajdonság elveszne, ha ezeket az információkat nem őriznénk meg egy­egy jól megfogal­mazott megjegyzés formájában.A (jól) dokumentált programSokszor nincs lehetőség – a program méretére rótt korlátozások miatt – arra, hogy az előző elvet maradéktala­nul megvalósíthassuk; ekkor le kell írni a program fontos vonásait: az algoritmusát (felépítését), a változóit ésezek szerepét, értelmezését, értéktartományát, hatáskörét stb., a kódolásnál követett szabályokat (a leíró és aprogramozási nyelv utasításainak, illetve változóinak megfeleltetését). Ezeket a dokumentációban is rögzítenikell, amelyben ezen kívül még foglalkozni kell a használat mikéntjével és az esetleges, előre látható fejlesztésilehetőségekkel is.

Esztétikai­ergonómiai elvekA program emberközelségéről  van szó. Nagy gondot kell fordítani a program által megjelenített információkkülalakjára. Ide nemcsak az eredmény jellegű kiírandók tartoznak, hanem például a tájékoztató, a felhasználó­val való párbeszéd módja is.Lapkezelési technikaA kiírandó  szövegek,  adatok logikai egységekre bontva jól  különüljenek el,  egyszerre csak annyi és olyanütemezésben, amennyit és ahogy a felhasználó be tud fogadni. Ennek megvalósítására alkalmazzák a lapkezeléstechnikáját.Egyszerre egy képernyőlapnyi információt jelenítünk meg, és a felhasználónak lehetősége van lapozásra, példá­ul egy adott billentyű lenyomásával jelzi a gépnek: „Elolvastam! Lapozhatsz!” (Többek között ennek megvaló­sítására használható a „Várj, amíg szükséges” utasítás.) Nem szerencsés ez esetben az adott ideig történő vára­kozás – gondoljunk a különböző olvasási sebességű felhasználókra!

25

Nyomtató esetén e várakozásra nincs szükség, viszont újdonságként felmerülhet a lapszámozás, illetve a fejlécvagy lábléc írása.Képernyőkezelés esetén is lehetőséget kell teremtenünk arra, hogy az aktuális képernyőtartalmat kinyomtathas­suk.Ügyelni kell a képernyőlap arányos kitöltésére, és jó, ha az egy lapon belül szereplő, logikailag szorosan összenem tartozó információk egymástól elkülönülnek. Az elkülönítés megoldható üres sorok beiktatásával, az egyesrészek szakaszokkal való elkülönítésével, illetve bekeretezésével.A mondanivalónk legfontosabb elemeit – a gép adta lehetőségek figyelembevételével – kiemeljük (inverz be­tűkkel, vagy bekeretezve, vagy más színű háttérrel, illetve betűkkel stb.).MenütechnikaA lapkezeléssel szorosan összefüggő módszer, amely a felhasználóval való párbeszéd elegáns megszervezésérealkalmas. Általában bonyolult szolgáltatásokkal rendelkező programoknál használatos, amelyből a felhasználó– akár egy menüből – kiválaszthatja a számára szükséges lehetőséget.Minden egyes válaszával (válaszcsoporttal) a kérdések egy nagy hányadát kizárja, ezeket a számítógépnek felsem kell tennie, megkímélve a felhasználót a fölösleges válaszadásoktól (hierarchikus menürendszer).A menü   egy   lap   (vagy  ablak),  amelyen  megjelennek a  választási   lehetőségek;  közülük sorszámmal   (vagykezdőbetűvel), illetve rámutatással (kurzormozgató billentyűk vagy egér segítségével) választhatunk.A program főmenüjében célszerűen szerepel egy Munka befejezése menüpont, a többi menüpont végrehajtásaután pedig újra e főmenü jelenik meg. Az egyes almenük hasonló elven épülhetnek fel, de ezekben a befejezéshelyett a Vissza az előző menühöz pont választható.IkontechnikaA szöveges menüknél esetenként gyorsabban felismerhetők az egyes választási lehetőségek, ha azokat kicsi jel­lemző ábrával, ún. ikonnal jelenítjük meg; közülük rámutatással (kurzormozgató billentyűk vagy egér segítsé­gével) választhatunk.Ez a technika azonban könnyen veszélyessé válhat: a túl sok és túl kicsi ikon a képet áttekinthetetlenné teheti.Értelmezési tartomány kijelzéseA kérdéseknél nagyon sokszor épp az okoz bizonytalanságot, hogy a felhasználónak fogalma sincs arról, hogyaz adatot milyen mértékegységben kell megadni. Ezért a kérdés szövege mellett célszerű közölni az adat mér­tékegységét, sőt – ha nem magától értetődő, akkor – még az értéktartományt is.Így elkerülhető, hogy például a program egy szöget radiánban vár, a gyanútlan felhasználó pedig a legnagyobbtermészetességgel fokban adja meg az értéket. Az ilyesmiből származó hibát nyilván nem kell ecsetelnünk.Fontos adatok kiemeléseNemcsak az információk könnyebb megértése szempontjából van jelentősége, hanem hasznos a program álla­potának, meghatározó paramétereinek azonnali visszajelzésekor is.Például amikor a számítógép egy hosszadalmas számítást végez, vagy bármilyen időigényes tevékenységbe fog,akkor ne maradjon el időnként egy­egy kiírás, ami értesíti a felhasználót, hogy mely tevékenységgel foglalkoziképpen a program, és hogy még kis türelmet kér. Látványos lehet ilyen esetekben közölni azt – esetleg grafikusformában is –, hogy a feldolgozás hány százalékánál tart éppen a program.TördelésA  legelemibb elvárás a képernyőn megjelenő szövegekkel szemben, hogy a sorok/szavak tördelése a helyesírásszabályainak megfeleljen. Ne sajnálja a programozó a fáradságot mondanivalójának gördülékeny megfogalmazására, szép elhelyezésére, hiszen csak ily módon kaphat mindenki számára kellemes programot!KövetkezetességA következetes beolvasási és kiírási szokások is fontosak. Tartsunk mértékletességet a beolvasási módszerekváltozatosságában. Nem díjazzák a felhasználók kiterjedt programozási ismereteinket, ha a választ hol ENTER-rel lezárva, hol anélkül várja a program.Hasonló probléma az IGEN-NEM választ igénylő kérdések sokféle feldolgozási lehetősége, válasszunk egyfaj-tát, és ahhoz ragaszkodjunk.Ha lehetőségünk van rá, akkor a lapkezelési technikához kapcsolódva az azonos jellegű kérdések, illetve ered-ményadatok a lapok azonos helyein jelenjenek meg.Hibajelzés követelményeiA hibák kézben tartásának szükségességéről már volt szó, de a hibák jelzésének mikéntje is jellemzi a progra-

26

mot. Igyekezni kell a hibajelzés legmegfelelőbb módjának kiválasztására. Ehhez a következő szempontokat ér-demes megfontolni:

• A hibajelzés ideje. Hibát akkor kell jelezni, amikor bekövetkezett, nem pedig valamely következ-ményekor! Tipikusan „bosszantó” lehet több száz adat beolvasása után olyan üzenetet látni, hogykezdjük elölről a begépelést, mert a legelső rossz volt.

• A hibajelzés „látványkörnyezete”. Ha a kezelői hiba javítása után folytatható a végrehajtás, akkor aképernyőlátványt vissza kell-e, illetve vissza lehet-e állítani?

• A hibajelzés időtartama. Mindig a felhasználó dönthessen a továbbhaladásról! Kerüljük az adott idő-tartamig megjelenő hibajelzéseket! A felhasználó ugyanis lehet lassúbb vagy gyorsabb, esetleg éppennem a képernyőre figyel, és így elmulaszthatja a hibajelzést.

• A hibajelzés mozgósító ereje. Biztosan észlelhető legyen, érthető legyen, azaz ne legyen túl rövid –csak a program írója ismeri a „megfejtést”, esetleg külön búvárkodást igényel –, túl hosszú – az em-ber az ilyenkor természetes türelmetlensége miatt csak hevenyészve képes végigszaladni a leírt „re-gényen” –, a várható felhasználói számára érthető szakkifejezéseket tartalmazzon.

Felesleges azonban abban az esetben külön hibajelzés szöveget kiírni, amikor a kérdés szövegéből egyértelmű,hogy a felhasználó mit rontott el. Ekkor elég például egy hangjelzés, majd a kérdés újra feltevése.NaplózásA program futása során több olyan esemény következhet be, amelyeket jó feljegyezni a későbbi esetleges fel-dolgozás érdekében. A felhasználó nem biztos, hogy megteszi ezeket. Ennek megoldására szolgál az ilyen ese-mények automatikus fájlba írása, a naplózás. Ez többnyire egy egyszerű szerkezetű szöveges fájl, amit a hasz-náló könnyen (egy „igénytelen” szövegszerkesztővel is) képes megjeleníteni, nyomtatni.FunkcióbillentyűkÉrdemes lehet egyes funkciókhoz, funkciócsoportokhoz egy-egy billentyűt hozzárendelni, és annak bármikorilenyomása a megfelelő funkciók végrehajtását jelenti.Például szimulációs programokban gyakran találkozunk olyan funkcióbillentyűkkel, amelyek a szimuláció le-állítására, újra paraméterezésére, megjelenítési módjának változtatására, részleges összesítések elkészítésérestb. vonatkoznak.SegítségEgy tipikus funkcióbillentyű a segítség (HELP=SÚGÓ) billentyű. Ennek lenyomása a futás bármely pillanatá-ban a program aktuális állapotáról szükséges tudnivalók kiírását eredményezi.Ennek egy hasznos formája a menüben mozgás alatti segítség, amely az aktuális menüpont részletes leírásátadja a felhasználó kívánságára.5.12. AblaktechnikaA homogén képernyő helyett célszerű olyan lapokat, ún. ablakokat használni, amelyek a képernyő elkülönítettrészein jelennek meg.Egy ablak mindig egy keret, és egy a belsejében levő tartalom. Az ablak kiírásakor a képernyőn alatta lévő részteltakarja, és levételekor újra megjelenik az eltakart rész.Ablakokat használhatunk a segítségszöveg megjelenítésére, hibajelzésre, menük kezelésére, a program állapotá-nak kijelzésére stb.

Programkészítés lépései

1. Feladat meghatározása (specifikáció)2. Algoritmus készítése3. Kódolás4. Tesztelés, hibakeresés, javítás5. Hatékonyságvizsgálat6. Dokumentálás

Feladat meghatározása (specifikáció)

A feladat   lehető   legpontosabb,   rövid,  egyértelmű   írásos  megfogalmazása.  A program helyes  működéséhez

27

szükséges körülmények megfogalmazása.Specifikáció tartalmazza a következőketA specifikációnak tartalmaznia kell a bemenő és a kimenő adatok leírását, azok  értékhalmazát is meg kell ad­nunk,  tartalmaznia kell a feladatban használt fogalmak definícióját, valamint az eredmény kiszámítási szabá­lyát. Itt lehetne megadni a bemenő adatokra vonatkozó összefüggéseket is. A bemenő, illetve a kimenő adatokrakirótt feltételeket nevezzük  előfeltételnek, illetve  utófeltételnek. Az előfeltétel nagyon sokszor egy azonosanigaz állítás, azaz a bemenő adatok értékhalmazát semmilyen „külön” feltétellel nem szorítjuk meg.1. példa:Feladat: Valaki nyissa ki az ablakot!Bemenet: ablak, valaki (pl. Géza), ablaknyitó tevékenységElőfeltétel: csukva legyen az ablakKimenet: ablak Utófeltétel: nyitva legyen az ablak

2. példa:Feladat: Add meg az osztályból a 10. legnagyobb emberkét!Bemenet: osztály, magasságok, kiválasztási módszerElőfeltétel: legalább 10 fő legyen az osztály, legyenek csökkenő sorba rendezveKimenet: egy emberkeUtófeltétel: előtte 9 ember legyen

Feladatok1. Feladat: Valaki adja meg az osztályból magasság szempontjából a középső embert! Bemenet: osztály, magasságok, kiválasztási módszerElőfeltétel:  legyenek növekvő sorba rendezveKimenet: egy vagy kettő emberkeUtófeltétel: előtte és utána is ugyanannyi emberke legyen

2. Feladat: Kerüljön fel a táblára egy angol szó! Bemenet: tábla, valaki (pl. Géza) , táblára írás módszereElőfeltétel:  valaki (pl. Géza) tudjon egy angol szótKimenet: táblaUtófeltétel: táblán legyen egy angol szó

Algoritmuskészítés

AlgoritmusAz algoritmus olyan pontos elírás, amely megmondja, hogy milyen műveleteket kell meghatározott sorrendbenelvégezni, hogy megoldjuk a problémát. Az algoritmus olyan pontos elírás, amely megmondja, hogy milyenműveleteket kell meghatározott sorrendben elvégezni, hogy megoldjuk a problémát.

Algoritmussal szemben támasztott követelményekLegyen időben és lépésszámban véges.Legyen egyértelmű: ugyanazon bemenet adatokra minden esetben ugyanazt az eredményt szolgáltassa.Legyen általános: ne csak egy konkrét feladatot oldjon meg, hanem lehetőleg minél szélesebb problémaosztályt! (Pl. ne csak egy konkrét másodfokú egyenletet oldjon meg, hanem bármelyiket)

Algoritmikus elemek• program,• értékadó utasítás,

28

• beolvasó utasítás,• kiíró utasítás,• megjegyzések,• utasításblokk (szekvencia),• elágazások (szelekció),• ciklusok (iteráció).

ProgramA program minden esetben utasítások sorozata.

Értékadó utasításVáltozók legtöbbször értékadó utasítással kapnak értéket. Az értékadás jel:  := ,  a bal oldalán a célként megje­lölt változó, jobb oldalon pedig a kiszámítandó kifejezés, szám szerepel.

pl. a:=12Az azonosító tetszőleges objektum neve lehet, a kifejezés pedig a matematikában és más tudományokban hasz­nált operátorokat, függvényeket, konstansokat tartalmazhat.

Beolvasó utasításTetszőleges adat beolvasására szolgál a felhasználó által kezelt perifériáról (billentyűzet). Mivel a felhasználó nem része a programnak, ezért az általa beírt adatok és a program által várt paraméterek típusát, értékhalmazát ellenőrizni kell. Az adatokat karakteresen kell megadni, és beolvasáskor a megfelelő változó típusa szerinti automatikus konverzió történik.

A feltételek elmaradhatnak, ha a beolvasandó értékekre semmilyen előfeltevésünk nincs.

Kiíró utasításA felhasználó által figyelt perifériára helyezi el az adatokat karakteresen.

Ha a kiírás formátumára van valamilyen speciális megkötésünk, akkor az itt szerepelhet, illetve a legtöbb ilyet majd a kódolásnál kell megfontolni.

MegjegyzésekAz algoritmusban elhelyezhetünk magyarázó szövegeket, a program állapotára vonatkozó állításokat, bármit, ami az olvashatóságot növeli, a későbbi munkánkat megkönnyítheti.

Utasításblokk ­ szekvenciaA szekvenciát alkotó utasítások a megadás (leírás) sorrendjében végrehajtandók.

Pl.: Kelj fel!       Moss arcot!       Fésülködj meg

29

Program:utasítás…

Program vége.

 azonosító := kifejezés

Be: azonosítók [feltételek]

Ki: kifejezések [formátum megkötés]

[magyarázó szöveg]

Utasítás1 Utasítás2 ...

Elágazás ­ szelekcióKét (vagy több) műveletcsoport közül csak az egyiket kell végrehajtani.A döntés mindig valamilyen logikai feltételtől függenek, és annak ismeretében egyértelmű a döntés.Egyszerű elágazásEgy utasításblokkból áll.Az utasításblokk a feltételtől függően vagy végrehajtásra kerül, vagy nem. 

Összetett elágazás ­ Két utasításblokkból állóA két utasításblokk közül a feltételtől függően pontosan az egyik utasításblokk hajtódik végre. 

Összetett elágazás ­ Több utasításblokkból állóA több utasításblokk közül legfeljebb az egyik kerül végrehajtásra ­ elképzelhető, hogy egyik feltétel sem telje­sül. Ekkor 

• ha van KÜLÖNBEN ág, akkor az hajtódik végre • ha nincs KÜLÖNBEN ág, akkor egyik blokk sem hajtódik végre • ha több feltétel is teljesül, akkor sorrendben csak az első hajtódik végre 

Ciklus ­ iterációEgy feltételtől függően egy adott utasításblokk többszöri ismételt végrehajtását jelenti. Az utasításblokkot cik­lusmagnak, a feltételt ciklus vezérlő feltételnek nevezzük.

Elöltesztelős ciklusFeltétel előbb értékelődik ki, majd megfelelő esetben végrehajtásra kerül a ciklusmag  „… előbb tesztel, aztán ciklusmag…”.

Hátultesztelős ciklusA ciklusmag végrehajtódik, majd kiértékelődik a ciklus vezérlő feltétel, és megfelelő esetben újra végrehajtásra kerül a ciklusmag. Egyszer mindenképpen lefut a ciklus. „…ciklus mag, majd tesztelés”

30

Ha logikai kifejezés akkor utasítássor

Ha logikai kifejezés akkor utasítássor           különben utasítássor

Ha logikai kifejezés akkor utasítássorkülönben ha logikai kifejezés akkor utasítássorkülönben utasítássor

Ciklus amíg logikai kifejezésutasítássor

Ciklus vége

Elágazásfeltétel_1 akkor utasítássor_1feltétel_2 akkor utasítássor_2…feltétel_n akkor utasítássor_negyéb esetben utasítássor_n+1

Elágazás vége.

Számlálós/Növekményes ciklusA ciklusmag utasításai a fejrészben megadott számszor hajtódnak végre, megadott lépésenként.

Eljárás, függvények, operátorProgramjainkat célszerű részfeladatokra bontani.Az olyan részfeladatokat megoldó részprogramokat, amelyek „valamit csinálnak”, nevezzük eljárásoknak. Azeljárások   egyik   fontos   szerepe   az   absztrakció   támogatása.   Az   eljárás   formailag   ugyanúgy   néz   ki   mint   a(fő)program. Használata egyszerűen a nevének a leírásával történik, önálló utasításnak számít.

Az eljárások paraméterezhetőek, az eljáráson belül használt paramétereket formális paramétereknek, az eljáráshívásánál is fel kell sorolni, itt aktuális paramétereknek nevezzük.A paramétereket megkülönböztetjük még bemenő  (amiből az eljárás „számol” valamit) és kimenő (amit ered­ményül ad az eljárás).Egy másik csoportosításban a paraméter értéke az eljárásban vagy megváltozik (változó paraméter), vagy pedignem (konstans).

Az eljárás mellet a másik absztrakciós eszköz függvény. Definiálása hasonló az eljáráshoz, használata formai­lag ugyanaz, csak nem önálló utasításként, hanem kifejezésben szerepelhet.

Vannak speciális függvények, amelyeket a többiektől eltérő módon használunk, jelüket nem az argumentumukelé, hanem argumentumaik közé írjuk, ezeket operátoroknak vagy műveleteknek nevezzük.

31

Ciklusutasítássor

amíg feltételCiklus vége

Ciklus cv=K­tól L­igutasítássor

Ciklus vége.

Eljárás Eljárásnév:utasítássor

Eljárás vége.

Eljárás Eljárásnév(formális paraméterek):utasítássor

Eljárás vége.

Eljárásnév(aktuális paraméterek)

Függvény Függvénynév(formális paraméterek): függvényérték típusautasítássorFüggvénynév:=kifejezés

Függvény vége.

Művelet Operátornév(formális paraméterek): értékének típusautasítássor

Operátornév:=értékMűvelet vége.

...aktuális paraméter_1 Operátornév aktuális paraméter_2

Műveletek csoportosítása

Elemi műveletek Azok a tevékenységek, amelyek nem igényelnek magyarázatot, azonnal végrehajthatók. Ezen műveleteket avégrehajtó (a számítógép) ismeri, és azokat végre tudja hajtani.Elemi utasítások:

• értékadás,• függvényhívás,• beolvasás,• kiíratás.

Összetett műveletek Azok a tevékenységek, amelyek elemi tevékenységekből épülnek föl, tartalmukat mindig meg kell magyarázni,maguk is egyszerűbb algoritmusokból épülnek föl. Ezen tevékenységeket a végrehajtó (a számítógép) nem is­meri, azok további magyarázatra várnak, ki kell bontani őket.Összetett utasítások:

• utasítás blokk (több utasítás egyben),• elágazások: döntési szerkezetek,• ciklusok: ismétlési szerkezetek.

Algoritmus leíróeszközök

Néhány ismertebb algoritmus leíróeszköz:• folyamatábra (blokkdiagram),• struktogram,• Jackson módszer,• mondatszerű leírás (pszeudokód).

Folyamatábra (blokkdiagram)Az egyik legkorábban kialakult megadási mód. Alapjeleit maga Neumann János dolgozta ki. A nyilakkal jelöl­jük a végrehajtási sorrendet. Téglalap: értékadó utasítás, eljárások,Rombusz vagy hatszög: az egy vagy többágú kiválasztás,Paralelogramma: az adatáramlás,Kör: a vezérlő utasításokAz ismétlési szerkezeteket elrejtve tartalmazza az ábra.

32

33

5. Ciklusok:

34

Struktogram

Gépfüggetlen, nyelv független algoritmus leíró nyelv. Az egyes szerkezeti elemeket különböző téglalapba fog­lalható ábrákkal jelöljük. A szerkezetek egymásba ágyazhatók, de vonalaik nem keresztezhetik egymást. A fo­lyamatábra hibáit próbálja meg kiküszöbölni ezzel.Előny:

a program gráfot élek nélkül ábrázolja,egyetlen alapelem marad a téglalap.

Hátrány:rajzossága miatt terjedelmesnehezen javíthatónehezen olvasható

35

Jackson diagram

Szekvencia esetén az utasításokat balról jobbra haladva kell végrehajtani, a kétféle elágazásnál az igaz feltételű,jobb felső sarkában kis karikával (o) jelölt téglalap tartalmát, ciklusnál pedig mindaddig, amíg a feltétel teljesül,a jobb felső sarkában csillaggal (*) jelöltét.Az új eszköz egyértelmű előnye az algoritmus­ és adatleírás egységessége, áttekinthetősége azonban az eddigi­eknél is rosszabb. A szekvenciát itt azonnal, mint sok utasítás szekvenciáját definiáltuk, a többi alapelem a szo­kásossal megegyező.

36

Mondatszerű leírás

Az anyanyelvi megfogalmazáshoz hasonló, de annál tömörebb leírási mód. Az élőnyelv pontatlanságait próbál­juk vele kizárni, de még egyszerűen értelmezhető marad.1. Értékadó utasítás

változó:=kifejezés       Az utasítás hatására a változó felveszi a kifejezés aktuális értékét.

2. Beolvasó utasításBE: változók [az adatokkal szemben állított követelmények]

    Kiírató utasítás  KI: kifejezések [a kiírás formájára vonatkozó követelmények]

3. Utasítás sorozat: Egymás alá írással adjuk meg az egymás után végrehajtandó utasításokat

4. ElágazásEgyszerű:

HA logikai kifejezés AKKOR utasításokÖsszetett:

HA logikai kifejezés AKKOR utasítások

KÜLÖNBEN utasítások

ELÁGAZÁS VÉGE.

HA logikai kifejezés AKKOR utasítások

KÜLÖNBEN HA logikai kifejezés AKKORutasítások

 KÜLÖNBENutasítások

ELÁGAZÁS VÉGE.

37

ELÁGAZÁSfeltétel_1 AKKOR utasítássor_1feltétel_2 AKKOR utasítássor_2…feltétel_n AKKOR utasítássor_nEGYÉB ESETBEN utasítássor_n+1

ELÁGAZÁS VÉGE.

5. CiklusokElöltesztelős 

CIKLUS AMÍG logikai kifejezés utasítássor

CIKLUS VÉGE

HátultesztelősCIKLUS

utasítássor AMÍG feltételCIKLUS VÉGE

SzámlálósCIKLUS cv=K­tól L­ig

utasítássor CIKLUS VÉGE.

6. Eljárás vagy függvény megadás:ELJÁRÁS eljárás_neve (paraméterek)

utasításokELJÁRÁS VÉGE

Az eljárás vagy függvény hívása nevének és paramétereinek leírásával történik meg.A program egy kitüntetett szerepű eljárás (vagy függvény), neve meghatározott:

PROGRAM neve:utasítás sorozat

PROGRAM VÉGE.

  FÜGGVÉNY Függvénynév(formális paraméterek): függvényérték típusa utasítássor Függvénynév:=kifejezésFÜGGVÉNY VÉGE.

Kódolás

A kész terveket egy választott programozási nyelven kódoljuk. Vannak olyan szoftverek, amelyek a kódolást aterv alapján automatikusan elvégzik. Az elkészült forráskód olyan, mint egy épület esetében a tervrajz. A for­ráskódból egy fordítóprogram hozza létre a futtatható gépi kódú programot.

Tesztelés, hibakeresés, javítás

38

Tesztelés: Minden program hibás. Az elkészült programot minimum két szempontból alaposan elemezni kell.• Minden esetben helyesen működik­e?• Hatékony­e?

A hatékonyság három fő mérőszáma a tárhelyhasználat, a sebesség és a bonyolultság. Szinte lehetetlen mindenhibát biztosan javítani, ezért a szoftverfejlesztés egyik központi kérdése a hibakeresés­hibajavítás ciklus szerve­zése.Hibajavítás: A felismert hibák kijavításához új specifikáció, új terv és újrakódolás lehet szükséges.A programtesztelés módszereit két csoportba oszthatjuk, aszerint, hogy a tesztelés során végrehajtjuk­e a prog­ramot vagy nem. Ha csak a program kódját vizsgáljuk, akkor statikus, ha a programot végre is hajtjuk a teszte­lés során, akkor dinamikus tesztelésről beszélünk.Statikus tesztelési módszerek

• kódellenőrzés,• formai ellenőrzés,• tartalmi ellenőrzés, ellentmondás keresés,• felhasználatlan objektumok,• felhasználatlan változóérték,• érték nélküli változó,• végtelen ciklus,• stb.

Statikus (számítógép nélküli algoritmus, ill. forrásellenőrzés)      1. Szemantikai hiba: 

logikátlan lépések      2. Szintaktikai hiba: 

nem helyesen lett beírva a programba.Dinamikus (lefuttatjuk a programot)Hibák észlelése (mi a hiba?) 

• Nem indul el a program,• Nem áll le a program,• Megszakad a programfutás, • Rossz eredményt ír ki,• Nem ír ki semmit,

Hibakeresés A hibakeresési módszerek kétféle kérdésre adhatnak választ:

• A bemenetnek mi az a része, amire hibásan működik a program?• Hol található a programban a hibát okozó utasítás?• Mire kell kicserélni a hibás részt, hogy a hibát megszüntessük?

Hibakeresési eszközök• kiírás: a program bizonyos helyeire elhelyezünk tesztkiírásokat.• nyomkövetés: végrehajtott utasítások követése a programban, futás során az eredmény­

képernyő mellett a programszöveget is látnunk kell. A programszövegből éppen végre­hajtott utasítást látjuk, vagy a programszövegben mutatja egy mutató az aktuális utasítást.

• adatnyomkövetés: nyomkövetés speciális esete. Akkor kapunk a képernyőn üzenetet, hakijelölt változó(ka)t valami használja, módosítja.

• töréspontok elhelyezése: a töréspontok a program olyan utasításai, aminél végrehajtáskormeg kell állnia. A felhasználó információt szerezhet a program állapotáról és folytathatjaa végrehajtást.

• lépésenkénti végrehajtás: olyan eszköz, amely a program minden utasítására egy törés­pontot definiál.

Tipikus hibák

39

A hibakeresést nagyban megkönnyíti az, ha tudjuk, hogy mire figyeljünk. Szép számmal vannak olyan hibák,amelyeket sokan, sokszor követnek el. A hibakeresés első lépése lehet e tipikus hibák megvizsgálása. Ebben afejezetben ezeket soroljuk fel vázlatszerűen.Gépelési hibák

• 0 számjegy és O betű keverése.• Alapszavak különírása.• Változónevek és alapszavak egybeírása.• Elválasztójel hiánya vagy rossz helyre tevése vagy keverése (,;:).• Sorokra tagolási hiba.

Elágazásszervezési hibák• Elágazás ágainak felcserélése.• Sokirányú elágazás hibás feltételű kétirányúvá alakítása.• Sokirányú elágazás nem létező egyéb ággal.• Elágazáslezárási hiba (nincs, vagy rossz helyen van).

Ciklusszervezési hibák• Kezdő és lezáró utasítások rossz helyen vannak.• Hibás ciklushatárok, lépésköz.• 0 vagy nagyon kis valós szám lépésközű ciklus.• Számlálós ciklus ciklusmagja akkor is lefut egyszer, ha nem kell.• Kilépési feltételben szereplő változónak az első belépéskor még nincs értéke.• Ciklusváltozó nem változtatása feltételes ciklusnál.• Ciklusváltozó változtatása számlálós ciklusnál.

Bemeneti adatok hibái• Hibás típusú bemenő adat.• Kevesebb adat beolvasása, mint amit a program vár.• Több adat beolvasása, mint amit a program vár.• Nem megengedett típusú változó beolvasása.

Kimeneti adatok hibái• Hibás típusú kimenő adat.• Kép utolsó sorába írás soremeléssel   a kép elcsúszik.→• Kép jobb alsó pontjába írás   a kép elcsúszik.→

Fájlok hibái• Nem létező fájl megnyitása.• A fájl nem ott van, ahol keressük.• Nem adtuk meg a fájlnévben a kiegészítőt.• Nem azonos a fájl szerkezete azzal, amit a program vár.• Hibás fájlvége­kezelés.• Írásvédett fájlba írás.

Változókkal kapcsolatos hibák• Hatásköri hibák• Láthatósági hibák• Kezdőérték nélküli változó használata (a program előszörre, illetve másodszorra különbözőképpen fut­

hat)• Konstans megváltoztatása• Ciklusváltozó használata a cikluson kívül

40

Kifejezések hibái• Típuskeveredés.• Túlcsordulás vagy alul­csordulás (emiatt asszociativitási, disztributivitási hibák).• Hibás zárójelezés.• Nullával osztás, négyzetgyök, logaritmus negatív számból.• Kerekítési hiba.• Szimmetrikus logikai műveletek miatti hibák.• Tömbindexhatár­hibák, memóriaméret­hibák, indexek felcserélése.• Logikai formulák tagadásában az ÉS és a VAGY műveletek hibás tagadása.

Eljárások hibái• Aktuális paraméterek száma nem megfelelő.• Aktuális paraméterek típusa nem megfelelő.• Aktuális paraméterek sorrendje nem megfelelő.• A függvényérték típusa nem megfelelő.• Nincs függvényérték­visszaadás a függvénydefinícióban vagy valamelyik ágán.• Érték szerinti paraméter megváltoztatása nem jut vissza a hívóhoz.• Mellékhatások problémái.

Grafikai hibák• Ablakrelativitás figyelembe nem vétele.• Szövegvágás furcsaságai (teljes szövegre vágás).• Képernyő vágás nélküli kezelése – kívülre rajzolás miatti memória felülírás.• Nem megfelelő grafikus kártya.• Grafikus driver hiánya.• Nem az aktuális grafikus kártya méretparamétereihez igazodó rajzolás.• Torzítási hibák (négyzet, kör).

Hibaüzenetek értelmezése

Hibakeresés (Bedugolás)

A programozás  nagyon összetett és, mint minden emberi tevékenység során, ennek során is számos hibát köve­tünk el. Anekdotai okokból a programozási hibákat bug­oknak nevezzük. A detektálásukra és javításukra hasz­nált technikák együttesét debugnak nevezzük. Háromféle típusú hiba létezhet egy programban: szintaxishibák,

41

Traceback (most recent call last): File "feladat1.py", line 6, in <module> szam=rw_input("Kérek egy negatív számot! ")NameError: name 'rw_input' is not defined

File "feladat1.py", line 11 szam=szam+ ^ SyntaxError: invalid syntax

File "feladat1.py", line 10 print("A szám: +str(szam)) ^ SyntaxError: EOL while scanning string literal

Melyik fájlban és hanyadik sorban van a hiba

A hibás rész

Hibatípus megnevezése, itt nincs definiálva Melyik fájlban és hanyadik sorban van a hiba

A hibás rész

Hibatípus megnevezése, szintaxis hiba, ismeretlen szintaxis

Melyik fájlban és hanyadik sorban van a hibaA hibás rész

Hibatípus megnevezése, szintaxis hiba

szemantikai hibák, végrehajtás közben fellépő hibák. 

Bedugolás technikák

Lépésenkénti végrehajtás A lépésenkénti végrehajtás segítségével programunknak mindig egyetlen sorát  tudjuk végrehajtani. Ilyenkoregy egységnek nem egy utasítás, hanem egy sor számít, ha egy sorba több utasítást írunk, ezeket mind egy lé­pésben fogja a gép végrehajtani.

Töréspont A töréspont lényege, hogy a program elindítása előtt kijelölhetjük azt a sort, amelyiknél majd a végrehajtástszeretnénk megállítani.

Változók és kifejezések pillanatnyi értékének figyelése A hibakeresés másik hatékony eszköze a változók tartalmának figyelése. Ezt a legáltalánosabb módon (amelyminden programozási  környezetben működik)  úgy valósíthatjuk meg, hogy a változók  tartalmát  a programmegfelelő helyein kiíratjuk a képernyőre. Ez azonban elég körülményes, hiszen egyrészt állandóan módosíta­nunk kell a programszöveget, és a futtatás előtt kell döntenünk, hogy mely változók lesznek érdekesek szá­munkra, másrészt egy összetettebb adat áttekinthető kiíratásához már egy kisebb programot kell írnunk.

Kivételkezelés

A kivételkezelés egy  programozási  mechanizmus,  melynek célja  a  program futását  szándékosan vagy nemszándékolt módon megszakító esemény (hiba) vagy utasítás kezelése. Az eseményt magát kivételnek (except­ion) hívjuk.A hibaüzenet két részből áll, amit : választ el. Elöl van a hiba típusa, utána egy, a hibára vonatkozó specifikusinformáció következik. Számos esetben előre lehet látni, hogy bizonyos hibák léphetnek fel a program egyikvagy másik részében. Ezekbe a programrészekbe beépíthetünk olyan speciális utasításokat, amik csak akkoraktiválódnak, ha ezek hibák fellépnek. Az olyan magasszintű nyelvekben, mint amilyen a Python, lehetőségvan arra, hogy egy felügyelő mechanizmust kössünk egy egész utasításcsoporthoz és így egyszerűsítsük azok­nak a hibáknak a kezelését, melyek ezen utasítások bármelyikében felléphetnek.

A Python kivételkezelő mechanizmusa a try – except – else utasításcsoportot használja, ami lehetővé teszi egy hiba elfogását és egy erre a hibára nézve specifikus ­ scriptrész végrehajtását. Ez a következő módon működik:A try­t követő utasításblokkot a Python feltételesen hajtja végre. Ha az egyik utasítás végrehajtásakor hiba lép  fel, akkor a Python törli a hibás utasítást és helyette az except­et követő kódblokkot hajtja végre. Ha semmilyenhiba sem lép fel a try utáni utasításokban, akkor az else­et követő kódblokkot hajtja végre (ha ez az utasítás je­len van). A program végrehajtása mindegyik esetben a későbbi utasításokkal folytatódhat.

Hatékonyságvizsgálat

Hatékonyság fogalma

A specifikációnak megfelelően elkészített, működőképes programjaink általában sok szempontból még nem tö­kéletesek. A legtöbb „kész” program javítható: 

• gyorsabbá tehető• memóriaigénye csökkenthető• programkódja egyszerűbbé tehető.

A programok ilyen szempontból történő vizsgálatát hatékonyságvizsgálatnak nevezzük.A hatékonyabbra írás alapfeltétele a program helyes működése, hiszen egy rosszul működő program esetébennincs értelme hatékonyságról beszélni.

42

A hatékonyságvizsgálat már az algoritmuskészítés idején megjelenik, de gyakran az elkészült forráskód haté­konysága is javítható.A hatékonyság vizsgálata több szempontból is fontos:

• szűkös erőforrások esetén• költségkímélés céljából• a gyakorlati használhatóság miatt

Hatékonyságvizsgálat szempontjai

• végrehajtási idő,• helyfoglalás (memóriában, háttértárakon),• bonyolultság.

Hatékonyságvizsgálat szintjei

Globális hatékonyságA globális hatékonyság növelése az algoritmus hatékonyabbá tételét jelenti, ez tehát valójában a program­tervezés része. Egy program tényleges hatékonyságát alapvetően a globális hatékonyság határozza meg. 

Lokális hatékonyságA programkód egyszerű transzformációit jelenti, általában a program működésének megértése nélkül, me­chanikusan is elvégezhető. Jelentősége kisebb, mint a globális hatékonyságé, de nem elhanyagolható.

Algoritmus hatékonysága

• jó algoritmus,• ciklusok végrehajtási száma (egymásba ágyazott ciklusok nagyon lassítják),• egy ciklus végrehajtási ideje,• feltételvizsgálat száma,• kivételesetek kiküszöbölése.

 

Programkód hatékonysága

• jó adattípusok (kis helyfoglalás, gyors számolás ­ a real számtípus nem szabványos, nem támogatja akoprocesszor),

• feltételek egyszerűsítése,• lehetőleg ne használjunk különböző adattípusokat egy kifejezésben (átváltás miatt),• függvények kiszámítását ritkán alkalmazzuk.

Dokumentálás

A program egy termék, és egy termékhez mindig tartozniuk kell különböző leírásoknak.Mire is lehet szükség egy program kapcsán? Először is egy leendő felhasználónak el kell döntenie, hogy milyenprogramot, akar használni. Ha a programot megvette, akkor el szeretné helyezni a számítógépén, majd használ­ni szeretné, és a felhasználásban segítséget vár.Nemcsak a felhasználónak van szüksége dokumentációra, hanem a fejlesztőnek, karbantartónak is (nem véletle­nül adnak például háztartási készülékeinkhez műszaki leírást is).Nyilvánvaló, hogy ez a két­ vagy többfajta dokumentáció másoknak szól, így nem egy egységes dokumentáció­ról fogunk beszélni, hanem többfajta dokumentumról.

43

Dokumentáció fajtái

Fejlesztői dokumentációA fejlesztői dokumentációt használja az, akinek a programban hibát kell keresnie, a hibát ki kell javítania, aprogramot hatékonyabbra kell írnia, át kell vinnie más gépre, át kell írnia más nyelvre, valamint tovább kell fej­lesztenie.Az ő munkájuk megkönnyítése érdekében a fejlesztői dokumentációban szerepeljenek a következők:

• specifikációk, követelményanalízis (korlátozások, pl. megkívánt hatékonysági jellemzők, alkalmazan­dó adatszerkezetek). A feladat és a megoldástól elvárt követelmények meghatározása. Ezt még a fel­adat kitűzője adta, vagy vele történt megbeszélés során pontosodott a megoldás első lépéseként.

• a futási környezet leírása: számítógép, operációs rendszer, memóriaméret, (speciális) perifériaigény,grafikus kártya (felbontóképesség, színek száma …) 

• fejlesztői környezet leírása: a választott programnyelv(ek), és verziószáma(i), eljáráskönyvtárak, uni­tok (azaz a szükséges „programdarabok” fájljai).

• az algoritmusok és az adatok (típusok, osztályok, programkonstansok) leírása, ezek kapcsolata. Dön­tések, más lehetőségek, érvek, magyarázatok.

• kód, implementációs szabványok (ún. kódolási szabályok, egyéni konvenciók), döntések;• tesztesetek, azaz milyen (jellegzetes) bemeneti adatokra, milyen eredménnyel „válaszol” a program.• hatékonysági  mérések   (hatékonysági   tesztesetek),  megfontolások,   javaslatok   az   esetleges  hatéko­

nyabbra írásra.• fejlesztési lehetőségek.• a készítő adatai.

Felhasználói dokumentációEzt a dokumentumot használja a felhasználó, az üzembe helyező, a betanító.Nekik szükségük van a következőkre:

• a feladat – egy rövid összefoglaló leírás is kell az áttekintés miatt és egy részletes a pontos használat­hoz.

• a futási  környezet   leírása:  számítógép,  operációs rendszer,  memóriaméret,  perifériaigény, grafikuskártya, ... (megegyezik a fejlesztői dokumentáció ugyanilyen című részével).

• a használat leírása – hogyan kell a programot betölteni/elindítani, milyen kérdéseket tesz fel, mik a le­hetséges válaszok, mik a program egyes lépései, lehetőségei (nagyvonalú funkcionális leírás).

• bemenő   adatok,  eredmények,   szolgáltatások   részletes   leírása:  mit,  mikor,  milyen  sorrendben kellmegadni (részletes funkcionális leírás).

• mintaalkalmazás – példafutás. A felhasználó – főleg a betanító – ennek alapján tudja előre – gép nél­kül – „elképzelni” a programot.

• hibaüzenetek és a hibák lehetséges okai – mi a teendő valamely hibaüzenet láttán.Látható ebből, hogy a felhasználói és a fejlesztői dokumentáció több közös jellemzőt tartalmaz.

ProgramismertetőA programismertető célja a vásárló, programkereső ember meggyőzése arról, hogy e program felel meg legin­kább igényeinek. Ez a hangzatos, reklám jellegű stílus mellett a következőket igényli:

• a feladat rövid, szöveges leírása, áttekintési céllal.• a program tulajdonságainak rövid leírása.• minimális hardver és szoftver (operációs rendszer és az esetlegesen megkívánt egyéb, a programmal

együtt nem „szállított” szoftverkellékek, pl. driverek, dll­ek stb.) környezet.

Installálási kézikönyv, operátori kézikönyvNagyobb programok esetén külön installálási (üzembe helyezési) kézikönyvet mellékelnek, máskor ez a fel­használói dokumentáció része. Ebben szerepel mindaz az információ, aminek segítségével egy­több generálólemezről   a  program   elhelyezhető   a  gépünkön   úgy,   hogy  az   aktuális   környezetben   optimálisan   működjön.(Ügyelni kell arra, hogy az installáció minél kevesebb számítástechnikai ismerettel végrehajtható legyen! Fel

44

lehet használni olyan célprogramokat, amelyeket kifejezetten erre terveztek, de legalább egy batch programmalautomatizálni kell. Ilyen automatizmus esetén is dokumentálni kell az installációs folyamat lépéseit.)Az operátori kézikönyv olyan rendszereknél különül el a felhasználói kézikönyvtől, ahol más a program fel­használója és más a kezelője.

Dokumentáció tulajdonságai

SzerkezetA dokumentáció elsődleges célja segítségnyújtás a program leendő felhasználóinak, továbbfejlesztőinek. Ezértolyannak kell lennie, hogy minden számukra szükséges tudnivalóhoz könnyen hozzájuthassanak. Ehhez elsőd­leges szempont természetesen, hogy a dokumentáció mindezeket tartalmazza, de a használatát egyéb követel­mények betartásával jelentősen megkönnyíthetjük. Ezek a következők:

• a dokumentáció ne legyen túl  hosszú,  hiszen egy program használatához senki sem akar egy „re­gényt” elolvasni;

• a dokumentáció ne legyen túl rövid, mert akkor tömörsége miatt érthetetlen lesz, s így használhatat­lan;

• a dokumentáció legyen világosan tagolt, és a tagolás segítse elő az egyes tudnivalók gyors keresését;• a dokumentáció legyen tömör: az olvasója ne vesszen el a részletekben;• a dokumentáció   legyen olvasható:  a  túlságos (és kizárólagos)   formalizálás  az érthetőség rovására

megy;• a dokumentáció legyen pontos: az olvasója minden kérdésére tartalmazza a választ.

FormaA dokumentáció használatát néhány formai jellemző nagyban megkönnyítheti. Ezek egyike a tartalomjegyzék.Másik, dokumentációkban ennél ritkábban használt, de néha kifejezetten nagy segítséget nyújtó eszköz az in­dex.Az nyilvánvaló, hogy világos szerkezetű kell legyen: kitalálható mondanivalójú fejezetekre bontva. További stí­lusjegyek megegyeznek bármely szakmai kiadványéval.StílusA programismertető egyértelműen reklámcélra szolgál. Itt dicsérni kell a programot, kiemelve jó tulajdonságait.A felhasználói dokumentáció elsősorban részletes szöveges leírás, amely időnként lehet „szájbarágó” is. (Cél­szerű figyelembe venni a várható felhasználói kört a leírás részletességének, a szájbarágósság szintjének meg­tervezésénél. Például teljességgel fölösleges egy Windows környezetben futó program esetében az ablakkeze­lésről általánosságban szólni.)A fejlesztői dokumentációban minden más szempontnál fontosabb a pontosság, emiatt ebben kerülhet elő a ma­tematikai leírás, a formális specifikáció.Az installálási, illetve az operátori kézikönyv elsősorban utasítások, teendők pontos felsorolása, utalva a lehet­séges válaszok következményeire.

45

Dokumentáció általános alakja

46

Felhasználói dokumentáció

Feladat”Feladat megfogalmazása.”

HasználatA program indítása:

”Honnan indul, mi a program neve.”A program indítása:

Egy lehetséges párbeszéd:”A felhasználó mit lát."

A program eredménye:”Egy példa eredmény kiírása, amit a felhasználó látna.”

Hibalehetőség:”Ha a program hibákat kezel, hogyan is teszi, mit fog tapasztalni a felhasználó.”

Fejlesztői dokumentáció

Feladat”Feladat megfogalmazása.”

Környezet”Milyen gép, operációs rendszer, program szükséges hozzá.”

Forráskód”A forráskód milyen néven, és hol található.”

MegoldásFontosabb típusok

”Változók, konstansok megadása.”

Algoritmus”A feladat megoldása mondatszerű algoritmus leírással.”

Kód”A program kódja.”

47

TesztelésÉrvényes tesztesetek:

”helyes eredményhez vezet.”

Érvénytelen tesztesetek:”Hibás adatok megadására példák.”

Hatékonysági tesztesetek {Egyelőre nincsenek.}

Fejlesztési lehetőségek”Hogyan lehet fejleszteni a programot.”

Készítő”Program készítőjének neve”

Példa dokumentációra

48

Felhasználói dokumentáció

FeladatA program olvasson be két számot, adja össze azokat, majd írja ki az összeget!

HasználatA program indítása:

Dokumnetumok könyvtárban taláható osszeg.pyIndítása Terminálból python osszeg.py prancs kiadásával.

A program indítása:Egy lehetséges párbeszéd:

A program eredménye:

Hibalehetőség:Szám helyett szöveg megadása, a hiba nincs lekezelve.

Kérem az első számot:12Kérem az első számot:3

A két szám összege:15

Strukturált program

Böhm­Jacopini tétel: (1966)

49

Fejlesztői dokumentáció

FeladatA program olvasson be két számot, adja össze azokat, majd írja ki az összeget!

Környezet

ForráskódDokumnetumok könyvtárban taláható osszeg.pyIndítása Terminálból python osszeg.py prancs kiadásával.

MegoldásFontosabb típusok

szam1, szam2, osszeg: Valós

AlgoritmusProgram osszeg:

Ki: „Kérem az első számot:”Be: szam1Ki: „Kérem a második számot:”Be: szam2osszeg=szam1+szam2Ki: „A két szám összege:”Ki: osszeg

Program vége

Kód szam1=raw_input(”Kérem az első számot:”) szam2=raw_input(”Kérem a második számot:”) osszeg=szam1+szam2 print(„A két szám összege”+str(osszeg))

TesztelésÉrvényes tesztesetek:

szam1=2, szam2=3, osszeg=5szam1=-2, szam2=3, osszeg=1

Érvénytelen tesztesetek:szam1=a, szam2=2

Hatékonysági tesztesetek {Egyelőre nincsenek}

Fejlesztési lehetőségek Szöveg típust ne olvashasson be.

KészítőDobosné Varsányi Anita

A szekvencia, szelekció és az iteráció segítségével minden olyan algoritmus felépíthető, amelynek egy belépésiés egy kilépési pontja van. A csak szekvenciákból, szelekciókból és iterációkból építkező programot strukturáltprogramnak nevezzük. A strukturált programozásban a ciklusból való kiugrás fogalma ismeretlen. Ebből kö­vetkezik, hogy a program minden szekvenciájának ­ és így az egész programnak is ­ egyetlen belépési és egyet­len kilépési pontja van, ennélfogva a program lényegesen áttekinthetőbb. Szekvencia: egymás után végrehajtható utasítások sorozata.Szelekció: választás megadott tevékenységek közül.Iteráció: megadott tevékenységek ismételt végrehajtása.

Típusok

Nyelvek típusosságaA típus egy algebrai struktúra: értékhalmazból és azon értelmezett műveletekből áll. A típusfogalom erőteljes­sége alapján típus nélküli, típusos, erősen típusos nyelvekről.Gyengén és erősen típusos nyelvekAzokat a nyelveket, amelyekben kötelező minden használni kívánt változót deklarálni és minden adattípussalszigorúan csak olyan műveletet enged végezni, amely a típusra lehetséges, erősen típusos nyelvnek nevezzük.Ezzel szemben a gyengén típusos nyelvekben nem kötelező a változók deklarálása. A fordító az első értékadás­kor állapítja meg , hogy használni kívánjuk a változót, a kapott értékből állapítja meg a típust és a definiálástautomatikusan elvégzi. A műveletek ellenőrzésekor is kevésbé szigorú, ugyanis, ha találkozik egy olyan műve­lettel, amely az adott típussal nem elvégezhető (pl. karakterek szorzása), akkor megpróbálja az adatokat olyantípusúvá átalakítani, amelyre értelmezve van a művelet.A gyengén típusos nyelvek nagy hátránya, hogy a hibák felderítése hihetetlenül megnehezedik. Például, ha elír­juk egy változó nevét, akkor azt hiszi a fordító, hogy egy új változót szeretnék használni. Az erősen típusosnyelvek esetén, ha elírjuk a változó nevét egy helyen, akkor szól a fordító, hogy ilyen nevű változót nem dekla­ráltunk. Előnyük viszont, hogy nem kell "vacakolni" a deklarációval. Hosszabb programok esetén megéri azerősen típusos nyelvek használata. Gyengén típusos nyelv pl. a Visual Basic, JavaScript.Erősen típusos nyelv pl. a C++, JAVA, Delphi(Pascal)

TípuskompatibilitásMikor végezhető el a következő A:=B értékadás? Az egyértelmű válasz, akkor, ha azonos típusúak. Két típusazonos, ha szerkezetük azonos.

TípuskényszerítésHa kifejezésben különböző típusú tényezők szerepelnek, akkor vagy kötelező a felhasználónak típuskonverziósfüggvénnyel azonos típusúvá alakítani őket, vagy automatikus konverzió, típuskényszerítés történik.

AltípusOlyan típus, amely értékeit egy másik típus értékhalmazából veszi, örökli a másik típus műveleteit, s a másik tí­pussal minden esetben kompatibilis.

Származtatott típusEz egy másik típusból származó típus, értékeit a másik típus értékhalmazából veszi, műveleteit örökölheti azőstípustól, s az őstípussal nem ekvivalens típus.

Statikus és dinamikus típusokStatikusnak nevezünk egy típust, ha az adott típushoz tartozó értékek a memóriában mindig azonos helyet fog­lalnak el.Dinamikus típushoz tartozó értékekhez futás közben különböző tárterület tartozik.

50

Paraméteres típusParaméteres típusok paraméterezhetők konstansokkal, változókkal, típusokkal.

Adatok, adatszerkezetek

VáltozóA változó egy elnevezett memória terület. Jellemzői: a neve, memóriacíme, típusa, pillanatnyi értéke. A válto­zókat első használat előtt deklarálni kell, azaz meg kell adni a változó nevét és típusát. Ennek hatására a fordítóautomatikusan kijelöl egy (virtuális) memóriacímet ennek a változónak. Arról, hogy melyik cím lett lefoglalvaa változó számára a programozónak nem kell tudnia, hiszen a programban mindenütt a változó nevével hivatko­zunk a területre. Erre a területre eltárolhatunk adatot (ha már volt ott adat, akkor felülírva azt), azaz értéketadunk a változónak, illetve hivatkozhatunk a pillanatnyilag éppen ott található értékre.Tehát az érték megvizsgálható és módosítható. - A változó neve: nevek képzésének vannak szabályai, ezek természetesen programozási nyelvenként eltérő­

ek lehetnek. Legtöbb nyelvben a szabályok a következők: a nevek betűkből és számokból állhatnak, betűvelkell kezdődjenek (semmiképpen sem lehetnek bennük írásjelek vagy szünet!!). 

- A változó memóriacíme: nem kell ismernünk az értékét, de bizonyos nyelvekben felhasználjuk, lásd ké­sőbb.

- A változó pillanatnyi értéke: egy változónak a definiálás pillanatától kezdve van pillanatnyi értéke. Mégakkor is ha még nem adtunk neki értéket (persze ez az érték nem valódi eltárolt érték), de ilyenkor nem cél­szerű felhasználni a pillanatnyi értéket. A definiált, de még értéket nem kapott változókat inicializálatlanváltozóknak szokás nevezni. Egyes nyelvek fordító programjai nem engedik felhasználni az inicializálatlanváltozók értékét, míg más nyelveknél a programozó felelőssége, hogy ne használja.

- A változó  típusa: a típus egyrészt meghatározza a lefoglalt memóriaterület nagyságát, van 1 byte­os, 2byte­os, 4 byte­os, stb. másrészt meghatározza, hogy az adatot hogyan lehet kezelni, egész számként, valósszámként, karakterkódként, stb. harmadrészt meghatározza, hogy milyen műveletek végezhetők az adattal.

KonstansA konstans is egy memóriatartományt reprezentál, adott típusú értéket tárolhat, ez az érték megvizsgálható, denem módosítható.

Definíció, deklarációA definíció és deklaráció szinte teljesen azonos fogalmak. Ha változó deklarálásáról beszélünk, akkor azt akar­juk kifejezni, hogy megadjuk a fordító számára egy használni kívánt változó nevét és típusát. Ha változó defini­álását emlegetünk változó deklarálása helyett, akkor azzal azt hangsúlyozzuk ki, hogy lefoglalódik egy hely aváltozónak a memóriában. Egy változót egyszer lehet definiálni, de bizonyos körülmények között előfordul,hogy  többször deklaráljuk. Vagyis egyszer  történhet  egy változó  számára helyfoglalás,  de lehetséges,  hogytöbbször is tudatnunk kell a fordítóval a változó nevét és típusát. (Például többmodulos programok esetén.)InicializálásInicializálásnak nevezzük, amikor egy változó definiálásával egyidejűleg értéket is adunk a változónak. (Nemösszetévesztendő az inicializált változó fogalmával, lásd változó pillanatnyi értéke.)DeklarációkiértékelésA deklarációs rész végrehajtása kétféleképpen történhet, a statikus deklarációkiértékelés fordításkor elvégezhe­tő, a dinamikus deklarációkiértékelés viszont csak futási időben.

AzonosítóA programozási nyelv objektumaihoz, konstansaihoz, változóihoz, típusokhoz, programegységeihez, fordításiegységekhez rendelt nevet hívjuk azonosítónak.Az azonosítók elnevezésere a programozási nyelvek különböző szabályokat vezettek be. Általános szabály: az

51

azonosítók betűkből és számjegyekből állhatnak.

Védett azonosítókProgramozási nyelvek egy része fordíthatóság miatt megtiltja, hogy alapszavait azonosítóként használjuk. Eze­ket a nem használható azonosítókat nevezzük védett azonosítóknak.

Azonosítók átlapolása (túlterhelés)Különböző objektumokat általában különböző azonosítóval jelöljük, de ez nem mindig van így. Két objektumneve lehet ugyanaz, ha a hatáskörük különböző.

Hozzáférési jogAz adat módosíthatósága és lekérdezhetősége.

KezdőértékKezdőértéknek nevezzük a memóriába képezéskor a lefoglalt helyre elhelyezett értéket.

HatáskörEgy azonosító hatáskörének nevezzük a programszöveg azon tartományát, amelyben a definíciója érvény­ben van.

Globális: minden eljárásból elérhető.Saját: Csak az adott eljárásban használhatóLokális: Csak az őt közvetlenül tartalmazó eljárásban használható.

LáthatóságA program azon része, ahol lehetséges a hozzáférés (egy lokális változó eltakarhat egy külső változót).Blokkstruktúra esetén egy programegység belsejében egy másik programegység az azonosítókat újradefini­álhatja. Ekkor a belső azonosító hatáskörében eltakarja a külsőben definiált azonos nevű azonosítót. Azt aprogramszövegbeli   tartományt,  ahol az azonosítót   semmi sem takarja,  nevezzük  láthatósági körnek.  Ezvagy azonos a hatáskörrel, vagy része annak.

ÉlettartamA futási idő azon része, ahol az azonosító ugyanazt az adatot jelenti. Statikus változónak nevezzük azokat aváltozókat, amelyek élettartalma a program teljes futási ideje. Ezeket a fordítóprogram egy statikus memó­riahelyen helyezi el. Dinamikus változók a program futási idejének csak egy részében létezik.

TípusAz alábbi adattulajdonságok összessége: értékhalmaz, műveletek, ábrázolás.

ÉrtékhalmazAz a halmaz, amelyből a változó értéket vehet fel.

Adat csoportosítása(értékhalmaz szempontjából)

Egyszerű típusokSzerkezetileg nem bontható tovább.Például: egész,

  valós,  logikai,  karakter,

52

  mutató (adat címe),  felsorolás,  intervallum.

Összetett(strukturált) típusokSzerkezettel rendelkezik.Például: rekord (különböző típusú, de logikailag összetartozó típusok együttes kezelése),   

 halmaz, szöveg (karakterek sorozata), sorozat, tömb (mátrix).

Típus meghatározásnál megadjuk az értékhalmazát, a hozzátapadó műveletek, a relációk körét.Az elemi adattípusok lehetséges műveleteit 3 csoportba szokás sorolni:

értékadó,típusátviteli:             relációs,             szelekciós (egy elem kiválasztásának módja),             konstrukciós (hogyan képezzük),             számosság (hány elemű az értékhalmaz),transzformációs (ugyanarra a típusra képez le, például +,­,min, előző).

Az összetett adattípusok műveletei további csoportokat alkothatnak:lekérdező (egy­egy érték kiolvasása),bővítő (új adat felvétele),szűkítő (adat törlése),mozgató (kívánt adat kiválasztása),egyéb (hibakezelés, hány eleme van,...).

A típus harmadik jellemzője az adatok memóriában történő tárolása.

Egész típus

Értékhalmaz­32768..32767 (Min'Egész..Max'Egész)

Műveletek+, –, *, Div (egészosztás), ^ (pozitív egész kitevős hatványozás), Mod, ­ (unáris mínusz) .

Relációk=, <, ≤, >, ≥, ≠.

Ábrázolásún. kettes komplemens kódú.

53

Valós típus

Értékhalmaz????..???? (Min'Valós..Max'Valós nem definiáltak, vagy implementációfüggő)

Műveletek+, –, *, /, ^, ­ (unáris mínusz).

Relációk=, <, ≤, ≥, >, ≠.

Ábrázolásún.  lebegőpontos ábrázolás  (mint az alábbiakból kitűnik, pontosabb lenne, ha e típust  racionálisnak  nevez­nénk, mert csak racionális számot képes ábrázolni).

Logikai típus

ÉrtékhalmazHamis..Igaz (Min'Logikai..Max'Logikai: Hamis, illetve Igaz)

MűveletekNem, és, vagy (a szokásos logikai műveletek) .

Relációk=, <, ≤, ≥, >, ≠ (a belső ábrázolásuk alapján).

Ábrázolás0 =Hamis ­1 =Igaz(néha 1 =Igaz).

Karaktertípus

Értékhalmaz0..255­kódú jelek (Min'Karakter..Max'Karakter: a 0, illetve a 255 kódú karakter)

Műveleteknincs.

Relációk

54

=, <, ≤, ≥, >, ≠ (a belső ábrázolásuk alapján).

ÁbrázolásValamely ún.  karakter­készlet  alapján.  Példaként az ASCII karakter­készletből   lássunk néhány kód­hozzárendelést:

0–31: ún. kontrollkarakterek; 32–64: szóköz, szokásos írásjelek, illetve számjegyek (48–57 = '0'–'9'); 65–91: nagybetűk; 92– : kisbetűk, grafikus jelek (erősen implementációtól függően).

Felsorolástípus

Mindazon típusokat, amelyek értékkészletét konstansainak egyszerű fölsorolásával adhatjuk meg, diszkrét tí­pusnak hívjuk. Speciálisan tehát ilyen az egész, a logikai, a karakter, de lehet bármilyen –a program írója általkreált – absztrakt konstansokat tartalmazó ún. absztrakt felsorolástípus is.

Értékhalmaz(konstans1, konstans2, … , konstansN) (Min'Típus..Max'Típus: konstans1..konstansN)A konstansok maguk a típus értékkészletét meghatározó rendezett absztrakt értékek.

Műveleteka rendezettségre építenek az alábbi függvények; nem értelmezett helyeken nem definiált az értékük:

Következő (típusbeli kifejezés), Előző (típusbeli kifejezés), Rend (típusbeli kifejezés).

A deklarációban a kezdőérték megadásához a korábbi szokás szerint használható a Típusnév nevű konstrukciósfüggvény. Emellett azonban a végrehajtáskor sokszor jó haszonnal jár az alábbi értelmezésű párja:Típusnév(0..Rend(Max'Típusnév)).Ez utóbbi függvény jelentése: a paraméterként „megadottadik” típusbeli konstans. Tehát mintha ez a  Rend­függvény inverzeként viselkednék!

Relációk=, <, ≤, ≥, >, ≠ (a felsorolás sorrendje egyben a rendezés is).

(Rész)Intervallumtípus(diszkrétből származtatott típus)

Értékhalmazkonstans1..konstans2 (Min'Típus..Max'Típus: konstans1..konstans2)A származtatás által meghatározott bázistípus adott részhalmaza, helyesebben részintervalluma.

MűveletekUgyanazok, amik a bázistípuson értelmezettek (a felsorolástípusoknál említett típuskonstrukciós függ­vényt itt nem definiáljuk; lásd a példa utáni megjegyzést!).

RelációkUgyanazok, amik a bázistípuson értelmezettek.

55

Valós résztípus

Értékhalmazvalós kons1 ... valós kons2 valós kons3­lépéssel(Min'Típus..Max'Típus: kons1... kons2)Olyan valósakat tartalmaz, amelyek előállíthatók a kons1+i*kons3 formulával, ahol i = 0..(kons2­kons1) /kons3.

MűveletekKorlátozott valós műveletek (csak a formulával előállíthatók jöhetnek ki – automatikus kerekítéssel, haszükséges), vagy ha nem ilyen, akkor mint „egyszerű” valós értékkel lehet csak továbbszámolni.

Relációkvalós relációk.

Rekord

A rekord segítségével több (akár különböző) típusú adatot „egyesíthetünk” egyetlen egésszé. A rekord felhasz­nálásával létesíthetünk egy újtípust, amely a definiáláskor felhasznált típusokból tevődik össze.Egy ilyen rekordtípusú adat kezeléséhez bevezettünk ún. konstrukciós és szelekciós műveleteket. Az előbbivellétre tudunk hozni ilyen típusú adatot, az utóbbiakkal az egyes összetevők hozzáférését biztosítjuk. Az egyesösszetevőknek egyedi nevet kell adni a definiáláskor, ami egyben a hozzáférést lehetővé tevő műveletben is előfog bukkanni. Ezt hívják mezőnévnek, amit azonosít, azt mezőnek.Értékhalmaz

alaptípus direktszorzata (pl. szöveg X egész)

Műveletekértékadás, reláció (=, <, >), kiválasztás (ponttal jelöljük)

ÁbrázolásMezőnként folytonos memóriaterületen

PéldaTDátum=Rekord(év,hó,nap:Egész)

   TSíkPont=Rekord(x,y:Valós)   THallgató=Rekord(kód:Egész, név:Szöveg, szül:Tdátum)

Változó: valaki: THallgatóvalaki.név a hallgató nevét jelenti

Vektor/Tömb

A programozásban a vektor a tömb más néven. A lényege, hogy sok azonos típusú elemet egyesítünk a vektorfogalmában egy adategységgé. Itt is egy típuskonstrukciós eszközről van szó, hasonlóan a rekordhoz, és épp­úgy kell, legyen konstrukciós és szelekciós műveletének.Értékhalmaz

Alaptípus iteráltja és a lineáris rendezettség jellemzi: pontosan egy megelőző és következő létezik.

56

MűveletekAlaptípussal megegyezik, kiválasztás.

Megadásanév(indextípusok felsorolása:értéktípus) alakban történik.

Példa  TSíkPont=Tömb[1..2:Valós]   [a korábbi síkbeli pontok egy másfajta tipizálása]  TNevek=Tömb[1..MaxN:Szöveg]   [MaxN db nevet tartalmazó vektorok típusa]Konstans  O:TSíkPont(0,0)  [konstans deklaráció: origó]Változó  Névsor:TNevek  [kezdőérték explicit megadása nélküli létrehozás]

Mátrix

A mátrix „különlegessége” – a vektorhoz képest – az, hogy nem egy, hanem kettő indexszel jelölhetők ki azelemei, azaz beszélhetünk a mátrix sorairól (ezt jelöltük ki az első indexével) és oszlopairól (ezt a második in­dexe határozta meg). Nyilván a definiáláskor (de legkésőbb létrehozásakor) kell megadni a sorainak és oszlo­painak a számát.Példa  TMárix=Tömb[1..MaxN,1..MaxM:Valós] [egy MaxN*MaxM­es mátrix tipizálása]  TKeresztRejvény=Tömb[1..10,1..10:Karakter] [egy 10*10­es keresztrejtvény típusa]Változó  m:TMátrix  [kezdőérték explicit megadása nélküli létrehozás]  rejtvény:TKeresztRejtvény  [kezdőérték explicit megadása nélküli létrehozás]

Halmaz

ÉrtékhalmazAz alaptípus iteráltja, amely rendelkezik a halmaz tulajdonsággal (minden elem különböző, nincs sor­rendiség)

MűveletekÉrtékadás, halmaz relációk, unió, metszet, különbség, eleme­e, üreshalmaz (ez hozza létre), jele: [].

Példanapok=(hétfő,kedd,szerda, csütörtök,péntek,szombat,vasárnap)Halmaztípus=Halmaz(napok) vagy SET OF napok

Szöveg

ÉrtékhalmazKarakterek direkt­szorzata, lehet fix hosszúságú, vagy változó.

Műveletek

57

Értékadás, reláció (karakter kódra), + (konkatenáció), jele(szöveg,i) a szöveg i­dik karaktere, melyet ál­talában 0­tól számolunk, esetleg szövegkezelő függvények.

PéldaVáltozó: s: szövegs:=”Ez egy példa”

Sorozat

ÉrtékhalmazAlaptípus iteráltja és a lineáris rendezettség jellemzi: pontosan egy megelőző és következő létezik.

MűveletekAz alaptípussal megegyezik, kiválasztás.Megadása: név(indextípus:értéktípus) alakban történik.A sorozatot egydimenziós tömbbel valósítjuk meg.

Példaváltozó s: sorozat(1..10:egész) nem használatos helyette:változó s: tömb(1:10:egész), vagy tömb[1..10:egész]Ki: s(1)

58

Számábrázolások

SzámábrázolásAmikor a számítógépben egy értéket ábrázolunk, azt mindig adott méret u tárterületen tehetjük. Így nem kezel ­hetünk akármilyen számokat, az ábrázolás korlátja a felhasználható bitek száma, melyet mindig előre rögzítenikell. Egy bájt bitjeit 0­tól 7­ig szokás számozni, ahol 0 a legalacsonyabb helyi értékű bit. 

Fixpontos ábrázolásFixpontos szám ábrázolás során az ábrázolás előre rögzített kettedes jegy pontos, azaz a kettedes és egész je­gyek száma adott. Ezt általában egész számok ábrázolását jelenti, mikor a kettedes jegyek száma nulla. Szokat­lan ugyan, de elképzelhető a valós számok fixpontosábrázolása.Nemnegatív egész számok A decimálisan adott számot binárissá alakítjuk, majd tároljuk, a megadott méretű területen, hogy ezt valóbankitöltsük, balról nullákkal egészítjük ki a számot.Példa:

A legkisebb ábrázolható szám n biten: 0 A legnagyobb ábrázolható szám n biten: 2n−1Egész számok A negatív számok ábrázolásara három megoldás létezik, melyekből az utóbbi kettő használatos. 1. Előjeles egész szám ábrázolás Az előjeles ábrázolásnál a legmagasabb helyi értékű bitet előjel jelzésére tartjuk fenn. Megállapodás szerint apozitív előjelnek a 0, míg a negatívnak az 1­es felel meg. A fennmaradó biteken a szám abszolút értékét tárol­juk. Problémát jelent azonban, hogy nulla kétféle is létezik, +0 és −0, valamint a kivonás művelete viszonylagkomplikáltan implementálható.Példa:

A legkisebb ábrázolható szám n biten: −2n−1−1 A legnagyobb ábrázolható szám n biten: +2n−1−12. Kettes komplemens A negatív számok helyett azok kettes komplemensének tárolását jelenti. A kettes komplemens az egyes komp­lemensnél eggyel nagyobb szám, ahol az egyes komplemens egyszerűen a szám bitenkénti negáltja (amennyi­ben bináris számról van szó). Egy ábrázolt szám legmagasabb helyi értékű bitje pontosan akkor 1, ha a számnegatív volt (bár nem tárolunk előjelet, ez mégis olyan egyszerűen megállapítható, mint az előjeles ábrázolás­nál). A negatív számot úgy kapjuk vissza, hogy a kettes komplemens képzését visszafelé hajtjuk végre, avagyismét a kettes komplemensét képezzük. Előnye, hogy a kivonást nem kell implementálni, ez egyszerűen negatívszám hozzáadását jelenti. A kettes komplemens előállítása közben túlcsordulás léphet fel, de ekkor a túlcsordultbittel nem foglalkozunk.Példa:

59

A legkisebb ábrázolható szám n biten: −2n−1 A legnagyobb ábrázolható szám n biten: +2n−1−1 3. Feszített előjeles ábrázolás Szokás eltolásos vagy alapértékes ábrázolásként is emlegetni. A negatív számokat is úgy tároljuk, mintha pozi­tívak lennének. Ezt úgy érjük el, hogy minden ábrázolni kívánt számhoz hozzáadunk egy előre rögzített c kons­tans értéket. A legkisebb ábrázolható szám −c lehet. Az összeadást elvégezve, így mindenképp nem negatívszámot kapunk, melynek ábrázolása már ismertetésre került. Előnye, hogy lebegőpontos számításoknál, ha a ki­tevőt így tároltuk el, az egyes számjegyek valódi helyi értékei könnyen kiszámíthatók. Az előjel megállapításá­hoz azonban vissza kell alakítani a számot.Példa:

A legkisebb ábrázolható szám n biten c = 2n−1 mellett: −2n−1 

A legnagyobb ábrázolható szám n biten c = 2n−1 mellett: +2n−1−1

Lebegőpontos ábrázolásA lebegőpontos szám ábrázolás a számok hatványkitevős felírásán alapszik. 

e ∙ M ∙ a k  e   {−1, +1} ∈Hogy e felírás egyértelmű legyen, M mindig kisebb kell legyen, mint 1, és az első nem egész jegy nem lehet 0. 

1/a ≤ M < 1 A lebegőpontos szám többnyire bináris számok hatványkitevős alakja. Többféle megoldás létezik, melyből ket­tőt nézünk meg, mindkét esetben az egyszeres pontosságú (4 bájton történő) ábrázolást tekintve: Hexadecimális alap Az IBM gépek a bináris számot hexadecimális alakban képezik le, és így végzik el a normálást, azaz a törtrészelső hexadecimális jegyének kell nullánál nagyobbnak lennie. A legmagasabb helyi érték u bit mindig a szám előjele. Ezt követi a karakterisztika mely most 7 bites, így a maradék három bájton, a mantissza (M ) mint 6számjegyű hexadecimális szám jelentkezik. A karakterisztika feszített előjeles, ahol c = 64. Példa:

Bináris alap A PDP típusú gépek a bináris számot normálják. Ez azt jelenti, hogy az első kettedes jegy legyen nullánál na­gyobb. Mivel bináris számoknál ez mindig az 1­es értéket fogja jelenteni, ennek tárolása felesleges, a fennmara­dó egy bittel kibővíthetjük a karakterisztikát, mely így 8 bitesre duzzad. A karakterisztika eltolása c = 126 (eztáltalában 128­nak kéne venni 8 bites feszített előjeles ábrázolás esetén, a konkrét példa azonban, melyet a ma­napság is használt valós típus szolgáltat, nem ilyen). Így az ábrázolható számok: 1, 5   10 −45 . . . 3, 4   10 38∗ ∗tartományba esnek és 7–8 tizedes jegyre pontosak. Példa:

60

Programozási tételek

Programozási tétel fogalmaA programozási tételek típusalgoritmusok, amelyek alkalmazásával garantáltan helyes megoldást adhatunk aprogramozási munka során gyakran előforduló, tipikus programozási feladatokra. A programozási tételek nem egyedi feladatokra, hanem feladatosztályokra adnak megoldást, ezért a megfogal­mazásuk is általános.Azokat a típusalgoritmusokat tekintjük programozási tételeknek, melyeknek  helyessége  (matematikai jellegűmódszerekkel) bizonyított.

Tételek megfogalmazásának elemeiFeladatkitűzés: az általános feladat szöveges formábanSpecifikáció: az általános feladatban szereplő adatok (intervallumok, függvények, relációk) megadása, elő­ és utófeltételek megadásaAlgoritmus: az általános specifikációban szereplő adatok segítségével megfogalmazott megoldás. 

Tételek alkalmazásának lépéseiSpecifikáljuk a konkrét programozási feladatot.A specifikáció ismeretében eldöntjük, hogy az adott feladat programozási tétellel megoldható­e.Ha igen, kiválasztjuk a megfelelő programozási tételt. Néha ez többféleképpen is megtehető.A tételben szereplő általános elemeket megfeleltetjük az aktuális feladat konkrét adatainak.A megfeleltetés és a tétel általános algoritmusa alapján behelyettesítés módszerével megadjuk az aktuális feladat megoldását.

Tételek csoportosításaA programozási tételek a bemenő és kimenő adatok jellege szerint az alábbi módon csoportosíthatók:

• Egy sorozathoz egy értéket rendelő tételek.  Ide soroljuk azokat is, amelyek egy sorozathoz néhány (kettő, három) egymással összefüggő értéket rendelnek. (Pl. lineáris keresés.)

• Egy sorozathoz egy sorozatot rendelő tételek.  Pl. Rendezések, kiválogatás.• Egy sorozathoz több sorozatot rendelő tételek.  Pl. szétválogatás• Több sorozathoz egy sorozatot rendelő tételek.  Pl. Metszet, unió.

Egy sorozathoz egy értéket rendelő tételek

Összegzés tétele

KitűzésAdott egy sorozat, a sorozat elemein értelmezett egy ’+’ művelet.Feladat: Határozzuk meg a sorozat elemeinek az összegét!Specifikáció

m,n: egész (tömb kezdő és vég indexe)f:[m..n] H-ból veszi elemeit, H-n értelmezett + művelets: H (s a végeredmény)

Előfeltétel: m,n, f adott, m<=n

Utófeltétel: s=∑i=m

n

f ( i)

/ azaz s tartalmazza az f függvény [m..n] intervallum elemeihez rendelt függvényértékeinek az összegét /Algoritmus 

Eljárás Összegez:

61

s:=0Ciklus i:=m-től n-ig

s:=s+f(i)Ciklus vége

Eljárás vége

Megszámlálás tétele

KitűzésAdott egy sorozat, a sorozat elemein értelmezett egy T tulajdonság.Feladat: Határozzuk meg a sorozat T tulajdonságú elemeinek a számát!Specifikáció

m,n: egészT:[m..n] -> logikai s: egész

Előfeltétel: m,n, T adott, m<=n

Utófeltétel:

n

)i(Tmi

1s

/ azaz s tartalmazza az [m..n] intervallum azon elemeinek a számát, amelyekhez T igazat rendel /Algoritmus

Eljárás Megszamlal:s:=0Ciklus i:=m-től n-ig

Ha T(i) akkors:=s+1

Elágazás végeCiklus vége

Eljárás vége

Eldöntés tétele

KitűzésAdott egy sorozat, a sorozat elemein értelmezett egy T tulajdonság.Feladat: Döntsük el, hogy van-e a sorozatban T tulajdonságú elem!Specifikáció

m,n: egészT:[m..n] -> logikai L:Logikai

Előfeltétel: m,n, T adott, m<=n

Utófeltétel: L=∃ i∈[m .. n ] :T ( i)

/ azaz L igaz, ha létezik () az [m..n] intervallumban olyan elem, amelyhez T igaz értéket rendel /

Algoritmus Eljárás Eldontes:

i:=mCiklus amíg (i<=n) és nem(T(i))

i:=i+1Ciklus végeL:=(i<=n)

62

Eljárás vége

Kiválasztás tétele

KitűzésAdott egy sorozat, a sorozat elemein értelmezett egy T tulajdonság, és tudjuk, hogy van a sorozatban T tulaj-donságú elem.Feladat: Határozzuk meg az első T tulajdonságú elem sorszámát!Specifikáció

m,n: egészT:[m..n] -> logikai Ind:egész

Előfeltétel: m,n, T adott, m<=n, ∃i∈[ m . . n ]:T ( i ) / azaz, van olyan elem [m..n]-ben, amelyhez T igazat rendel /

Utófeltétel: ind∈[m . .n ] és T ( Ind ) és ∀ i∈[ m . . Ind−1 ]: nem(T ( i))

/azaz az Ind az első (legkisebb) olyan elem az [m..n] intervallumban, amelyhez T igaz értéket rendel /Algoritmus 

Eljárás Kiválasztás:i:=mCiklus amíg nem(T(i))

i:=i+1Ciklus végeInd:=i

Eljárás végeFeladatok

- határozzuk meg az A és B pozitív egészek legkisebb közös többszörösét!- Adott síkbeli pontok közül válasszuk ki az origótól legtávolabb lévő pontot!- Határozzuk meg az A..B egész intervallum elemei közül azt az egész számot, amelynek a legtöbb

prímosztója van! (A>0)

Egy sorozathoz egy sorozatot rendelő tétele

Másolás, transzformálás tétele

KitűzésAdott egy sorozat, a sorozat elemein értelmezett egy függvény (transzformáció).Feladat: Másoljuk a sorozat elemeinek a transzformáltjait egy másik sorozatba.Specifikáció

A:Tömb[1..Max]:HA

N:egész / A és B elemszámaf: HA -> HB

B:Tömb[1..Max]:HB

Ef: A, N adott, 0<= N <= MaxUf: B adott és ∀ i∈[ 1. . N ] :( B [ I ]=f ( A [ I ]) )/ Azaz B tartalmazza az A elemeinek a transzformáltjait /

AlgoritmusEljárás Masol:

Ciklus i:=1-től N-ig

63

B[i]:=f(A[i])Ciklus vége

Eljárás vége

Feladatok- Állítsunk elő egy egészeket tartalmazó tömb elemei alapján egy másik tömböt, amely ugyanezen

számok négyzeteit tartalmazza.- Állítsuk elő egy tömb elemeit fordított sorrendben egy másik tömbben!

Kiválogatás tétele

KitűzésAdott egy sorozat, a sorozat elemein értelmezett egy T tulajdonság.Feladat: Válogassuk ki a sorozat összes T tulajdonságú elemét!Specifikáció

A:Tömb[1..Max]:HN:egész / A elemszámaB:Tömb[1..Max]:HDB:egész / B elemszáma

Ef: A, N adott, 0<= N <= MaxUf: B adott és tartalmazza az A összes T tulajdonságú elemét, 0 <= DB <= N

AlgoritmusEljárás Kivalogat:

DB:=0Ciklus i:=1-től N-ig

Ha T(A[i]) akkorDB:=DB+1B[DB]:=A[i]

Elágazás végeCiklus vége

Eljárás vége

Feladatok- Adott egy egészeket tartalmazó tömb. Válogassuk ki belőle azokat, amelyek az elemek átlagától

legfeljebb 1-el térnek el.

Egy sorozathoz több sorozatot rendelő tétel

Szétválogatás tétele

KitűzésAdott egy sorozat, a sorozat elemein értelmezett egy T tulajdonság.Feladat: Válogassuk szét a sorozat T tulajdonságú, ill. nem T tulajdonságú elemeit!Specifikáció

A:Tömb[1..Max]:HN:egész / A elemszámaB,C:Tömb[1..Max]:HBDB,CDB:egész / B, C elemszáma

Ef: A, N adott, 0 <= N <= MaxUf: B, C adott; B tartalmazza az A összes T tulajdonságú elemét; C tartalmazza az A összes nem T tulajdonságú elemét; 0<= BDB <=N, 0<= CDB <=N

64

AlgoritmusEljárás Szetvalogat:

BDB:=0CDB:=0Ciklus i:=1-től N-ig

Ha T(A[i]) akkorBDB:=BDB+1B[BDB]:=A[ii]

KülönbenCDB:=CDB+1C[CDB]:=A[i]

Elágazás végeCiklus vége

Eljárás vége

Megjegyzés: a szétválogatás több (egymást kizáró) tulajdonság alapján, több vektorba is történhet. Feladat

- Egy személyi adatokat (név, nem, telefonszám, fizetés) tartalmazó vektor rekordjait válogassuk szét: nemek szerint ill. fizetési kategóriák szerint (0-50 000; 50-100 000; 100 001-150 000; 150 000-nél több)

Több sorozathoz egy sorozatot rendelő tételek

Metszetképzés tétele

KitűzésAdott két sorozat, a sorozatokon belül egy-egy elem csak egyszer szerepel.Feladat: Határozzuk meg azt a sorozatot, amely a két sorozat közös elemeit tartalmazza. Specifikáció

A,B:Tömb[1..Max]:HN,M:egész / A és B elemszámaC:Tömb[1..Max]:HL: egész / C elemszáma

Ef.: A,B adott, elemeik egyediek; 0<=N<=Max , 0<=M<=MaxUf: C tartalmazza A és B közös elemeit, 0<=L<=Min(A,B) /a metszet legfeljebb annyi elemet tartalmaz, mint a kisebb elemszámú sorozat/

AlgoritmusElve: minden A-beli elemet keresünk a B tömbben. Ha egy A-beli megtalálható a B-ben, akkor felvesszük a közös elemek közé, a C-be.

Eljárás Metszet: L:=0; Ciklus i:=1-től N-ig j:=1; / A[i] keresése B-ben Ciklus amíg j<=M és A[i]<>B[j] j:=j+1 Ciklus vége Ha j<=M akkor / Ha A[i] megtalálható B-ben L:=L+1 C[L]:=A[i] Elágazás vége Ciklus vége

65

Eljárás vége

Feladat

Ismerjük a bostoni, ill. a New York-i maratoni futóversenyeken célba érkezők névsorát. Készítsük el azok névsorát, akik mindkét versenyen célba értek!

Unióképzés tétele

KitűzésAdott két sorozat, a sorozatokon belül egy-egy elem csak egyszer szerepel.Feladat: Határozzuk meg azt a sorozatot, amely minden olyan elemet tartalmaz, amely legalább az egyiknek eleme. Specifikáció

A,B:Tömb[1..Max]:HN,M:egész / A és B elemszámaC:Tömb[1..2*Max]:H L: egész / C elemszáma

Ef.: A,B adott; elemeik egyediek; 0<=N<=Max , 0<=M<=MaxUf: C tartalmazza az A és B sorozatok unióját, Max(A,B)<=L<=M+N

Megjegyzés: a kimenő sorozat elemszáma legrosszab esetben 2*Max, ez akkor áll elő, ha A és B is Max elemet tartalmaz, és nincsen közös elemük. AlgoritmusElve: először A összes elemét átmásoljuk C-be. Majd B elemeit sorra vesszük, és mindazokat, amelyek nem szerepelnek az A tömbben, szintén C-be másoljuk.

Eljárás Unio: Ciklus i:=1-től N-ig /A elemeinek másolása C-be C[i]:=A[i] Ciklus vége L:=N Ciklus j:=1-től M-ig i:=1 / B[J] keresése A-ban Ciklus i<=N és B[j]<>A[i] i:=i+1 Ciklus vége Ha (i>N) akkor / Ha B[j] nem szerepel A-ban L:=L+1 C[L]:=B[j] Elágazás vége Ciklus végeEljárás vége

Feladat

Ismerjük a bostoni, ill. a New York-i maratoni futóversenyeken célba érkezők névsorát. Készítsük el azok névsorát, akik legalább az egyik versenyen célba értek!

Összefuttatás tétele (UNIÓ)

Az összefuttatás rendezett sorozatok rendezett unióját (metszetét, különbségét, szimmetrikus differenciáját) állítja elő. A rendezettség miatt az összefuttatás hatékonyabb, mint az egyszerű unió, metszet tétel. Az algoritmust először unióra fogalmazzuk meg.

66

KitűzésAdott két rendezett sorozat, a sorozatokon belül egy-egy elem csak egyszer szerepel.Feladat: Határozzuk meg a két sorozat rendezett unióját.

SpecifikációA,B:Tömb[1..Max]:HN,M:egész / A és B elemszámaC:Tömb[1..2*Max]:H L: egész / C elemszáma

Ef.: A,B adottak, elemeik egyediek és növekvően rendezettek; 0<=N<=Max , 0<=M<=MaxUf: C tartalmazza az A és B sorozatok rendezett unióját, Max(A,B)<=L<=M+N

AlgoritmusAz összefuttató algoritmus lényege (unió esetén), hogy a két bemenő sorozat aktuális elemeit összehasonlítva a kisebbik az eredménysorozatba kerül, és a kisebb elem sorozatában továbblépünk. Egyenlő elemek esetében az elem az eredménysorozatba kerül, és mindkét sorozatban lépünk. Ha az egyik sorozat elfogy, a másik maradék elemei bekerülnek az eredménysorozatba.

Eljárás OsszefuttatUnio: i:=1 j:=1 l:=0Ciklus amíg (i<=N) és (j<=M)

l:=l+1Elágazás

A[i]<B[j] esetén C[l]:=A[i]i:=i+1

A[i]>B[j] esetén C[l]:=B[j]j:=j+1

A[i]=B[j] esetén C[l]:=A[i] /vagy C[l]:=B[j]i:=i+1

j:=j+1 Elágazás végeCiklus vége

/ Az esetleg megmaradó elemek másolása C-be, a két ciklus közül legfeljebb az egyik hajtódik végre! /

Ciklus k:=i-től N-ig /Csak akkor fut le, ha marad elem A-ban/l:=l+1C[l]:=A[k]

Ciklus vége

Ciklus k:=j-től M-ig /Csak akkor fut le, ha marad elem B-ben/l:=l+1C[l]:=B[k]

Ciklus vége

Eljárás vége

67

Összefuttatás tétele (METSZET)

KitűzésAdott két rendezett sorozat, a sorozatokon belül egy-egy elem csak egyszer szerepel.Feladat: Határozzuk meg a két sorozat rendezett metszetét, azaz, azokat az elemeket, amelyek mindkét sorozatban szerepelnek. Specifikáció

A,B:Tömb[1..Max]:HN,M:egész / A és B elemszámaC:Tömb[1..Max]:H L: egész / C elemszáma

Ef.: A,B adottak, elemeik egyediek és növekvően rendezettek; 0<=N<=Max , 0<=M<=MaxUf: C tartalmazza az A és B sorozatok rendezett metszetét, 0<=L<=Min(A,B)

AlgoritmusMetszet esetén az algoritmus annyiban változik, hogy csak az egyező elemek kerülnek az eredménysorozatba, és a végén a két ciklus értelemszerűen elmarad.

Eljárás OsszefuttatMetszet: i:=1 j:=1 l:=0Ciklus amíg (i<=N) és (j<=M)

ElágazásA[i]<B[j] esetén

i:=i+1 /csak továbblép az A-banA[i]>B[j] esetén

j:=j+1 /csak továbblép a B-banA[i]=B[j] esetén

l:=l+1 /ez a sor az uniónál az elágazás előtt volt/C[l]:=A[i] /vagy C[l]:=B[j]i:=i+1

j:=j+1 Elágazás végeCiklus vége

Eljárás végeFeladat

Határozd meg összefuttatással a rendezett A és B sorozatok különbségét!

Keresési tételek

Lineáris keresés tételeKitűzésN elemű sorozat; sorozat elemein értelmezett T tulajdonság. Van­e T tulajdonságú elem és ha van, akkor mi asorszáma. (Eldöntés és kiválasztás együtt.)Rendelkezésre áll egy N elemű sorozat, és egy, a sorozat elemein értelmezett T tulajdonság. Olyan algoritmustkell írni, amely eldönti, hogy van­e T tulajdonságú elem a sorozatban, s ha van, akkor megadja a sorszámát(ennyivel több mint az eldöntés tétele).Specifikáció

N: egész,X: tömb[1..N:H],T:H logikai→VAN: logikai,

68

SORSZ: egészEf.: N≥0Uf.: VAN=(?i(1≤i≤N): T(X[i])) és VAN   1≤SORSZ≤N és T(X[SORSZ])→

Algoritmus     Eljárás lin_keres:

i:=1Ciklus amíg i≤N és A(i) nem T tulajdonságú i:= i+1Ciklus végeVAN:=(i≤N)Ha VAN akkor SORSZAM:=i

Eljárás vége.

Logaritmikus keresés tétele

Általános feladat: N elemű rendezett sorozat; egy keresett elem (X). Szerepel-e a keresett elem a sorozatban ésha igen, akkor mi a sorszáma.Kihasználjuk, hogy a sorozat rendezett, így el tudjuk dönteni, hogy a keresett elem az éppen vizsgált elemhezképest hol helyezkedik el.

Uf.:VAN ≡ ( i(1≤i≤N): X[i]=Y) és VAN → 1≤SORSZ≤N és X[SORSZ]=Y és∃

i(1≤i<SORSZ):X[i]≤Y és i(SORSZ<i≤N): X[i]≥Y∀ ∀

AlgoritmusEljárás log_keres:

E:=1; U:=NCiklus K:=[(E+U)/2] [E+U felének egész értéke] Elágazás

Y<X[K] esetén U:=K-1Y>X[K] esetén E:=K+1

Elágazás végeamíg E≤U és X[K]?Y

Ciklus végeVAN:=(E≤U)Ha VAN akkor SORSZ:=K

Eljárás vége.

Megjegyzések:Azért hívják logaritmikus keresésnek, mert a ciklus lépésszáma kb. log N, sokkal hatékonyabb rendezett soro-zatra, mint a lineáris keresés.

Rendezések************Buborékos rendezés

A módszer lényege

Végigmenve az adatsort tartalmazó vektoron minden szomszédos elempárt növekvő sorrendbe rakunk, azaz

meghagyjuk helyükön, vagy megcseréljük őket aszerint, hogy jó sorrendben voltak vagy sem. Egy ilyen menetvégén a legnagyobb elem a vektor végére kerül. Ugyanezt a páronkénti cserét végrehajtjuk a még rendezetlenA[1..(n-1)] részvektoron. Ezzel a második legnagyobb elem az A[n-1] elem helyére kerül. Addig folytatjuk az

69

egyre rövidebb rendezetlen sor párcseréit, míg minden elem a helyére kerül. Egy menetben a maradék sor leg-nagyobb eleme, mint egy buborék halad végig az adatsoron. Innen származik a módszer neve.

Az algoritmus:

Eljárás Buborék

r:=n; csere:=hamis

Ciklus amíg r>1 és Nem csere

csere:=igaz

Ciklus i:=1-től r-1-ig

Ha A[i]>A[i+1] akkor //itt a páronkénti összehasonlítás

Csere(A[i], A[i+1])

csere:=hamis

Elágazás vége

i:=i+1

Ciklus vége

r:=r-1

Ciklus vége

Eljárás vége

A buborékrendezési algoritmust a következőképpen javíthatjuk: A módszer azon az észrevételen alapul, hogyegy menetnek az eredményeként a maximális elem a sor végére kerül. Eszerint a menet közbeni adatcseréketmegtakaríthatjuk, ha a maximális elemet és ennek helyét megállapítjuk és csak a menet végén egyetlen cseréveltesszük a helyére. Ezt a módszert maximum-kiválasztásos rendezésnek nevezzük.

Rendezés maximum-kiválasztással

Az algoritmus:

Eljárás MaxKivRend

r:=n

70

Ciklus amíg r>1

i:=1; m:=A[1]; k:=1

Ciklus amíg i<r

Ha A[i]>m akkor

M:=A[i]; k:=i

Elágazás vége

i:=i+1

Ciklus vége

A[k]:=A[r]; A[r]:=m

r:=r-1

Ciklus vége

Eljárás vége

Rendezés minimum-kiválasztással

A módszer lényege:

A felesleges cserék kiküszöbölése érdekében két segédváltozó bevezetésére van szükség. Az ÉRTÉK nevű vál-tozó tartalmazza az adott menetben addig megtalált legkisebb elemet, az index pedig annak vektorbeli sorszá-mát, indexét. Az A vektor elemeit mindig az ÉRTÉK változó tartalmával hasonlítjuk össze. Ha ÉRTÉK-nél ki-sebb elemet találunk, azt betesszük az ÉRTÉK nevű változóba és az index-ben megjegyezzük a szóban forgóelem indexét. A menet végére az ÉRTÉK a vektor soron következő legkisebb elemét tartalmazza, az index pe-dig azt a sorszámot, ahol ezt az elemet találtuk. Csak a menet utolsó lépésében van szükségünk cserére, amikoraz ÉRTÉK-ben lévő legkisebb elemet a helyére tesszük.

Az algoritmus:

Eljárás MinKivRend

Ciklus cikl:=1-től N-ig

index:=cikl; ÉRTÉK:=A[cikl]

71

Ciklus j:= cikl+1-től N-ig

Ha ÉRTÉK>A[j] akkor ÉRTÉK:=A[j]; index:=j

Ciklus vége

A[index]:=A[cikl]; A[cikl]:=ÉRTÉK

Ciklus vége

Eljárás vége

Rekurzió******A rekurzió egy programozási módszer. Azt az esetet nevezzük így, amikor egy eljárásban szerepló kód önmagáthívja meg. Fontos megjegyezni, hogy minden rekurzív algoritmus átalakítható nem rekurzívvá, azaz létezik ite­ratív megoldása is.A rekurzív algoritmusok esetében meg kell találnunk a legegyszerűbb esetet (alapeset), amelyben a megoldásmagától  értetődik, majd találnunk kell egy olyan ismételt  egyszerűsítési folyamatot (indukciós lépés), melyalapján véges lépésben eljuthatunk a legegyszerűbb esethez. Minden egyes lépésnél feltételezzük, hogy a kö­vetkező, egyszerűbb esetnek már megvan a megoldása.

FaktoriálisAz egyik legegyszerűbb példa rekurzióra a faktoriális értékének kiszámítása. Az n faktoriálisa (jelölése: n!)alatt az első n darab pozitív egész szám szorzatát értjük, n = 1 esetén pedig 1­et.Szükségünk van egy alapesetre. Ez most az n = 1 lesz.Az indukciós lépés n > 1 esetén n * (n­1)!. Nem rekurzív algoritmus

fakt(N,R):     R:=1     Ciklus i:=1­től N­ig

R:=R*i     Ciklus vége.Függvény vége.

Az iteratív megoldás:def faktIter(n):       eredmeny = 1       while n > 1:            eredmeny = eredmeny * n            n ­= 1       return eredmeny

Rekurzív algoritmusfakt(N):    Ha N=0 akkor

return(1)  Különben

return(N*fakt(N­1))Elágazás vége.Függvény vége.

A rekurzív megoldás:def faktRekurz(n):       if n == 1:              return 1       return n * faktRekurz(n­1)

Hanoi tornyaiA játék szabályai szerint az első rúdról az utolsóra kell átrakni a korongokat úgy, hogy minden lépésben egykorongot lehet áttenni, nagyobb korong nem tehető kisebb korongra, és ehhez összesen három rúd áll rendelke­zésre. Egy legenda szerint a világ megteremtésekor egy 64 korongból álló Hanoi torony feladványt kezdtek eljátszani Brahma szerzetesei. A szabályok azonosak voltak a ma ismert Hanoi torony szabályaival. A legenda

72

szerint amikor a szerzetesek végeznek majd a korongok átjuttatásával a harmadik rúdra, a kolostor összeomlik,és a világunk megszűnik létezni.A feladványban n korongot szeretnék mozgatni. Bontsuk egyszerűbb formára a problémánkat. Elsőként n – 1korongot átmozgatok a tartalék rúdra, majd a legalsót átmozgatom a célrúdra. Ezután az egészet átrakom a cél­rúdra. Az algoritmus szerint itt megoldunk egy kisebb problémát (n – 1 korong átmozgatása), majd megoldjukaz alapesetet (a legalsó átmozgatása a célrúdra), végül újra egy kisebb problémát oldok meg (áthelyezem a töb­bit a célrúdra). Nézzük meg, hogy néz ki ez Pythonban:Algoritmus

Hanoi(N,honnan,hova,tartalek)Ha N>0 akkor

Hanoi(N­1,honnan,hova,tartalek)Ki: N,honnan,hovaHanoi(N­1,tartalek,hova,honnan)

Elágazás végeEljárás vége.

def tornyok(n, honnan, hova, tartalek):    if n == 1:

         print(str(honnan) + '. rúdról átmozgatjuk    a ', str(hova) + '. rúdra')

         else:         tornyok(n­1, honnan, tartalek, hova)         tornyok(1, honnan, hova, tartalek)         tornyok(n­1, tartalek, hova, honnan)

Az alapesetben (n = 1) egyszerűen kiíratom a lépést, honnan mozgatom hová a korongot.Egyéb esetben egy kisebb rakást (egyet hagyok alul) átrakok a tartalék rúdra. Az ott maradt egy korongot átra­kom a célrúdra. Végül a kisebb rakást átrakom a célrúdra.A legenda szerinti 64 korong esetében a megoldás 18 446 744 073 709 551 615 lépés lenne. Ha egy szerzeteséjjel­nappal dolgozna a feladaton másodpercenként egy lépést végrehajtva, akkor kicsit több mint 580 milliárdév alatt tudná megoldani a feladatot.

Fibonacci számokRekurzív algoritmus

Fib(N):Ha N<=1 akkor       return(1)Különben      return(Fib(N­1)+Fib(N­2))

Objektumorientált programozás

Objektumorientált programozás fogalma

Olyan programozási technika, amely a programokat objektumokból építi fel. A program működése tulajdonkép­pen objektumok ( minden objektumnak megvan a jól meghatározott feladata ) kommunikációját jelenti. Legfon­tosabb alapelvei: egységbezárás, öröklődés, polimorfizmus. A strukturált programozást felváltja az objektum orientált programozás.(Programozási paradigmaProgramozási mód. Alapvetően a program felépítésére használt eszközkészletet jelenti, vagyis milyen egységekképezik a program alkotóelemeit. (moduláris programozás, objektumorientált programozás, általánosított prog­ramozás, aspektusorientált programozás stb.)Objektum­orientált programozásOlyan programozási paradigma, amely a programokat objektumokból építi fel. A program működése tulajdon­képpen objektumok kommunikációját  jelenti. Legfontosabb alapelvei:  egységbezárás,  öröklődés,  polimorfiz­mus.)

Objektumorientált nyelvek osztályozása • tiszta objektumorientált nyelvek ,• hibrid nyelvek ,

73

• objektum alapú nyelvek .

Objektumorientált program jellemzői, alapfogalmak

Osztály (Class)Az osztály egy felhasználói típus, amelynek alapján példányok (objektumok) hozhatók létre. Az osztály alapvetően adat és metódus (művelet) definíciókat tartalmaz.Példák:Egy osztályba sok diák jár, a programablakban több parancsgombot helyezhetünk el.Programjainkban gyakran sok objektum tárol ugyanolyan adatokat, és végez ugyanolyan tevékenységeket.Az egymáshoz hasonló objektumokat osztályokba soroljuk.A diák objektumosztály egy példánya (objektuma) Kovács István vagy Nagy Anna. A programablakban a parancsgomb (Button) objektumosztály példányait helyezzük el (Button1, Button2 stb.).

Objektum (példány)Információt (adatokat) tárol és kérésre műveleteket végez. Van állapota, viselkedése és futásidőben azonosítható.Példák:Az iskolában diákok tanulnak. Egy diák adataihoz tartozik a neve, születési ideje, lakcíme, stb.. A diák a tanórán felel, hiányzást igazol, tornázik. A diák objektum­modelljének ezeket az adatokat kell tartalmaznia, ezeket a tevékenységeket végezik.A grafikus felhasználói felület programozásakor is objektummal dolgozunk. Megadjuk például egy parancsgomb helyzetét, méretét, feliratát, elkészítjük eseménykezelő eljárásait.

FelelősségMinden objektumnak megvan a jól meghatározott feladata, amelynek elvégzéséért felelős.

OsztályozásAz objektum osztályokat viselkedésük szerint osztályokba soroljuk. 

Objektum osztály (típus)egy objektum minta, mely alapján objektum példányokat (objektumokat) hozhatunk létre.

AdatmezőAz osztály minden objektum példányában megtalálható, kezelése és deklarálása a rekordmezőével megegyező.

MetódusAz objektumon végzendő műveleteket definiáló eljárások és függvények. Azonos osztályhoz tartozó objektumpéldányok a metódusokat közösen használják. A Self paraméter jelöli, hogy éppen melyik példány adatmezőin kell műveletet végezni.

Üzenet (Message, kérelem)Ezen keresztül kérjük meg az objektumokat különböző feladatok elvégzésére. Objektumhoz továbbított kérés.Válaszként az objektum végrehajtja a kért műveletet.

Egységbezárás (Encapsulation)Az adatok és a metódusok osztályba való összezárását jelenti. Tulajdonképpen az objektum egységbe zárja azállapotot (adattagok értékei) a viselkedésmóddal (műveletekkel). Következmény: az objektum állapotát csak aműveletein keresztül módosíthatjuk.

74

Információ elrejtése (Information Hiding)Az objektum elrejti az adatait és bizonyos műveleteit. Ez azt jelenti, hogy nem tudjuk pontosan, hogy egy ob­jektumban hogyan vannak az adatok ábrázolva, sőt a műveletek implementációit sem ismerjük. Az információkelrejtése az objektum biztonságát szolgálja, amelyeket csak a ellenőrzött műveleteken keresztül érhetünk el.

Öröklődés (Inheritance)(Származtatás, örökítés)Olyan osztályok között értelmezett viszony, amely segítségével egy általánosabb típusból (ősosztály) egy sajá­tosabb típust tudunk létrehozni (utódosztály). Az utódosztály adatokat és műveleteket (viselkedésmódot) örö­köl, kiegészíti ezeket saját adatokkal és műveletekkel, illetve felülírhat bizonyos műveleteket. A kód újrafel­használásának egyik módja. Megkülönböztetünk egyszeres és többszörös örökítést.

Helyettesíthetőség (Substitutability)Ha S altípusa a T típusnak (S osztályt a T osztályból származtatjuk), akkor a T osztálybeli példányokat helyette­síthetjük S osztálybeli példányokkal, anélkül, hogy programunk helyességét veszélyeztetnénk.

Dinamikus (késői) kötésFutásidejű  hozzárendelése a  hívott  metódusnak az objektumhoz.   (Pl.  C++: virtuális   függvények,  Java:  pél­dánymetódusok) (Lassú)

Statikus (korai) kötésFordításidejű hozzárendelése a hívott metódusnak az objektumhoz. (Pl. C++: nem virtuális függvények, Java:osztálymetódusok­ statikus metódusok) (Gyors)

Metódusok túlterhelésTöbb azonos nevű, különböző szignatúrájú függvény. A függvényhívás aktuális paraméterei meghatározzák,hogy melyik függvény fog meghívódni. Ezt már a fordításidőben eldől (statikus, fordításidejű kötés)

Metódusok felülírásaEgy osztályhierarchián belül az utódosztály újradefiniálja az ősosztály metódusát. (azonos név, azonos szig­natúra). Ha ősosztály típusú mutatón vagy referencián keresztül érjük el az osztályhierarchia példányait és ezenkeresztül meghívjuk a felülírt metódust, akkor futási időben dől el, hogy pontosan melyik metódus kerül meghívásra. (dinamikus, futásidejű kötés).

Absztrakt osztályOlyan osztály, amelynek van legalább egy absztrakt művelete. Felületet határoz meg és nem lehet példányosíta­ni. Absztrakt osztály az absztrakt műveleteinek implementálását az utódosztályokra bízza.

Konkrét osztályOlyan osztály, amely nem tartalmaz absztrakt műveletet. Példányosítható.

Interfész (Interface)Viselkedésmódot definiál. Gyakorlatilag egy művelethalmaz deklarációját jelenti. Ha egy osztály implementálegy adott   interfészt,  akkor példányai  az interfészben meghatározott  viselkedéssel  fognak rendelkezni.  Csakkonstans adattagokat tartalmazhat és minden tagja nyilvános. 

Objektum interfész (Object Interface)Meghatározza az objektummal végezhető műveletek halmazát

Polimorfizmus (többalakúság)

75

Ugyanarra   az   üzenetre   különböző   objektumok   különbözőképpen   reagálhatnak.   Egy   típuselméleti   fogalom,amely szerint egy ősosztály típusú változó hivatkozhat ugyanazon közös ősosztályból származó (vagy ugyan­azon interfészt megvalósító) osztályok példányaira. A polimorfizmus lehet statikus és dinamikus. 

• Statikus polimorfizmus: metódusok túlterhelése, függvénysablonok, osztálysablonok. Satikus, fordítás­idejű kötés. 

• Dinamikus polimorfizmus: metódusok felülírása. Dinamikus, futásidejű kötés. 

Konstruktor (Constructor)Az a művelet, amely inicializálja az objektumot. Automatikusan hívódik. Egy osztályhoz annyiféle konstruktortkészítünk, ahányféleképpen lehetővé tesszük a példányok inicializálását. 

Destruktor (Destructor)A konstruktorral ellentétes művelet, általában a konstruktorban lekötött erőforrásokat szabadítja fel. Az objek­tum megsemmisítése előtt hajtódik végre és automatikusan hívódik. 

Függőség (Coupling)Komponensek közötti függőség mértéke. Megkülönböztetünk laza és szoros csatolású rendszereket. A laza csa­tolású rendszerek esetében, a rendszer valamely komponensének változása nem vonja maga után a többi kom­ponens módosítását. 

Osztályszintű (statikus) tagok (Class (Static) Members)Statikus tagok= statikus adattagok + statikus metódustagok A statikus adattagok, olyan adatok, amelyeket azadott osztály példányai közösen használnak (osztott). A statikus műveletek olyan műveletek, amelyek az argu­mentumaikon illetve az osztály statikus adattagjain dolgoznak. Ezek a tagok már példányok létrehozása előtt használhatók. 

Aggregáció (Aggregation)Rész­egész kapcsolat. A részek alkotják az egészet. Például az autó motor, váz és kerekek aggregációja. A ré­szek túlélhetik az egészet. 

Kompozíció (Composition)Sajátos aggregáció, amikor a rész szorosan hozzátartozik az egészhez. A részek nem élik túl az egészet. Példáulaz emberi agy szorosan hozzátartozik az emberhez. 

Delegálás (Delegation)Implementációs mechanizmus, melynek során egy objektum továbbítja (delegálja) a kérést egy másik objektumfele. A delegált objektum fogja feldolgozni a kérést. Példa: Java eseménykezelés (az eseményfigyelő fele továbbítódik a kérés) 

Tároló (Konténer, Container)Olyan típus, amely objektumok tárolását biztosítja. A tárolási funkció mellett karbantartó műveleteket is bizto­sít. 

Bejáró (Iterátor, Iterator)Olyan típus, amely pozíciót határoz meg egy halmazban (tároló, adatfolyam). Műveletein keresztül biztosítja atároló bejárását, azaz a tárolt elemek egymás utáni feldolgozását.

Statikus metódusokAz ilyen metódusok az örökléskor, csupán kicserélik az előd metódusát az újra, nincs hatással az objektum másrészeire ­ így nem változik meg teljesen annak tulajdonsága. Gondoljunk itt az objektum más részében elhe­lyezkedő esetleg őt meghívó más metódusokra, akik nem az újat, hanem a régit fogják meghívni, a statikus

76

megoldás következménye képen.

Virtuális metódusokIlyen típusú metódusokkal lehet megoldani az öröklés folyamaton keresztül a sokoldalúságot. Ez azt jelenti,hogy nem csak a régi metódust cseréli ki az újra, hanem az egész objektumot „átnézve” a régi metódusra muta­tó összes hivatkozást átírja az új metódusra mutatóvá. Ezáltal megváltozik az egész objektum tulajdonsága, ésaz öröklés folyamatra nézve sokoldalúvá válik.Ha egy objektumban már használtuk a virtual kulcsszót, akkor annak utódaiban is kötelező.

Futóverseny példaA futóverseny objektumai, a mezők és metódusok megadásával: Pályaobjektum: a versenypályát jelképezi. 

Hossz mező: a pálya hossza. A versenyzők használják fel a cél elérésének ellenőrzéséhez. Létrehoz metódus: a versenyzők számának megfelelően méretezi az ablakot, és kirajzolja a képernyőre acélvonalat. Az ablak szélessége alapján meghatározza a Hossz értékét. A versenyzők számát argumen­tumként adjuk meg. 

Versenyzőobjektum: egy versenyző adatait és metódusait tartalmazza. Mezők: Mez: a versenyző mezének sorszáma. Szín: a versenyző mezének színe. Helyzet: a versenyző pozíciója a pályán. Színek(): a lehetséges színeket tartalmazó tömb. Vélszám: véletlenszám­objektum a szín választásához, illetve a helyzet változtatásához. Metódusok: 

Létrehoz: inicializálja a mezőket. A metódus argumentuma a versenyző mezének sorszáma. Aszínt véletlenszerűen választja ki. Fut:   lépteti  a  versenyzőt   a  verseny során.  Véletlenszerűen  választott  mértékben megnöveli  aHelyzet mező értékét. Ha a versenyző beér a célba, akkor hozzáadja a mez sorszámát a verseny­objektum győzteseket tartalmazó halmazához. 

Kiír: megjeleníti a képernyőn a versenyző helyzetét. A Fut metódus hívja. Versenyobjektum: elindítja és vezérli a versenyt. 

Mezők: Pálya: pályaobjektum. Győztesek: a győztesek mezének sorszámát tartalmazó halmaz. VersenyzőkSzáma: a versenyzők száma.Versenyzők(): a versenyzőobjektumokat tartalmazó tömb. Metódusok: 

Start: megkérdezi a felhasználótól  a versenyzők számát,  majd létrehozza a versenyzőobjektu­mokat, és meghívja Létrehoz metódusukat. Létrehozza a pályaobjektumot, amelynek meghívja aLétrehoz metódusát. A Futás metódus hívásával elindítja a versenyt, a végén pedig az Eredménymetódussal kiíratja az eredményt. Futás: magát a versenyt jelképezi. Ciklussal lépteti a versenyzőket mindaddig, amíg valamelyi­kük be nem ér a célba (egy cikluson belül esetleg egyszerre több is). Eredmény: a verseny végén kilistázza a győztes versenyzőket. Ehhez a Győztesek halmazt hasz­nálja fel, melybe a célba érő versenyzők beírták mezük sorszámát. Vár: a megadott időtartamra leállítja a végrehajtást, egyébként a versenyt nem tudnánk követni aképernyőn. A Futás metódus hívja.

77

Objektum­orientált tervezés

1. Analízis (OOA), 2. Tervezés (OOT)3. Programozás (OOP)Eymással kapcsolatban állnak, de különböző fogalmakAz OOA a felhasználói környezet modelljének kidolgozásával foglalkozik.Az OOT a követelményeket kielégítő rendszer modelljének kidolgozásával foglalkozik.Az OOP az OOT realizálásával foglalkozik egy OO nyelv (pl. Java, C++) segítségével. 

Ábrázolás osztálydiagramon

Programunkban osztályokat definiálunk a tervben szereplő objektumok alapján. Az osztályok szerkezetét úgy­nevezett osztálydiagrammal tesszük áttekinthetővé. Az osztálydiagram fontos eleme az objektumorientált prog­ramok tervezését segítő UML­nek (Unified Modeling Language: egységes modellező nyelv). Az osztálydiagram téglalapban tünteti fel az osztály nevét, mezőit és metódusait. A mezőket és metódusokatvízszintes vonallal választjuk el egymástól.

A futóverseny leírása alapján jelöljük be az alábbi osztálydiagramra, hogy egy­egy osztály objektumai melymásik osztály mezőit kérdezik le vagy módosítják, illetve mely metódusokat hívják! Melyik osztály objektumahoz létre egy másik osztályhoz tartozó objektumot vagy objektumokat? 

Az osztálydiagramon csak az általunk definiált osztályokat tüntettük fel. Nem ábrázoltuk külön a fejlesztő rend­szerben rendelkezésünkre álló osztályokat (véletlenszám, halmaz, tömb). Az osztálydiagramok mellett gyakran használják az objektumdiagramot is. Az objektumdiagram az objektumo­kat téglalapokban ábrázolja, feltüntetve az objektum nevét, osztályát, továbbá mezőinek értékét. Az objektumnevét, osztályát aláhúzzuk, és kettősponttal választjuk el egymástól. Ha nem lényeges az objektum neve, akkorel is hagyhatjuk.

Objektumosztály definiálása, objektumok létrehozása 

Objektumosztályt az OSZTÁLY ... OSZTÁLY VÉGE kulcsszavak között definiálunk a forráskódban. A definí­cióban a mezők (változók) deklarációi és metódusok (alprogramok) definíciói szerepelnek a szokásos módon: 

A TPálya osztály definíciója például (vázlatosan): 

78

OSZTÁLY Osztálynévváltozók (mezők) deklarálásaeljárások, függvények (metódusok) definiálása

OSZTÁLY VÉGE

Linux alapok

Parancs általános alakjaparancs kapcsolók paraméterek

Könyvtárszerkezetabszolút útvonal: útvonal megadása a gyökérből kiindulva

/ gyökérkönyvtárrelatív útvonal: útvonal megadása az aktuális könyvtárból kiindulva

. aktuális könyvtár

.. egy szinttel feljebb lévő könyvtár

pwdkiírja az aktuális könyvtár abszolút elérési útját

cd <könyvtár><könyvtár> lesz az aktuális könyvtár, paraméter nélkül a home könyvtárba ugrik

ls <kapcsolók> <lista>Kilistázza a listában megadott fájlokat és könyvtárakat (ha nincs lista, akkor olyan mintha . lett volna megadva)Kapcsolók

­l részletes lista­a rejtett fájlokat is kiírja­d a könyvtárakat ugyanúgy mint a fájlokat (nem a tartalmukat listázza ki)­R a könyvtárakat rekurzívan­r csökkenő betűrendben listáz

mkdir <kapcsolók> <lista>Létrehozza a listában található könyvtárakatKapcsolók

­p a teljes megadott útvonalat létrehozza­m a könyvtár jogosultságainak megadása (oktális alak)

(használat: ­m <jog>)

rmdir <kapcsolók> <lista>Törli a listában megadott könyvtárakatKapcsolók

­p a teljes megadott útvonalat törli

mv <kapcsolók> <eredeti> <új>

79

OSZTÁLY TPálya VÁLTOZÓ Hossz MINT Egész ELJÁRÁS Létrehoz(VersenyzőkSzáma MINT Egész)

az ablak méretének módosítása a célvonal kirajzolása

ELJÁRÁS VÉGE OSZTÁLY VÉGE

Átnevezi az <eredeti> nevű fájlt vagy könyvtárat <új> névre (ha nem létezik ilyen könyvtár)Kapcsolók

­b ha az új létezik, készít róla egy biztonsági mentést (<új>~néven)

mv <kapcsolók> <lista> <újhely>Átmozgatja <lista> elemeit az <újhely> könyvtárba (aminek léteznie kell)Kapcsolók

­f kétes esetben nem kérdez­i bármely kétes esetben megerősítést vár­u csak a régebbi fájlokat írja felül

cp <kapcsolók> <eredeti> <új>Létrehoz egy <eredeti> nevű fájlból vagy könyvtárból egy másolatot <új> néven (ha nem létezik ilyen nevű könyvtár)Kapcsolók

­b ha az új létezik, készít róla egy biztonsági mentést (<új>~néven)

cp <kapcsolók> <lista> <újhely>Átmozgatja a <lista> elemeit az <újhely> könyvtárba (aminek léteznie kell)Kapcsolók

­f kétes esetben nem kérdez­i bármely kétes esetben megerősítést vár­r ­R könyvtárakat rekurzívan átmásolja­l másolás helyett linket készít­s másolás helyett szimbolikus linket­u csak akkor másol, ha a cél helyen régebbi fájlok vannak vagy az adott fájl 

hiányzik

rm <kapcsolók> <lista>Törli a listában megadott fájlokatKapcsolók

­f kétes esetben sem kérdez vissza­i bármely kétes esetben megerősítést vár­r ­R ha könyvtárnevet talál a listában, törli azt

du <kapcsolók> <lista>Összeszámolja a könyvtárban található fájlok méretétKapcsolók

­a a kimeneti listába a fájlok is bekerülnek­s a méreteket összeadja­m kilobyte­ok helyett megabyte­okban számol­h az ember számára olvasható mértékegységek

quotaA felhasználó által használható lemezterület méretét írja ki.

dfA fájlrendszerek lemezhasználatáról készít jelentést.Kapcsolók

­h az ember számára olvasható mértékegységek

80

Szövegfájlokcat <fájl>

A <fájl> teljes tartalmát egyszerre kiírja a képernyőre 

more <fájl>A <fájl> teljes tartalmát oldalanként kiírja a képernyőre 

head ­<n> <fájl>A <fájl> első <n> sorát kiírja a képernyőre 

tail ­<n> <fájl>A<fájl>utolsó <n> sorát kiírja a képernyőre

grep <minta> <fájl>Kiírja a <fájl> azon sorait, amelyekben megtalálható a <minta> szövegrészlet

more <fájl>A fájl teljes tartalmát oldalanként írja ki a képernyőre

teeA bemenetként kapott szöveget a kimenetre írja.

less <fájl>A fájl tartalmát görgethetően írja ki

wc <kapcsolók> <fájl>Kiírja a <fájl>­ban található byte­ok/sorok/szavak számátKapcsolók

­c a fájl méretét írja ki­w a szavak számát írja ki­l a sorok számát írja ki­m a karakterek számát írja ki

sort <kapcsolók> <fájl>A fájl sorait ábécé sorrendben írja ki.Kapcsolók

­r csökken sorrend (z­a)

Egyébman <parancs>

Előhozza a parancs részletes leírását

file <fájl>Megadja a fálj típusát.

echo <szöveg>Kiírja a szöveget.

passwdA jelszó megváltoztatására szolgál.

Jogosultságok

81

Hozzáférések korlátozása.Tulajdonos (User), Csoport (Group), Többiek (Others)Olvasás (Read), Írás (Write), Végrehajtás (eXecution)

chmod <kapcsolók> <jogosultság> <lista>Jogosultság<kinek><hogyan><mit>

<kinek> a (all), u (user), g (group), o (others)<hogyan> + (megadás), ­ (megvonás), = (beállítás)<mit> r (read), w (write), x, (execute)

<user><group><other>oktális számjegyekread: 4, write: 2, execute: 1ezek összege a kód

Kapcsolók­c a változtatásokat jelenti­R ha könyvtárat talál, rekurzívan beállítja a jogokat a könyvtárban

található fájlokra és könyvtárakra is

Mintaillesztés? egyetlen karaktert helyettesít* akárhány karaktert helyettesít[…] a [ és ] között felsorolt karaktereket helyettesítheti\c a c speciális karaktert jelent

\, szóköz, ', ”, ?, *, [, ], `

Felhasználókfinger

Megadja, hogy ezen a gépen kik vannak bejelentkezve.

finger <név>Felsorolja azokat a felhasználókat akiknek a neve vagy azonosítója megegyezik a <név> paraméterrel.

finger @hostMegadja, hogy a host gépen kik vannak bejelentkezve.

whoMegadja, hogy ki van bejelentkezve a gépre. Fingernél kevesebb adatot szolgáltat.

wMint, a who, de megmondja azt is, hogy ki min dolgozik.

lastMegmondja az utolsó néhány bejelentkezett felhasználót.

exitKapcsolat megszakítása.

82

Python

Első lépésekAz interpretert közvetlenül  a parancssorból indíthatjuk (egy Linux shell­ben, vagy Windows alatt egy DOSablakból): elég, ha begépeljük a "python" parancsot (feltéve, hogy a program fel van telepítve)). Ha grafikus interface­t használunk, mint a Windows, Gnome, WindowMaker vagy KDE, valószínűleg inkább egy « terminálablakban » fogunk dolgozni, vagy egy specializált fejlesztő környezetben, mint amilyen az IDLE.Terminálablakban a következő jelenik meg:

A >>> jel a fő prompt, ami azt jelzi, hogy az interpreter készen áll egy utasítás végrehajtására.

Számolás PythonbanAz interpretert azonnal egyszerű számológépként használhatjuk. A   +, ­, * és / aritmetikai operátorok össze­adásra, kivonásra, szorzásra és osztásra valók. A zárójelek működnek. 

Adatok és változók Egy számítógépprogram lényegét az adatmanipulációk képezik. Ezek az adatok nagyon különbözőek lehetneklényegében minden, ami digitalizálható), de a számítógép memóriájában végleg bináris számok véges sorozatá­vá egyszerűsödnek. Ahhoz, hogy a program hozzá tudjon férni az adatokhoz, nagyszámú különböző típusú változót használ. Egyprogramozási nyelvben egy változó majdnem mindegy milyen változónévként jelenik meg, a számítógép szá­mára egy memóriacímet jelölő hivatkozásról van szó, vagyis egy meghatározott helyről a RAM­ban. Ezen a helyen egy jól meghatározott érték van tárolva. Ez az igazi adat, ami bináris számok sorozata formájá­ban van tárolva, de ami az alkalmazott programozási nyelv szemében nem feltétlenül egy szám. Szinte bármi­lyen « objektum » lehet, ami elhelyezhető a számítógép memóriájában, pl. egy egész, egy valós, egy komplexszám, egy vektor, egy karakterlánc, egy táblázat, egy függvény, stb. A programozási nyelv különböző változótípusokat (egész, valós, karakterlánc, lista, stb.) használ a különböző lehetséges   tartalmak   egymástól   történő   megkülönböztetésére.

Változónevek és foglalt szavak A változóneveket mi választjuk meg, fontos, hogy jól válasszuk meg azokat. Rövid, kifejezik, hogy mit tartal­maz a változó. Egy jó programozónak ügyelni kell arra, hogy az utasítássorait könnyű legyen olvasni. Pythonban a változóneveknek néhány egyszerű szabály van: 

• A változónév az a­z, A­Z betűk és a 0­9 számok sorozata, aminek mindig betűvel kell kezdődni. • Csak az ékezet nélküli betűk a megengedettek. A szóközök, a speciális karakterek, mint pl.: $, #, @, stb.

nem használhatók, kivétel a _ (aláhúzás). • A kis­ és nagybetűk különbözőnek számítanak. 

További szabály: nem használható változónévként az alább felsorolt 28 «foglalt szó » (ezeket a Python hasz­

83

Python 3.4.0 (default, Apr 11 2014, 13:05:18) [GCC 4.8.2] on linuxType "copyright", "credits" or "license()" for more information.>>>

>>> 2+35>>> 10-46>>> 3*39>>> 21/210.5>>> (5+4)*2/36.0

nálja): 

 Értékadás, hozzárendelésEgy változót úgy definiálhatunk, hogy értéket rendelünk hozzá. A változóhoz való „érték hozzárendelés” vagy„értékadás” kifejezések egyenértékűek. Egy olyan műveletet jelölnek, amely kapcsolatot teremt a változónév ésa változó értéke (tartalma) között. A Pythonban számos más nyelvhez hasonlóan a hozzárendelés műveletét azegyenlőségjel reprezentálja.

Többszörös értékadás is létezik a Pythonban, több változónak ugyanazt az értéket adhatjuk vagy több változó­nak egyszerre adhatunk különböző értéket:

 Változó értékének a kiírása Két lehetőségünk van az értékük képernyőre történő kiíratására.A billentyűzeten beírjuk a változó nevét, majd Entert nyomunk, kiíródik a változó értéke (promt nélkül)

A másik lehetősé a print(változónév) parancs kiadása.

84

>>> a=12>>> a12>>> koszones="Szia!">>> koszones'Szia!'>>> pi=3.14>>> pi3.14

>>> szam1=szam2=2>>> szam12>>> szam22>>> szam1,szam2,szo=23,-45.4,"alma">>> szam123>>> szam2-45.4>>> szo'alma'

>>> a34>>> koszones'Szia!'>>> pi3.14

>>> print(a)34>>> print(koszones)Szia!

A kétféle kiíratási mód közötti különbség: a print utasítás csak a változó értékét írja ki, úgy ahogyan az kódolvavolt, míg a másik módszer az idézőjeleket is.

Változók típusadásaNem szükséges a változók használata előtt a típusuk definiálása, elég ha hozzárendelünk egy értéket egy válto­zónévhez. A Python a változót automatikusan azzal a típussal hozza létre, ami a legjobban megfelel az érték­nek.A Python   dinamikus   típusadású   nyelv, szemben a statikus   típusadású   nyelvekkel, ezekben a nyelvekbenelőször mindig speciális utasításokkal deklarálni(definiálni) kell a változók nevét és típusát és csak ezután lehettartalmat rendelni hozzájuk, aminek természetesen kompatibilisnek kell lenni a deklarált típussal.A type() függvénnyel a változók típusait íratjuk.

Típusok:int : egészfloat : valósstr : szöveg

Operátorok és kifejezések Az értékeket és a rájuk hivatkozó változókat operátorok segítségével kifejezésekké kombináljuk.Példa:a, b = 2.5, 12 c = 4*a + b/2 Operátorok: * , + és /Operandusok: 3, 5Változók: a,b,cAz  operátorok  speciális szimbólumok, amiket olyan egyszerű matematikai műveletek reprezentálására hasz­nálunk, mint az összeadás vagy a szorzás. Az operandusok az értékek, amiket az operátorok segítségével kom­binálunk. Hatványozás operátora **, modulo operátor: %, (egy számnak egy másik számmal való egészosztásából szár­mazó maradékát adja meg)Relációs operátorok :

x ==y egyenlő y­nalx!=y nem egyenlő y ­nal x >y nagyobb, mint y x <y kisebb, mint y x >=y nagyobb, vagy egyenlő mint y x<=y  kisebb, vagy egyenlő mint y

A műveletek prioritása Ha egy kifejezésben egynél több operátor van, akkor a műveletek végrehajtásának sorrendje a prioritási szabá­lyoktól függ. A Pythonban a prioritási szabályok ugyanazok, mint amiket matematikából tanultunk: 

• Zárójelek. Ezek a legmagasabb prioritásúak. Azt teszik lehetővé, hogy az általunk kívánt sorrendbentörténjen egy kifejezés kiértékelése. Így   2*(3­1) = 4  ,  és   (1+1)**(5­2) = 8 . 

• Hatványozás. A hatványok kiszámolására a többi művelet előtt kerül sor. Így 2**1+1 = 3 (és nem 4),  és

85

>>> szam1=12>>> szam2=3.23>>> szo="körte">>> szam1,type(szam1)(12, <class 'int'>)>>> szam2,type(szam2)(3.23, <class 'float'>)>>> szo,type(szo)('körte', <class 'str'>)

3*1**10 = 3 (és nem 59049 !).• Szorzás és osztás, azonos prioritással. Ezeket az összeadás és kivonás előtt értékeli ki. • Így  2*3­1 = 5   (és nem 4),   és     2/3­1 = ­1   (Emlékezzünk vissza, hogy alapértelmezésben a Python

egészosztást végez.) • Ha két operátor azonos prioritású, akkor a végrehajtásuk balról jobbra történik. 

Így az   59*100/60  kifejezésben először a szorzást, majd ezt követően , az   5900/60  osztást végzi el,aminek az eredménye  98 . Ha először az osztást végezné el, akkor az eredmény  59  lenne (emlékezünkrá, hogy itt egy egészosztásról lenne szó).

GUI tananyag***************

Programok feladatok**************

Specifikáció készítés

A feladatspecifikáció történhet szövegesen, illetve matematikai és logikai szimbólumok alkalmazásával. Mindkét esetben maximális pontosságra és egyértelműségre kell törekednünk.Feladat:

Írjunk programot, amely egy háromszög oldalainak ismeretében meghatározza annak területét!A feladat specifikációja:

Bemenő adatok:     a,b,c : valós számok a háromszög oldalaiKimenő adatok:     T : valós szám a háromszög területeElőfeltételek:   a>0 b>0 c>0 (minden oldal mérőszáma pozitív) a+b>c a+c>b b+c>a (az oldalakra teljesül a háromszög­egyenlőtlenség)Utófeltétel:  s=(a+b+c)/2 c)b)(sa)(ss(sT   Héron­féle területképlet

A specifikáció során használható szimbólumok

A feladatok specifikálásakor gyakran alkalmazunk logikai műveleteket, valamint a matematikai logika egyéb szimbólumait. A legtöbbször használt jelek a következők:

ÉS logikai művelet VAGY logikai művelet KKOR logikai művelet (implikáció) AKKOR és CSAK AKKOR logikai művelet (ekvivalencia) „minden” logikai kvantor „létezik” logikai kvantor

Példaként tekintsünk egy rövid részletet egy feladatspecifikációból, amely az előbbi szimbólumokat használja:Jelekkel:  i (1<= i <=N) : (A[i]>0 B[i]<0) C[i]<0 Szöveggel:  minden 1 és N közé eső i értékre, amennyiben az A tömb i. eleme pozitív, a B tömb i. eleme pedig negatív, akkor a C tömb i. eleme negatív.Megfigyelhető, hogy a jelekkel felírt specifikáció sokkal tömörebb. 

PéldaKészíts programot, ami kiszámolja egy szám négyzetgyökét.A feladat specifikációja:

86

Bemenő adatok:     x : valós számokKimenő adatok:     y : valós számElőfeltétel    x >= 0 Utófeltétel    y >= 0 és y2 = x 

PéldaKészíts programot, ami tetszőleges egész számra megadja az annál kisebb négyzetszámokat.A feladat specifikációja:Bemenő adatok:     K : egész számKimenő adatok:      (X1 ... XN) : egész számElőfeltétel:      K>0 Utófeltétel     (X1 ... XN) egész sorozat a következő tulajdonságokkal:        X1 = 1        Xi < X(i+1), azaz a sorozat szigorúan monoton növő        Xi = a2 valamilyen a egész számra, azaz a sorozat minden tagja négyzetszám        Az (Xi ;X(i+1)) intervallumokban nincs négyzetszám        Az (XN, K) intervallumban nincs négyzetszám 

Készítsd el a következő feladatok specifikációját:1. Készíts programot, ami kiszámolja egy téglalap kerületét és területét.2. Készíts programot, ami összead két számot!3. Készíts programot, ami kiszámol egy tetszőleges pozitív kitevős hatványt.4. Készíts programot, ami három szám közül megadja a legnagyobbat.5. Készíts programot, ami kiszámítja egy másodfokú egyenlet megoldásait.6. Készíts programot, ami eldönti egy egész számról, hogy prímszám­e.7. Készíts programot, ami kiszámítja két egész szám legnagyobb közös osztóját.8. Készíts programot, ami felsorolja az első N négyzetszámot (N megadható).9. Készíts programot, ami kiszámolja egy számsor átlagát.10. Készíts programot, ami egy kezdőelemmel és különbséggel adott számtani sorozatnak kiírja az első 

tagjait (az is megadható, hogy mennyit).11. Készíts programot, ami megadja egy szövegfájl leghosszabb sorát.12. Készíts programot, ami felsorolja egy egész szám valódi osztóit..

Algoritmus készítés

Hétköznapi feladatok algoritmussal1. Készítse el egy pénzérmés telefonkészülékkel való telefonálás algoritmusát mondatszerűen.2. Készítse el egy üdítőautomata használatának algoritmusát folyamatábrával.3. Készítse el a teafőzés algoritmusát folyamatábrával.4. Készítse el a defektes kerékpárgumi javításának algoritmusát. Az eredményt mentse a következő fájlba:

Matematikai feladatok algoritmizálása5. Kérjen be két számot, szorozza össze a számokat, írja az eredményt a képernyőre.

87

6. Kérjen be két számot, a nagyobbat ossza el a kisebbel, az eredményt írja a képernyőre.7. Kérjen be két számot, majd írassa a nagyobbat a képernyőre.8. Kérjen be két számot, a nagyobbat ossza el kettővel, a kisebbet hárommal. Az eredményt írja a 

képernyőre.9. Kérjen be számokat 0 végjelig. Számolja meg az 5­nél nagyobb számokat. Írassa a képernyőre hány 5­

nél nagyobb számot írt be a felhasználó.10. Kérjen be folyamatosan hőmérséklet adatokat. Ha a beírt hőmérséklet fagypont alá esik, akkor ne kérjen

többet.11. Kérjen be folyamatosan hőmérséklet adatokat. Ha a beírt hőmérséklet ­5 fok alá esik, akkor ne kérjen 

többet. Írassa ki, hány hőmérsékletadatot adott meg felhasználó.12. Kérjen be 0 végjelig számokat. Írassa ki hány darab számot írt be a felhasználó.13. Kérjen be 0 végjelig számokat. A bekért számokat adja össze. Az eredmény írja a képernyőre.14. Kérjen be 0 végjelig számokat. A bekért számokat szorozza össze. Az eredményt írja a képernyőre.

Mond az eredményt15. Adott a következő algoritmus:

Starta = 3b = 5c = 1d = 0Ha b < 5 akkor

  d = 8  c = 5 + a

ellenbend = 15

Ha végeHa c < d akkor

  d = 40Ha vége

VégeA program végén mi a d értéke?

Starta = 45z = 37d = a ­ zg = 3r = 2v = v / 2Ha v > r akkor

a = 23ellenben

z = 23Ha végeHa z == r akkor

a = 4Ha vége

StopA végrehajtás után mi lesz „a” és „z” értéke?

88

Starta = 45b = 37c = a ­ bd = 3f = 2g = b * aa = gHa a > f akkor

b = 23ellenben

c = 23Ha végeHa b == c akkor

b = 4ellenben

d = 4Ha vége

StopAz algoritmus végrehajtása után mi lesz a, b, c és d értéke?

Mit csinál a következő algoritmus? Algoritmus 

Be: a Ha a<0 akkor a:=­a Ki: a 

 Algoritmus vége 

Mit csinál a következő függvény?Függvény csinál(a)

ciklus i = 1 .. aprint i

ciklus végeFüggvény vége

89

Folyamatábra eredménye? A program végén mi lesz „a” és „b” értéke?

Algoritmus készítésA kúp felszínét a következő képlet segítségével számíthatjuk ki:

A = (pi r^2) + (pi r sqrt{r^2 + h^2})A  felszínr  sugárh  magasság

Írjon algoritmust, amelyben két kúp adatait kéri be, majd mindkettőnek kiszámítja a felszínét. Az első kúpnál írja ki szimplán az eredményt, a második esetben a dupláját írja a képernyőre.

Az algoritmust készítse el folyamatábrával.Feladat 402

A kúp térfogatszámításának képlete az alábbi:

V = 1/3 T hT  alapterületh  magasságr  sugár

A kúp térfogata területszámítással:

V = 1/3 r^2 pi h

Kérjük két kúp magasságát és sugarát, számítsuk ki a térfogatát, majd írjuk a képernyőre a nagyobbat.

Készítsük el az algoritmust folyamatábrával.

90

Egyszerű konzol feladatok

Programok

Beolvasás, kiíratás

Típuskonverzió

Egyszerű műveletek

Elágazások

Ciklusok

Vegyes feladatok

Menü a programban

Eljárást tartalmazó

Függvényt tartalmazó

Összetett adattípusok

Tömb

Mátrix

Rekord

Tételek

Keresési tételek

Rendezési tételek

Műveletek fájlokkal

Egy fájlt használat előtt meg kell találni, meg kell nyitni, amikor befejeztük a használatát, be kell zárni. Amígnyitva van különböző információkat lehet belőle olvasni és lehet bele írni, de általában a kettőt nem tesszükegyszerre.A neve segítségével férünk hozzá (ami tartalmazhat egy könyvtárnevet is). A fájl tartalmát mindig tekinthetjükegy karaktersorozatnak, ami azt jelenti, hogy ezt a tartalmat, vagy annak bármely részét a karakterláncok keze­lésére szolgáló függvények segítségével kezelhetjük.A Python a fájlokat az aktuális könyvtárban fogja létrehozni és keresni. Ez szokás szerint az a könyvtár, aholmaga a script található, kivéve ha a scriptet egy IDLE shell ablakból indítjuk. Ez esetben az aktuális könyvtáraz IDLE indításakor van definiálva (Windows alatt ennek a könyvtárnak a definíciója részét képezi az indítóikon tulajdonságainak).Ha az IDLE­vel dolgozunk, akkor biztos, hogy a Pythont az aktuális könyvtárának megváltoztatására akarjukmajd kényszeríteni azért, hogy az megfeleljen az elvárásainknak. Ennek megtételéhez használjuk a következőutasításokat a session elején. (Most feltételezem, hogy a használni szándékozott könyvtár a /home/jules/exer­cices). Használhatjuk ezt a szintaxist (vagyis szeparátorként a / karaktert nem pedig a  \ karaktert). A Python au­tomatikusan elvégzi a szükséges konverziókat annak megfelelően, hogy MacOS, Linuxban dolgozunk.

>>> from os import chdir>>> chdir("/home/jules/exercices")

Az első parancs az os modul chdir() függvényét importálja. Az os modul egy sor függvényt tartalmaz, amik az

91

operációs rendszerrel (os = operating system) való kommunikációt teszik lehetővé, bármi is legyen az operációsrendszerünk. A második parancs a könyvtárat változtatja meg («chdir»     «change directory»).≡

A Pythonban a fájlokhoz való hozzáférést egy közbenső «fajl» biztosítja, amit az open() belsőfüggvény segítsé­gével hozunk létre. Ennek a függvénynek a hívása után a fajl speciális metódusait használva olvasni és írni tu­dunk a fájlban.Az alábbi példa bemutatja, hogyan nyitunk meg egy fájlt «írásra», jegyzünk be két karakterláncot, majd zárjukle a fájlt. Jegyezzük meg, hogy ha a fájl még nem létezik, akkor automatikusan létre lesz  hozva. Ha viszont anév egy már létező és adatokat tartalmazó fájlra vonatkozik, akkor a bejegyzendő karaktereket hozzáfogja fűznia meglévőekhez. Ezt a gyakorlatot parancssorból végrehajthatjuk:

>>> fajl = open('sajatFile','a')>>> fajl.write('Szia, hello !')>>> fajl.write("Hogy vagy?")>>> fajl.close()>>>

Az első sor egy «fajl» nevű fájlobjektumot hoz létre. Ez egy valódi fájlra hivatkozik, aminek a neve «sajatFile»lesz. Ne keverjük össze a fájl nevét a fájlobjektum nevével, amin keresztül hozzáférünk a fájlhoz. A gyakorlatsorán ellenőrizhetjük, hogy a rendszerünkben (az aktuális könyvtárban) egy «sajatFile» nevű   fájlt (aminek atartalmát bármelyik szövegszerkesztővel megnézhetjük) hozott létre a program.Az open() függvény két string típusú argumentumot vár. Az első a megnyitandó fájl neve, a második a megnyi­tás módja. Az «a» azt jelenti, hogy «hozzáfűzés» (append) módban kell a fájlt megnyitni, azaz a bejegyzendőadatokat a fájl végéhez, a már esetleg ott lévő adatokhoz kell fűzni.A «w» (írásra) fájlmegnyitási módot is használhattuk volna, de ha ezt a módot használjuk, a Python mindig egyúj (üres) fájlt hoz létre és az adatok írása ennek az üres fájlnak az elejétől kezdődik. Ha már létezik egy azonosnevű fájl, akkor azt előbb törli.A write() metódus végzi a fájlba írást. A kiírandó adatokat argumentumként kell megadni. Ezeket az adatokatsorban egymás után írja ki a fájlba (ezért beszélünk szekvenciális  hozzáférésű fájlról). A write() minden új hí­vása a már rögzített adatok után folytatja az írást.A close() metódus lezárja a fájlt. Ettől kezdve az mindenféle használatra rendelkezésre áll.

File szekvenciális olvasásaÚjra megnyitjuk a fájlt, de ez alkalommal «olvasásra», hogy vissza tudjuk olvasni az előző fejezetben rögzítettinformációkat:

>>> fajl = open('sajatFajl', 'r')>>> t = fajl.read()>>> print Szia, hello ! Hogy vagy?>>> fajl.close()

Amint az várható a read() metódus kiolvassa a fájlbeli adatokat és egy «karakterlánc» (string) típusú változóbateszi. Ha argumentum nélkül használjuk ezt a metódust, akkor az egész fájltartalmat beolvassa. «sajatFajl» an­nak a fájlnak a neve, amit olvasni akarunk. A  fájlt megnyitó utasításnak szükségszerűen hivatkozni kell erre anévre. Ha nem létezik a fájl, akkor egy hiba üzenetet kapunk.Példa:

>>> fajl = open('sajatFajl','r')IOError: [Errno 2] No such file or directory: 'sajatFajl'

Viszont semmilyen kikötést sem tettünk a fájlobjektum nevének megválasztására vonatkozóan. Ez egy tetszőle­ges változónév. Így az első utasításunkban egy «fajl»nevű fájlobjektumot hoztunk létre, ami az olvasásra(«r»argumentum ) megnyitott «sajatFajl» valódi fájlra hivatkozik. A két beírt string most egyetlen stringként van a fájlban. Ez  így természetes, mivel semmilyen  elválasztóka­raktert sem adtunk meg, amikor beírtuk őket a fájlba.A read() metódust argumentummal is használhatjuk. Az argumentum azt adja meg, hogy hány karaktert kell be­olvasni a fájlban már elért pozíciótól:

92

>>> fajl = open('sajatFajl', 'r')>>> t = fajl.read(7)>>> print t

         Szia, h>>> t = fajl.read(15)>>> print tello ! Hogy vag

Ha a fájlban nincs annyi karakter hátra, mint amennyit az argumentum megad, akkor az olvasás a fájl végénegyszerűen leáll:

>>> t = fajl.read(1000)>>> print t Szia, hello ! Hogy vagy?

Ha a fájl végén vagyunk, akkor a read() metódus egy üres stringet küld vissza:>>> t = fajl.read()>>> print t>>> fajl.close()

A ciklusból való kilépésre szolgáló a break utasítás. Programhurkokra van szükségünk, amikor egy olyan fájltkell kezelnünk, aminek nem ismerjük előre a tartalmát. Az alapelképzelés az, hogy részletekben olvassuk a fájltmindaddig, amíg el nem érjük a fájl végét.Az egész fájlt átmásolja egy másik fájlba 50 karakteres részletekben: 

def masolFajl(forras, cel): fforras = open(forras, 'r') fcel = open(cel, 'w') while 1: 

txt = fforras.read(50) if txt =="":       break 

fcel.write(txt) fforras.close() fcel.close() return 

Ha ellenőrizni akarjuk a függvény működését, két argumentumot kell megadni : az első az eredeti fájl neve, a második a másolat neve.Példa : masolFajle('forrasFajl','celFajl')  A while utasítást mindig egy kiértékelendő feltétel követi. Amíg ez a feltétel igaz, addig fog a while utasítástkövető utasításblokk végrehajtódni. Itt pedig a kiértékelendő  feltételt egy állandó helyettesíti.  Azt is tudjuk,hogy a Python minden nullától különböző numerikus értéket igaznak tekint. Az így megalkotott  while  ciklus végtelen ciklus, mert a folytatásának a feltétele mindig igaz. Ez azonban meg­szakítható a break utasítás hívásával, ami többféle kilépési mechanizmus elhelyezését teszi lehetővé ugyanabbaa programhurokba: 

while <feltétel1> : ­­­ különböző utasítások ­­­ if <feltétel2> :        break ­­­ különböz ő utasítások ­­­ if <feltétel3>:        break stb. 

Könnyű belátni, hogy a masokFajl() függvényünkben a break utasítás csak akkor fog végrehajtódni, ha elértük a fájl végét.

93

Egy szövegfájl egy olyan fájl, ami nyomtatható karaktereket és betűközöket tartalmaz egymást követő sorokbarendezve. A sorokat egy nem nyomtatható speciális karakter a « sorvége karakter » választja el egymástól. A Pythonnal nagyon könnyen kezelhetők az ilyen fajta fájlok. A következő utasítások egy négysoros szöveg­fájlt hoznak létre: 

>>> f = open("szovegfajl", "w") >>> f.write("Ez az első sor\nEz a második sor\n") >>> f.write("Ez a harmadik sor\nEz a negyedik sor\n") >>> f.close() 

A szövegbe \n sorvége jelzéseket szúrunk be azokra a helyekre, ahol el akarjuk egymástól választani a szöveg­sorokat. Enélkül a marker nélkül a karaktereket egymás után írnánk ki a fájlba. Az olvasási műveletek alatt a szövegfájl sorai külön­külön nyerhetők vissza. A readline() metódus egyszerrecsak egy sort olvas: 

>>> f = open('szovegfajl','r') >>> t = f.readline() >>> print t Ez az első sor >>> print f.readline() Ez a második sor 

A readlines() metódus az összes maradék sort egy szövegből álló listába teszi: >>> t = f.readlines() >>> print t ['Ez a harmadik sor\012', 'Ez a negyedik sor\012'] >>> f.close() 

A lista nyers formában jelenik meg, a karakterláncokat határoló aposztrófokkal és numerikus kód formájú spe­ciális karakterekkel.A readlines() metódus lehetővé teszi, hogy egyetlen utasítással olvassunk el egy egész fájlt. Ez azonban csakakkor lehetséges, ha az olvasandó fájl nem túl nagy. (Mivel teljes egészében be fogja másolni egy változóba,vagyis a számítógép operatív memóriájába. ezért a memória méretének megfelelően nagynak kell lenni.) Hanagy fájlokat kell kezelnünk, inkább a readline() metódust használjuk egy programhurokban. A readline() metódus egy karakterláncot ad vissza, míg a readlines() metódusa egy listát. A fájl végén a read­line() egy üres stringet, míg a readlines() egy üres listát ad vissza. A következő függvényben úgy másolunk át egy szövegfájlt egy másik fájlba, hogy minden olyan sort kiha­gyunk, ami # karakterrel kezdődik: 

def feltmasol(forras,cel): fforras = open(forras, 'r') fcel = open(cel, 'w') while 1:       txt = fforras.readline()       if txt =='': 

break       if txt[0]!= '#':     fcel.write(txt) fforras.close() fcel.close() return 

A függvény hívásához két argumentumot kell megadni: az eredeti fájl nevét és annak a fájlnak a nevét, ami a másolatot fogja tartalmazni.Példa : feltmasol('forras.txt', 'cel.txt')

A write() metódus argumentumának egy karakterláncnak kell lenni. Úgy tudunk más értéktípusokat elmenteni,hogy azokat először szöveggé alakítjuk, ezt a beépített str() függvény segítségével tehetjük meg.

94

>>> x = 52 >>> f.write(str(x)) 

Ha a numerikus értékeket először karakterlánccá alakítjuk és így mentjük el azokat, akkor azt kockáztatjuk,hogy nem fogjuk tudni azokat helyesen visszaalakítani numerikus értékekké amikor majd a fájlból olvassuk.Példa: 

>>> a = 5 >>> b = 2.83 >>> c = 67 >>> f = open('sajatFajl', 'w') >>> f.write(str(a)) >>> f.write(str(b)) >>> f.write(str(c)) >>> f.close() >>> f = open('sajatFajl', 'r') >>> print f.read() 52.8367 >>> f.close() 

Nem tudjuk, hány érték is van a fájlban. Megoldás erre: importáljuk a pickle modult.A pickle modul dump() függvénye két argumentuma: változónév, fájlobjektum, amibe menteni fogjuk a válto­zó értékét. A pickle.load() függvény a fordított irányú műveletet végzi el, vagyis visszaállít minden változót atípusával. 

>>> import pickle >>> f = open('sajatFajl', 'w') >>> pickle.dump(a, f) >>> pickle.dump(b, f) >>> pickle.dump(c, f) >>> f.close() >>> f = open('sajatFajl', 'r') >>> t = pickle.load(f) >>> print t, type(t) 5 <type 'int'> >>> t = pickle.load(f) >>> print t, type(t) 2.83 <type 'float'> >>> t = pickle.load(f) >>> print t, type(t) 67 <type 'int'> >>> f.close()

GUI programok

OOP programok

    Csak kiírató utasítás 0001­0050

    Kiíratás és operátorhasználat 0051­0100

    Kiíratás és escape szekvenciák használata 0101­0150

95

    Változóhasználat 0151­0180

    Típusválasztásos 0181­0200

    Formázott kimenet 0201­0250

    Matematikai könyvtár/osztály használatát követeli meg 0251­0300

    Bekérést is tartalmaz 0301­0400

Feladat 0001

Írassa a képernyőre a saját nevét.

A program ez után a képernyőre a következő piramist rajzolja:

    @

   @@@

  @@@@@

 @@@@@@@

@@@@@@@@@

Mentés: piramis

Feladat 0002

Írassa a képernyőre a következő névjegyet:

==============================

||                          ||

||    Nagy József           ||

||                          ||

||    15a                   ||

||                          ||

||    2012.01.04            ||

96

||                          ||

==============================

A nevet javítsa a sajátjára. A dátumot az aktuális dátumra.

Mentés: piramis

Feladat 0003

A program első sorba a saját nevét írja ki. A következő sorba a dátumot írassa ki, amikor írja a programot.

Rajzoltassa a következő rajzot a képernyőre:

    __

    ||

    || /|

    ||/ |

    |/  |

    /   |

   /    |

   |    |

   |    |

   ­­­­­­ 

Mentés: haziko

Feladat 0004

A program először saját nevét írja a képernyőre.

Ez után, rajzoltassa a következő fát a képernyőre:

97

@  @    @

 @ @ @ @

  @   @

   @ @    @

    @   @

 @  @ @

  @ @@

   @@

    @

    @

    @

Mentés: fa

Feladat 0005

A program először saját nevét írja a képernyőre, majd a következő sorba a program készítés napjának dátumát.

Ezt követően rajzolja a következő gyümölcsöt a képernyőre:

     @

     @

    @@

    @

  @@@@@@

 @@ @@ @@

 @   @  @

 @      @

 @@     @

98

  @@  @@

    @@@

Mentés: gyumi

Feladat 0006

A program elsőként saját nevét, és a program elkészítés dátumát írja a képernyőre.

Ezt követően, írassa a képernyőre a következő táblázatot:

  #######

  #3#7#8#

  #######

  #9#8#2#

  #######

  #8#2#3#

  #######

Mentés: table

Feladat 0007

A program először írja saját nevét a képernyőre. A következő sorba a program készítésének dátumát írjaki.

Ez után rajzoltassa képernyőre a következő táblázatot:

  ­­­­­­­­­­­

  | 37 | 42 |

  ­­­­­­­­­­­

  | 23 | 76 |

99

  ­­­­­­­­­­­

  | 14 | 98 |

  ­­­­­­­­­­­

Mentés: table2

Feladat 0008

Írassa ki a „Gyártó: ” szöveg után saját nevét. A következő sorba a programkészítés dátumát írassa ki.

Ezek után egy üres sor hagyásával a következő ábrát rajzoltassa a képernyőre:

              >>>>>>>>>>>>>>>>><<<<<<<<<<<<<<<<<<<<<

>>>>>>>>>>>>>>>>                                  <<<<<<<<<<<<<<<<<<<<<<

>>>>>>>>>>>>>>>>                                  <<<<<<<<<<<<<<<<<<<<<<

>>>>>>>>>>>>>>>>              ooo                 <<<<<<<<<<<<<<<<<<<<<<

>>>>>>>>>>>>>>>>                                  <<<<<<<<<<<<<<<<<<<<<<

>>>>>>>>>>>>>>>>                                  <<<<<<<<<<<<<<<<<<<<<<

>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>><<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<

Mentés: kozep

Feladat 0009

Írassa ki a „Gyártó: ” szöveg után saját nevét. A következő sorban a program készítésének dátumát írassa ki.

Egy üres sor hagyása után a következő ábrát rajzoltassa a képernyőre:

             @   @

            @   @

           @   @

100

@@@@@@@@@@@   @

@            @

@           @

@@@@@@@@@@@@

Mentés: uto

Feladat 0010

Írassa ki a „Gyártó: ” szöveg után saját nevét. A következő sorban a program készítésének dátumát írassa ki.

Ez után, egy üres sor hagyásával a következő rajzot jelenítse meg:

          @     

        @   @

      @       @

    @           @

   @              @

 @                  @

@ @@@@@@@@@@@@@@@@@@ @

  @                @

  @     @@@@@@     @

  @     @    @     @

  @     @    @     @ @ @ @ @ @ @ @ @ @ @ @     @ @ @ @ @

  @     @@@@@@     @@@@@@@@@@@@@@@@@@@@@@@     @@@@@@@@@

  @                @ @ @ @ @ @ @ @ @ @ @ @     @ @ @ @ @

  @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@     @@@@@@@@@

Mentés: hiziko

101

Feladat 0011

Írassa ki a „Gyártó: ” szöveg után saját nevét. A következő sorban a program készítésének dátumát írassa ki.

Ez után, egy üres sor hagyásával a következő rajzot jelenítse meg:

 @        @

  @      @

  @      @

  @      @

  @      @

   @@  @@

     @@

     @@

     @@

     @@

  @@@@@@@@

Mentés: kehe

Feladat 0012

Írassa ki a „Szerző: ” szöveg után saját nevét. A következő sorban a program készítésének dátumát írassa ki.

Ez után, egy üres sor hagyásával, a következő rajzot jelenítse meg:

               #

              # 

               #

102

              #

               #

              #

       # # # # # # # # ## 

       #              #  #

      #              #   #

     #               #   #

    #                 # #

    #                  #

     #               #

       # # # # # # #

Mentés: teagoz

Feladat 0013

Írassa ki a „Szerző: ” szöveg után saját nevét.

Ez után a következő rajzot jelenítse meg:

           ############## 

          #            # #             #######

         #            # #              #######

        #            # #                #   #

       #            # #                #     #

      #            # #                #       #

     #            # #                #         #

    ############## #                 #         #

   #            # #                  #         #

    ##############                   ###########

103

Mentés: konyvtinta

Feladat 0014

Írassa ki a „Szerző: ” szöveg után saját nevét.

Ez után a következő rajzot jelenítse meg:

                                    #

                                  #   #

                                 #     #

                                #       #

 #####     ####     ####     ####       ####   ####

 # o #     #  #     #  #     #  #       #  #   #  #

 #   #######  #######  #######  #       #  #####  #

 #                              #       #         #

 ################################       ###########

Mentés: varokapu

Feladat 0015

A program első sorba a saját nevét írja ki. A következő sorba a dátumot írassa ki, amikor írja a programot.

Rajzoltassa a következő rajzot a képernyőre:

        __

      _ ||

     / \||

    /   \|

   /     \

104

   |     |

   |     |

   ­­­­­­­ 

Mentés: haziko

Feladat 0016

Írassa ki a „Szerző: ” szöveg után saját nevét.

Ez után a következő rajzot jelenítse meg:

           (o)===============(O)

           //                 \\  

       ___//_                  \\

      /      \                  \\

     /        \                  \\

    /          \                  \\

   /            \                  \\

   ­­­­­­­­­­­­­­                   \\

                                     \\

                                     (O)

                                     //

                                    //

                                   //

                                  //

                                 //

                                //

                               //

                              //

                             //

105

                ||          //

           ==========================

Mentés: lampa

Feladat 0017

Írassa ki a „Szerző: ” szöveg után saját nevét.

Ez után a következő rajzot jelenítse meg:

   __        /\  

  /  \      |  |

  |  |    _  \/

   \ /   / \_/

    |   _|

     \_/ |\

         ||

     ===========

     \\       //

      \\     //

       \\===//

   \\============//

Mentés: husevo

Feladat 0018

Írassa ki a „Szerző: ” szöveg után saját nevét.

Ez után a következő rajzot jelenítse meg:

106

      //

     //­      ==========\\

    // \\    //          \\

        \\  //            \\

         \\//=========\   ||

          ||          ||  ||

          ||          ||  ||      

          ||          ||==// 

          ||          ||

          ||          ||

          ||          ||

          ||==========||

Mentés: locsolo

Feladat 0019

Írjon programot, amely 2 felnőtet, egy gyereket rajzol. A feladathoz pálcika emberkék is megfelelnek!

Mentés: emberek

Feladat 0020

Írjon programot, amely kiírja saját nevét, következő sorba osztályát, az aktuális dátumot.

A program ez után rajzolja a magyar­kártya egyik ász lapját a képernyőre. Használja saját fantáziáját.

Mentés: kartyo

Feladat 0021

Írjon programot, amely kiírja saját nevét, következő sorba osztályát, az aktuális dátumot.

107

A program ez után rajzolja egy analóg óra számlapját, mutatókkal együtt (karakterekből). Használja saját fantáziáját.

Mentés: oras

Feladat 0022

Írjon programot, amely a következő növényt rajzolja a képernyőre karakteresen:

Mentés: noveny

Feladat 0023

 __________________

< Ezt rajzold meg! >

 ­­­­­­­­­­­­­­­­­­

        \   ^__^

         \  (oo)\_______

            (__)\       )\/\

                ||­­­­w |

                ||     ||

Mentés: boci

Feladat 0051

Írassa ki a következő kifejezés eredményét: (33*45)/2

Feladat 0052

Írassa ki a következő kifejezés eredményét: {(2,3 * (4,5 ­ 3,7))*2}/ {8,0}

Mentés: szoroz

Feladat 0053

108

Írassa a képernyőre a 9 / 2 osztás maradékát.

A következő sorban a 8 / 4 osztás eredményét írja a képernyőre.

Mentés: maradek

Feladat 0054

Írassa saját nevét a képernyőre, majd a következő sorba ennek a kifejezésnek az eredményét:

(35­47)/2

Mentés: kivon

Feladat 0055

Írassa a „Gyártó: ” szöveg után a saját nevét a képernyőre.

Ez után a következő kifejezés értékét írassa a képernyőre:

((482 / 44) * 32 / {47 + 97}) / 2

Mentés: kif5

Feladat 0056

Írassa a „Gyártó: ” szöveg után a saját nevét a képernyőre.

Ez után a következő kifejezés értékét írassa a képernyőre:

{{23 + 44} / 2}­20

109

Mentés: kif16

Feladat 0057

Írassa a „Gyártó: ” szöveg után a saját nevét a képernyőre.

Ez után a következő kifejezés értékét írassa a képernyőre:

{72 * 2} / {3 + 7}

Mentés: kif17

Feladat 0058

Írassa a „Gyártó: ” szöveg után a saját nevét a képernyőre.

Ez után a következő kifejezés értékét írassa a képernyőre:

({{(67*22)/43} * 2}/456) * 2

Mentés: kif18

Feladat 0059

Írassa a „Gyártó: ” szöveg után a saját nevét a képernyőre.

Ez után a következő kifejezés értékét írassa a képernyőre:

{(28/2)+40}/4

Mentés: kif19

Feladat 0060

110

Írassa a „Gyártó: ” szöveg után a saját nevét a képernyőre.

Ez után a következő kifejezés értékét írassa a képernyőre:

{(217 ­ 25} / 2) *7

Mentés: kif20

Feladat 0061

Írassa a „Gyártó: ” szöveg után a saját nevét a képernyőre.

Ez után a következő kifejezés értékét írassa a képernyőre:

{({3+7} / 27)*2} / (10 ­ 3)*2

Mentés: kif20

Feladat 0062

Írassa a „Gyártó: ” szöveg után a saját nevét a képernyőre.

Ez után a következő kifejezés értékét írassa a képernyőre:

({(5+2)*3) ­ {((2+4)*4)}} / {2/4}

Mentés: kif20

Feladat 0063

Írassa a „Gyártó: ” szöveg után a saját nevét a képernyőre.

Ez után a következő kifejezés értékét írassa a képernyőre:

111

({({ 3*4.2 / {(49*47)+8}})*(3/4)}/3) ^2

Mentés: kif203

Feladat 0064

Írassa a „Gyártó: ” szöveg után a saját nevét a képernyőre.

Ez után a következő kifejezés értékét írassa a képernyőre:

({{37/2}*5.7}/{45.2}) * 3

Mentés: kif203

Feladat 0065

Írassa a „Gyártó: ” szöveg után a saját nevét a képernyőre.

Ez után a következő kifejezés értékét írassa a képernyőre:

(({47*3,14}/12)+({48­32}/7))*2

Mentés: kif065

Feladat 0066

Írassa a „Szerző: ” szöveg után a saját nevét a képernyőre, a következő sorba készítés dátumát.

Ez után a következő kifejezés értékét írassa a képernyőre:

({(43*2)+(77­23)}/{27,5*8})*({97*2}/50)

112

Mentés: kif0066

Feladat 0067

Írassa a „Szerző: ” szöveg után a saját nevét a képernyőre, a következő sorba készítés dátumát.

Ez után a következő kifejezés értékét írassa a képernyőre:

( {(({2,7}/{3,857})*{9,274})+4} / {({8,5471}*{2,13})­17} )­5

Mentés: kif0067

Feladat 0068

Írjon programot, amelyben a következő kifejezés értéket kapjuk meg.

(((32*43)+7)/(12,7+8))­2

Mentés: kif0068

Feladat 0069

Írjon programot, amely kiszámítja a következő kifejezés értékét:

((4.5 * 3.943)+2.48)/ {2.7}

A pontok, tizedespontok.

Feladat 0101

Írassa ki a saját nevét és a települést, ahol lakik idézőjelek között, egyetlen utasítással, két sorban.

Mentés: kiidez

Feladat 0102

113

Írassa a képernyőre a következőket:

1    alma    500

2    szilva  700

3    barack  850

4    körte   370

Az egyes oszlopok között tabulátor legyen. Minden egyes sort egy kiírató utasítással írasson ki. Használjon escape szekvenciát a tabulátorokhoz és a sortöréshez.

Mentés: gyumik

Feladat 0103

Írassa képernyőre a következő névjegyet. A „Saját Név” szöveget cserélje le a sajátjára.

"""""""""""""""""""""""""""""""""""""""""""

"                                         "

"           Saját Név                     "

"           próbálkozó                    "

"                                         "

"          (35) 424­8822                  "

"                                         "

"""""""""""""""""""""""""""""""""""""""""""

A keretet escape szekvenciákkal rajzolja ki, idézőjel megjelenítésével.

Mentés: probalkozo

Feladat 0104

114

Írassa a következő oszlopokat a képernyőre, tabulátorral tagolva az egyes oszlopokat.

1        processzor       3      25000

2        merevlemez       5      32000

3        monitor          4      37000

4        pendrive         3      11000

A kiíratáshoz használjon escape szekvenciát.

Mentés: szamito

Feladat 0105

Írassa a „Gyártó: ” szöveg után saját nevét a képernyőre.

Írassa a következő oszlopokat a képernyőre, tabulátorral tagolva az egyes oszlopokat.

1        Nagy József      3

2        Péti Feren       2

3        Lápos Géza       5

4        Gender Lajos     1

A kiíratáshoz használjon escape szekvenciát.

Mentés: osztaly

Feladat 0106

Írassa a „Gyártó: ” szöveg után saját nevét a képernyőre.

Írassa a következő neveket és településeket a képernyőre. A nevek és a települések legyenek idézőjelben. A név után legyen tabulátor.

115

"Tér Erzsébet"     "Miskolc"

"Nagy József"     "Szolnok"

"Tél Gábor"     "Miskolc"

"Rongy Elek"     "Szeged"

"Fer Tamás"     "Miskolc"

A kiíratáshoz használjon escape szekvenciát.

Mentés: osztaly

Feladat 0107

Írassa a „Szerző: ” szöveg után saját nevét a képernyőre.

Írassa a következő oszlopokat a képernyőre, tabulátorral tagolva az egyes oszlopokat.

1        Fekete Gábor     Szeged

2        Péti Feren       Szolnok

3        Lápos Géza       Debrecen

4        Gender Lajos     Szeged

5        Geszti Árpád     Szolnok

6        Lantos Zoltán    Miskolc

7        Fehér Irén       Debrecen

8        Prog Lajos       Szolnok

A kiíratáshoz használjon escape szekvenciát.

Mentés: dolga

Feladat 0151

116

A program első sora saját nevét írja a képernyőre.

Tegye 35­öt egy szam nevű változóba. Tegye 47­et egy szam2 nevű másik változóba. Szorozza meg mindkét változó értékét 2­vel, majd, adja össze az eredményeket, a végeredményt írassa a képernyőre.

Mentés: szorka

Feladat 0152

Hozzon létre egy vnev nevű változót, tegye bele vezeték nevét. Hozzon létre egy knev nevű változót, tegye bele keresztnevét.

Írassa a képernyőre mindkét változó értéket, a kettő között legyen egy szóköz.

Mentés: nevek

Feladat 0153

A program első sora saját nevét írja képernyőre.

Vegye fel a következő változókat: a, b, c. Helyezze el bennük a következő értékeket:

3,7  4,8  2,4

Írassa ki a változók tartalmának összegét, és az összeg felét.

Mentés: oszti

Feladat 0154

A program első sora a „Gyártó: ” szöveget, majd a saját nevét írja a képernyőre.

Vegyen fel 5 darab változót. Vegyen fel bennük egy valós számot, majd adja össze tartalmukat. Az összegüket egy „osszeg” nevű változóban helyezze el, amelyet osszon el 5­el. A végeredményt írassa a képernyőre a következő szöveg után: „Atlag: ”.

117

Ügyeljen a kiíratandó szövegekben a szóközök és a kettőspontok meglétére.

Mentés: atle

Feladat 0155

Számítsuk ki egy háromszög területét, ha adott a háromszög egy oldala, és hozzátartozó magassága! Az oldalt és a magasságot egyszerű értékadással mi határozzuk meg!

Mentés: haromszog

Feladat 0156

Írjon egy programot, amely a, b, c, d változókat deklarál rendre a következő értékekkel: 10, 9, 1, 2 Adja össze az első két számot és helyezze egy s változóba! Ez után számítsa ki a másik két szám szorzatát, az eredmény helyezze a p változóba! Végül írja ki p és s változók értékét egy sorba!

Mentés: negyes

Feladat 0157

Írjon programot, amelynek első sora saját nevét és az aktuális dátumot írja a képernyőre. A következő sorok egy „a” változóban 35­öt, majd egy „b” változóban 27­et tárolnak. A program következői sorai cseréljék meg a két változó tartalmát. Tehát az „a” változóban vegye fel „b” változó tartalmát, a „b” változó az „a” változó tartalmát. Akkor is működjön a csere, ha az „a” és „b” változó más értékeket tartalmaz.

Mentés: csere

Feladat 0158

Egy tehénfarm költségeit kell kiszámítania egy évre. A tehenek száma (például: 300), és az egy napra jutóköltség (például: 3000 ­ Ft) adott. A program írja ki, egy évben mennyibe kerül az összes tehén tartása.

Mentés: tehen

118

Feladat 0181

Egy kockadobást, egy fizetést és egy karaktert kell eltárolnia. Válassza ki azokat a típusokat, amelyek elegendőek a tároláshoz.

Mentés: tipval

Feladat 0201

Adott egy „a” nevű valós számokat tárolni képes változó 583,123456789 értékkel. Írassa ki a számot 3 tizedesjegy pontossággal, 20 szélesen.

Feladat 0202

A program első sora saját nevét írja a képernyőre.

Írjon programot, amelyben adott egy név és egy fizetés. Írja ki a nevet 30 szélesen jobbra igazítva, azt következő sorban a fizetést szintén 30 szélesen Ft utótaggal.

Mentés: fizute

Feladat 0203

Írjon programot, amely tárolja az e havi bevételt és kiadást (pl: Kiadás: 280315500; Bevétel: 125270000).

Írassa ki az egyenleget, 30 szélesen, 3 tizedesjegy pontossággal, „Ft” egységként.

Mentés: egyenleg

Feladat 0204

Írjon programot, amely a következő hőmérséklet adatokat, valós számok alakjában tárolja:

    15,82

    18,27

119

    22,40

    23,19

    24,57

    22,02

    20,28

Az adatok hétfőtől vasárnapig egy hét adatait tartalmazzák. A program írja ki egymás alá az adatokat.

A sorok a hőmérséklet adat értéket mutassák először, 1 tizedesjegy pontossággal, 15 szélesen, jobbra igazítva, előjellel, a következő oszlop 10 szélességben, balra igazítva mutassa milyen napra esett.

Példa:

        15.8   hétfő

        18.2   kedd

        22.4   szerda

        23.1   csütörtök

        24.5   péntek

        22.0   szombat

        20.2   péntek

Mentés: homer

Feladat 0205

Írjon programot, amelyben egy float típusú változóban elhelyezi a 18,58 értéket, majd három tizedesjegy pontossággal, 17 helyen, vezető nullákkal írassa a képernyőre.

Mentés: flotul

Feladat 0206

Írjon programot, ahol 5 raklap áru súlyát tároljuk. A raklapok súlya áruval együtt, kilogramban 

120

kifejezve a következő:

    214,5

    232,48

    243,25

    217,18

    231,05

Tegye 5 darab változóba az egyes értékeket, majd írassa ki egy tizedesjegy pontossággal, mértékegységgel együtt. A számok 24 helyen legyenek ábrázolva. Minden súlyérték mértékegységgel jelenjen meg egymás alatt öt sorban.

Feladat 0207

Adott négy raklap áru, amelynek a súlya rakománnyal együtt kilogramban kifejezve a következők:

    342,5

    289,7

    312,5

    322,42

Egy raklap súlya 12 kg. Írassa ki minden raklapon lévő áru súlyát mázsába átszámítva, a raklapok súlya nélkül. A kiíratás 2 tizedesjegy pontossággal, 8 helyen ábrázolva történjen. Minden súlyérték mértékegységgel jelenjen meg egymás alatt négy sorban.

Feladat 0251

Írjon programot, amely kiszámítja egy paralelogramma területét, ha adott két oldala (a és b) és az általuk közbe zárt szög (gamma). A paralelogramma terültszámításának képlete az alábbi:

T = a b sin(gamma)

Mentés: parater

121

Feladat 0252

Írjon programot, amely kiszámítja a tényleges kamatot, ha az évenkénti tőkésítések száma 6, a névleges kamat, 5%, 1 évről van szó, és a betett összeg 100 Ft.

Használja a következő képletet:

Tényleges = ((1 + névleges / {100 tőkésítésekSzáma}) ^ {tőkésítésekSzáma ­ 1 }) betét

A program a következőket írja ki:

Tényleges kamat számítása

Tényleges éves kamat: (A választ a gép adja)

Mentés: tenyleg

Feladat 0253

Írjon programot, amely kiszámítja egy kúp felszínét.

A = (pi r^2) + (pi r sqrt{r^2 + h^2})

A  felszín

r  sugár

h  magasság

Mentés: kup

Feladat 0254

Vegye fel a következő változókat a következő értékekkel:

    a = 15;

122

    b = 21;

    c = 13;

    d = 27;

    e = 33;

Számítsd ki a számok négyzetes közepét.

Négyzetes közép képlete

Q=sqrt{{{x^{2}}_{1} + {x^{2}}_{2} + {x^{2}}_{3} ... + {x^{2}}_{n}}/n}

Mentés: negyzetes

Feladat 0255

Írassa a „Gyártó: ” szöveg után a saját nevét a képernyőre.

Ez után a következő kifejezés értékét írassa a képernyőre:

({({ 3^4/{49*sqrt{47+8}}})*(3/4)}/3) ^2

Mentés: kif203

Feladat 0256

Írassa a „Gyártó: ” szöveg után a saját nevét a képernyőre.

Ez után a következő kifejezés értékét írassa a képernyőre:

{sqrt{5^2*3} * sqrt{2^4*4}} / {2^4}

Mentés: kif20

123

Feladat 0257

Írassa a „Gyártó: ” szöveg után a saját nevét a képernyőre.

Ez utána a következő kifejezés értékét írassa a képernyőre:

{({3^7} / 27)*2} / sqrt {10 * 3 ^ 5}

Mentés: kif67

Feladat 0258

Írassa a „Gyártó: ” szöveg után a saját nevét a képernyőre.

Ez után a következő kifejezés értékét írassa a képernyőre:

({sqrt{5^3*2} * sqrt{2^4}} / {2^4})^3

A programot alakítsa úgy, hogy 4 tizedesjegy pontossággal írja ki a számot, 20 szélesen.

Mentés: kif68

Feladat 0259

Írassa a „Gyártó: ” szöveg után a saját nevét a képernyőre.

Ez után a következő kifejezés értékét írassa a képernyőre:

sqrt{ ({47*{3,14}/2})^2 + ({48­32}/{2^8}) }

A programot alakítsa úgy, hogy 4 tizedesjegy pontossággal írja ki a számot, 20 szélesen.

124

Mentés: kif0259

Feladat 0260

Írassa a „Gyártó: ” szöveg után a saját nevét a képernyőre.

Ez után a következő kifejezés értékét írassa a képernyőre:

sqrt{ {({(3+7)/{sin(9)}})­7}/({3^4}/{3­2}) }

A programot alakítsa úgy, hogy 4 tizedesjegy pontossággal írja ki a számot, 20 szélesen.

Mentés: kif0260

Feladat 0261

Oldja meg a következő műveletet.

{3/5} + {8/2}!

Feladat 0262

Oldja meg a következő műveletet.

33/28 = {33/42} + {28/24}!

Feladat 0263

Írjon programot, amely kiszámítja a következő kifejezés értékét:

(3/4)^2

Az eredményt tegye külön változóba. Írassa ki azt, három tizedesjegy pontossággal.

Feladat 0264

125

Írjon programot, amely kiszámítja a következő kifejezés értékét:

sqrt{34}*45^2

Az eredményt tegye külön változóba. Írassa ki azt, három tizedesjegy pontossággal.

Feladat 0265

Írjon programot, amely kiszámítja a következő kifejezés értékét:

sqrt{34*45}^3

Az eredményt tegye külön változóba. Írassa ki azt, kettő tizedesjegy pontossággal.

Feladat 0266

Írjon programot, amely kiszámítja a következő kifejezés értékét:

sqrt{34} sqrt{45}

Az eredményt tegye külön változóba. Írassa ki azt, kettő tizedesjegy pontossággal.

Feladat 0267

Írjon programot, amely kiszámítja a következő kifejezés értékét, ha a = 45, és b = 23.

sqrt{a^3} sqrt{b}

Az eredményt tegye külön változóba. Írassa ki azt, kettő tizedesjegy pontossággal.

Feladat 0268

Írjon programot, amely kiszámítja a következő kifejezés értékét, ha a = 24, és b = 13.

126

a^2 + sqrt{b} b^3

Az eredményt tegye külön változóba. Írassa ki azt, kettő tizedesjegy pontossággal.

Feladat 0269

Írjon programot, amely kiszámítja a következő kifejezés értékét, ha a = 21, és b = 15.

sqrt{a + b}

Az eredményt tegye külön változóba. Írassa ki azt, kettő tizedesjegy pontossággal.

Feladat 0270

Írjon programot, amely kiszámítja a következő kifejezés értékét, ha a = 12, és b = 25.

3 / {a + b}

Az eredményt tegye külön változóba. Írassa ki azt, kettő tizedesjegy pontossággal.

Feladat 0271

Írjon programot, amely kiszámítja a következő kifejezés értékét, ha a = 18, és b = 11.

35 / (a + b)^2

Az eredményt tegye külön változóba. Írassa ki azt, kettő tizedesjegy pontossággal.

Feladat 0272

Írjon programot, amely kiszámítja a következő kifejezés értékét, ha a = 48, és b = 51.

(a / b) 2^3

127

Az eredményt tegye külön változóba. Írassa ki azt, négy tizedesjegy pontossággal.

Feladat 0273

Írjon programot, amely kiszámítja a következő kifejezés értékét, ha a = 4, és b = 50.

a pi b^2

Az eredményt tegye külön változóba. Írassa ki azt, négy öt pontossággal.

Bekérést tartalmazó feladatok

Feladat 0301

Számítsa ki egy kör alapú kúp térfogatát. Kérje be az alap sugarát és a kúp magasságát.

V = 1/3 T h

T  alapterület

h  magasság

A kúp térfogata területszámítással:

V = 1/3 r^2 pi h

Mentés: terkup

Feladat 0302

Az anyagmennyiség jele az n. Mértékegysége a mol.

1 mol = 6*10^23 db részecske együttese

128

Kérje be hány mol konyhasója van, és írja ki fixpontos számábrázolással a részecskék számát.

Mentés: reszecske

Feladat 0303

Adott egy kör alakú telek. A telek felének gyepesítését nekünk kell megoldani. Tudjuk, hogy 1 négyzetméter gyepesítése 2500 forintba kerül.

Nem tudjuk, hogy a telek átmérője hány méter, de egyik barátunk most fogja megmérni és hozza az eredményt.

A barátja nemsoká visszaér, írja meg azt a programot, amely bekéri az általa mért adatot, majd kiszámítja hány négyzetméter gyeptéglára van szükségünk és az mennyibe kerül.

A kör területe: T = r^2*pi

Mentés: gyepes

Feladat 0304

Írjon egy programot, ami kiszámítja egy hónapban egy autóval mennyibe kerül 1km megtétele. A program a végrehajtása során kérje be az állandó költségeket (adó, garázs, stb.), a javítási költségeket, a benzinköltségeket és a megtett km­ek számát.

Mentés: autokoltseg

Feladat 0305

Írjon egy programot, amely négy adatot kér be. A bevitelt követően a program írja ki ezeket fordított sorrendben. Ha n pl. 5,2,11,12 értéket ad be, akkor a programnak 12,11,2,5 értékeket kell kiírnia. A program fogadjon el négy, szabadon választható számot.

Mentés: forditva

Feladat 0306

129

Számítsuk ki egy háromszög területét, a háromszög egy oldalából, és hozzátartozó magasságból! Kérjük be a háromszög oldalát és magasságát!

Mentés: haromszog2

Feladat 0307

Számítsuk ki egy háromszög kerületét, a háromszög három oldalából! Kérjük be a háromszög oldalait!

Mentés: haromszog3

Feladat 0308

Számítsuk ki egy háromszög területét, a háromszög három oldalából! Kérjük be a háromszög oldalait!

Mentés: haromter

Feladat 0309

Írjon programot, amely beolvassa egy mozgó test által megtett utat és időt, majd kiírja a test átlagsebességét!

Mentés: atlagsebesseg

Feladat 0310

Készítsen programot, amely bekér egy rombusz oldalának hosszát és az alfa szögét. Számítsa ki a rombusz kerületét és területét.

Mentés: romb

Feladat 0311

Írjon programot, amely kiszámítja egy rombusz területét annak két átlója segítségével. Az átlók hosszát kérje be a felhasználótól. A program első sora írja ki mit csinál a program. A program második sora az ön vezeték és keresztneve legyen, majd vessző, szóköz és az osztálya.

130

A program tartalmazzon egy megjegyzést, amelyben leírja mire használható a program, szerepel saját neve, a mai dátum és az osztálya.

Mentés: rombatl

Feladat 0312

Írjon programot, amely kiszámítja egy rombuszba írható kör sugarát.

Képlet:

r = {1/2} oldal sin(alpha)

A program kérje be az oldalt és az alfa szöget.

Mentés: tombsug

Feladat 0313

Írjon programot, amely kamatos kamatot számít. A feladat kiíratni a tényleges kamatot 1 évre. Bekéri a betétet a „betet” nevű változóba. Bekéri a betét évenkénti tőkésítésének számát, amit a tokesites_szam változóban tárolunk. Bekéri a névleges kamatot százalékban, amit a nevleges váltózóban tárolunk.

Tényleges = ((1 + névleges / {100 ~tökésítésekSzáma}) ^ {tökésítésekSzáma }­1) ~betét

A program a következőket írja ki:

Kamat számítás

Betét: (bekérés)

Névleges kamatot (%): (bekérés)

Évenkénti tőkésítések száma: (bekérés)

Tényleges éves kamat: (A választ a gép adja)

131

Mentés: kamatos

Feladat 0314

Írjon programot, amely kiszámítja egy trapéz területét. A területszámításnál vesszük két párhuzamos oldalának számtani közepét és megszorozzuk a magassággal. A program kérje be az egyik párhuzamos oldalt „a”­t és a másik párhuzamos oldat „c”, és kettő távolságát „m”­et. A program írja ki a trapéz területét.

Mentés: trapt

Feladat 0315

A húrnégyszög olyan négyszög, amelyhez van olyan kör, amely áthalad a négyszög négy csúcsán. Más megfogalmazásban, olyan négyszög, melynek oldalai egy kör húrjai.

Írjon programot, amely kiszámítja egy húrnégyszög területét. A program kérje be a húrnégyszög oldalait.

A húrnégyszög területe:

Terület T = sqrt{(s­a)(s­b)(s­c)(s­d)}

Félkerület s = {a + b + c + d}/2

Oldalak a, b, c, d

Mentés: hurnegyter

Feladat 0316

Írjon programot, amely kiszámítja egy trapéz területét, ha ismerjük annak oldalainak hosszát. Az oldalak hosszát kérje be. A terület számítás képlete:

T = {a + c} / {4(a­c)} sqrt{(a+b­c+d)(a­b­c+d)(a+b­c­d)(­a+b+c+d)}

Mentés: trapter

132

Feladat 0317

Számítsa ki egy hexadecagon területét. A hexadecagon szabályos tizenhatszög. A program kérje be egy oldalát, majd számolja ki a területét. A program első sora írja ki saját nevét, osztályát és az aktuális dátumot. A program második sor írja ki mit csinál a program.

A hexadecagon területszámításának képlete:

T=4a^2cot(pi/16)

Mentés: hexadecagonter

Feladat 0318

Írjon programot, amely kiszámítja egy kör alapú henger felszínét. A program kérje be a henger sugarát és hosszát.

A kör alapú henger felszínének számítása:

Mentés: hengfel

Feladat 0319

Írjon programot, amely kiszámítja egy tórusz térfogatát. A program kérje be a generáló kör sugarát (r), a forgástengely és a kör középpontjának távolságát (R).

A tórusz térfogatszámításának képlete:

Mentés: toruszterf

Feladat 0320

A láb hosszúság­mértékegység. 1 láb = 0,3048 méter (angol láb (foot).

133

Kérjen be egy értéket láb mértékegységben megadva, majd írja ki, hány méter. A program jelezze, hogy lábban kéri az adott értéket, az eredmény után is álljon ott, hogy méter.

Mentés: labmet

Feladat 0321

A hüvelyk hosszúság­mértékegység. Jelölése: ″

A nemzetközi hüvelyk: 1  = 2,54 cm Kérjen be egy cm értéket, majd írja ki hüvelykben.″

Mentés: huvcem

Feladat 0322

Kérje be egy ember testtömegét (kg) és testmagasságát (méter).

Megjegyzés: A normális testtömegindex 18 és 24 közötti szám.

Számolja ki a testtömegindexét, ha a képlet a következő:

testtömegindex = tömeg / magasság^2

Írassa ki a testtömegindext.

Mentés: tomtestin

Megjegyzés: Figyelem! Ez a számítás nem veszi figyelembe a testmagasságot, ezért nem ad jó eredményt. Alacsonyabb embereknél soványságot, magasabb embereknél testsúlyfelesleget mutathat.

Forrás: www.telegraph.co.uk

Mérjél helyette testzsírszázalékot. Például itt: http://szit.hu/tzs/

134

Feladat 0323

Szeretnénk n évre betenni x összeget, amely után n év múlva kapunk y összeget. Nem tudjuk megéri­e. Számítsuk ki a belső megtérülési rátáját (IRR ­ Inter Rate of Return).

Ezt gyakran használjuk arra, hogy megnézzük gazdaságos­e pénzünket befektetni. Ha a befektetéshez kötődő kamatláb (például a banki kamatláb) kisebb mint a megtérülési ráta, akkor gazdaságos befektetni.

Írjon programot, amely bekéri a hány évre szeretnénk betenni a tőkénket, mennyi tőkét szeretnénk betenni, mennyit kapnánk vissza. Számítsa ki a megtérülési rátát.

A megtérülési ráta kiszámításának képlete a következő:

r = root{t}{C_t/C_0} ­ 1

másként:

r = root{évek}{eztKapjuk/tőke} ­ 1

Feladat 0324

Célunk: ellenállás számítása

Kérje be az elektromos térerősséget (E), az elektromos áramsűrűséget (J), amelyből kifejezhető a fajlagosellenállás ( ) a következő képlettel:ρ

 = E / Jρ

Az ellenállás (R) kiszámításához kérje be a vezető hosszát(l) és a vezető keresztmetszetét (A). Számítsa ki az ellenállást a következő képlet alapján:

R =  *{l/A}ρ

135

Használt jelzések

    E = elektromos térerősség

    J = elektromos áramsűrűség

      (rho) = fajlagos ellenállásρ

    l = vezető hossza

    A = a vezető keresztmetszete

az ellenállás értékét írja a képernyőre.

Mentés: erel

Feladat 0325

Írjon programot, amely négy ellenállás értékét kéri be.

A program írja ki az eredő ellenállást ha az ellenállások sorba vannak kötve.

A program első sora a saját nevét írja a képernyőre.

Az eredő ellenállás számítása sorba kötött ellenállások esetén:

R_S = R_1 + R_2 + ... + R_n = sum {i=1}{n} {R_i}

Mentés: ered

Feladat 0326

Egy ellipszis alapú kúp térfogatát kell kiszámítani. Mivel az alap egy ellipszis így két sugara van az r_1 ésaz r_2. Kérje be a kúp magasságát és két sugarat, számítsa ki a térfogatát az alábbi képlet alapján:

Írassa a V = {1/3} pi r_1 r_2 h

136

Az eredményt írja a képernyőre 3 tizedesjegy pontossággal.

Mentés: elipkup

Feladat 0327

Írjon programot, amely egy halmaz elemeiből vett, adott nagyságú elemszámmal meghatározza hány kombináció lehetséges, ha nem lehet ismétlődés.

A példa kedvéért adott a következő halmaz:

A = {a, b, c}

A lehetséges kombinációk:

ab  ac  bc

Vagyis három kombináció lehetséges.

A számítás képlete a következő:

{n!} / { k!* (n­k)! }

A feladat, hogy kérje a halmaz elemeinek számát, a kiválasztott elemek számát, majd írja a képernyőre hány kombináció lehetséges.

Mentés: kombi

Feladat 0328

Egy hasáb térfogatának számítása a következő képlettel lehetséges:

V=a b c

137

Kérje be három hasáb adatait. Számítsa ki a hasábok térfogatát, majd írja a képernyőre a térfogatokat és azok összegét.

Feladat 0329

Egy gömb térfogatának és felszínének számítása a következő képlettel lehetséges:

V={4 r^3 pi }/3

A=4 pi r^2

Kérje be egy gömb átmérőjét, majd számítsa ki a gömb térfogatát és felszínét.

Feladat 0330

Írjon programot, amely kamatos kamatot számít. A feladat kiíratni a tényleges kamatot tetszőleges évre. Bekéri a betétet a „betet” nevű változóba. Bekéri a betét évenkénti tőkésítésének számát, amit a tokesites_szam változóban tárolunk. Bekéri a névleges kamatot százalékban, amit a nevleges váltózóban tárolunk. Bekéri hány éven keresztül szeretné tőkésíteni, az „ev” változóba.

Tényleges = ((1 + névleges / {100~tökésítésekSzáma}) ^ {év~tökésítésekSzáma }­1) ~betét

A program a következőket írja ki:

Kamat számítás

Betét: (bekérés)

Névleges kamatot (%): (bekérés)

Évenkénti tőkésítések száma: (bekérés)

Évek száma: (bekérés)

Tényleges éves kamat: (A választ a gép adja)

Mentés: kamatos

138

Feladat 0331

Írjon programot, amely kamatos kamatot számít, éven belüli többszöri tőkésítési lehetőséggel. A feladat a jövőérték kiszámítása. Bekéri a betét összegét „betet” nevű változóba. Bekéri a hány éven keresztül tőkésítünk, az „ev” változóba. Bekéri az éves kamatot százalékban, amit a kamat váltózóban tárolunk. Bekéri az évenkénti tőkésítések számát, a „tokesitesekSzama” változóba.

Jövőérték = betét ~ (1 +{ kamat / {100 ~ tőkésítésekSzáma}}) ^ {év ~ tőkésítésekSzáma }

A program a következőket írja ki:

Kamat számítás

Betét: (bekérés)

Éves kamat (%): (bekérés)

Évenkénti tőkésítések száma: (bekérés)

Évek száma: (bekérés)

Jövőérték: (A választ a gép adja)

Az éves kamat például 5. A jövő érték, az az érték, amit teljes futamidő végén kapunk.

Mentés: kamatosul

Feladat 0332

A 150 éve ismert BMI (testtömegindex) képlet nagy magasságkülönbségek esetén torzít. Az Oxford Egyetem matematikusai, ezért egy újabb képlettel álltak elő, a testtömegindex számításához, amely a következő:

{1,3 x testtömeg (kilogramm)} / {magasság (méter)}^{2,5}

Pubertáskorban számolhatunk 2,5 hatvány helyett, 2 hatvánnyal. Csecsemőkorban pedig 3 hatványával.

Írjon programot, amely bekéri a testtömeget és a magasságot, majd a képlet alapján kiírja 

139

testtömegindexet.

index  megállapítás

16 alatt  súlyos soványság

16 és 16,9 között  mérsékelt soványság

17 és 18,49 között  enyhe sovány

18,5 és 24,9 között  egészséges

25 és 29,9 között  túlsúlyos

30 és 34,9 között  I. fokú elhízás

35 és 39,9 között  II. fokú elhízás

40 felett  III. fokú súlyos elhízás

50 éves korban és sportolók esetén (nagyobb izomtömeg miatt) 27­ig még egészséges.

Szelekciós tevékenység

Feladat 0401

Írjon programot, amely bekér két számot, majd kiírja a nagyobbat.

Bemenő adatok: Két szám:

Szám1: 

Szám2:

Kimenő adatok:

Az első szám nagyobb.

A második szám nagyobb.

Mentés: nagyobb

Feladat 0402

140

Írjon programot, amely bekér egy számot, majd eldönti, hogy negatív szám­e. Ha nem, akkor írja ki, hogy nulla vagy pozitív.

Mentés: negate

Feladat 0403

Írjon programot, amely bekér egy számot, majd kiírja, hogy nagyobb vagy kisebb mint 50.

Mentés: otvennel

Feladat 0404

Írjon programot, amely beolvas a billentyűzetről két számot: a­t és b­t! Ha b nagyobb, akkor megcseréli a két változó értékét! Írja ki a megcserélt értékeket.

Mentés: nagyobcsere

Feladat 0405

Kérjünk be két számot! Döntsük el, hogy a második osztója­e az elsőnek!

Mentés: osztoja

Feladat 0406

    A program először saját nevét írja a képernyőre.

    A neve után írassa a képernyőre mit csinál a program.

    Kérjük be egy háromszög oldalait.

    A program ellenőrizze, hogy a háromszög szerkeszthető­e.

    Ha a háromszög nem szerkeszthető, írja ki, hogy „nem háromszög”

    Ha a háromszög szerkeszthető számítsuk ki a kerületét, írjuk az eredményt a képernyőre.

Mentés: haromszog4

141

Feladat 0407

    A program először saját nevét írja a képernyőre.

    A neve után írassa a képernyőre mit csinál a program.

    Kérjük be egy háromszög oldalait.

    A program ellenőrizze, hogy a háromszög szerkeszthető­e.

    Ha a háromszög nem szerkeszthető, írja ki, hogy „nem háromszög”

    Ha a háromszög szerkeszthető számítsuk ki a területét, írjuk az eredményt a képernyőre.

Mentés: haromszog4

Feladat 0408

    A program először saját nevét írja a képernyőre.

    A neve után írassa ki, mit csinál a program.

    Írjon programot, amely bekéri egy háromszög három oldalát, és eldönti, hogy a háromszög szerkeszhető­e!

    A program vizsgálja meg, hogy a háromszög deréköszögű­e, erről tájékoztassa a felhasználót!

Mentés: haromderek

Feladat 0409

Olvassunk be egy valós számot, és döntsük el, hogy szigorúan 10 és 20 közé esik­e!

Mentés: tizhuszkozott

Feladat 0410

Olvassunk be két számot, és a nagyobbat osszuk el a kisebbel!

Mentés: osztas

Feladat 0411

142

Adott három valós szám. Határozzuk meg közölük a legynagyobbat! A három számot ne kérjükbe, egyszerűen adjuk meg.

Mentés: legnagyobb

Feladat 0412

Adott három valós szám. Határozzuk meg közölük a legynagyobbat! A három számot kérjük be a felhasználóktól!

Mentés: legnagyobb2

Feladat 0413

Írjon programot, amely beolvas egy egész számot, majd eldönti, hogy a szám osztható­e 3­mal!

Mentés: oszthato3mal

Feladat 0414

Írjon programot, amely beolvas egy egész számot, majd eldönti, hogy a szám osztható­e 2­vel és 3­mal!

Mentés: oszthato23mal

Feladat 0415

Írjon programot, amely beolvas egy egész számot, majd megadja, hogy a szám osztható­e 2­vel, vagy osztható 3­mal, vagy osztható 2­vel és hárommal is vagy 2­vel és hárommal sem osztható!

Mentés: oszthatosag

Feladat 0416

Írjon programot, amely kiírja egy szám 2­vel vett maradékát! Ha a nincs maradék írjuk ki, hogy „Nincs maradék”. Ha van maradék akkor a maradékot.

143

Mentés: osztas2vel

Feladat 0417

Írjon programot, amely kiírja egy szám 3­mal vett maradékát! Ha nincs maradék írjuk ki a következő szöveget:

Nincs maradék

Ha van írjuk ki a maradék értékét a „Maradék” szó után.

Mentés: osztas2vel

Feladat 0418

Írjon programot, amely kiírja egy szám 3­mal vett hányadosát! Ha a hányados nagyobb mint 2, írjuk ki a „Nagyobb” szöveget.

Mentés: osztas3hanyados

Feladat 0419

Írjon programot, amely beolvassa az osztandót, az osztót majd kiírja a hányadost és a maradékot! Valós számokkal dolgozzon!

Írja ki szövegesen, hogy volt­e maradék.

Mentés: osztasvalos

Feladat 0420

Írjon programot, amely beolvassa az osztandót, az osztót majd kiírja a hányadost és a maradékot! Egész számokkal dolgozzon! Ha a maradék nagyobb mint 1 írja szövegesen a képernyőre, másként a szövegesen az adott értéket.

144

Mentés: osztasegesz

Feladat 0421

Írjunk programot, amely beolvassa egy alkán vegyületben található szénatomok számát, majd kiírja, hogy hány H atom van a vegyületben! Az Alkánok általános képlete:

C_n H_{2n+2}

Ha a szénatomok száma meghaladja a 10­et írja a képernyőre a „Sok” szót, egyébként a normál szót.

Mentés: alkan

Feladat 0422

Van 10000 Ft­od. Elmész bevásárolni. Lehet kapni lisztet (300 Ft/kg), mézet (1000 Ft/kg), tej (200 Ft/l). Aprogram olvassa be, hogy miből mennyit akarsz venni, és írja ki a fizetendő összeget. Ha több lenne a végösszeg annál, mint amennyi nálad van, akkor írja ki a program, hogy nincs elég pénzed.

Mentés: vasarlas

Feladat 0423

Írjon programot, amely bekéri 3 ember IQ­ját, majd kiírja, hogy kinek nagyobb 130­nál.

Mentés: iqszaz

Feladat 0424

A szacharóz (étkezési cukor: nádcukor, répacukor, juharcukor) képlete a következő:

C_12 H_22 O_11

Kérje be egy molekula szén, hidrogén és oxigén tartalmát. Írj ki, hogy lehet­e szacharóz.

145

Mentés: szacharoz

Feladat 0425

A glükóz (szőlőcukor) képlete a következő:

C_6 H_12 O_6

Kérje be egy molekula szén, hidrogén és oxigén tartalmát. Írj ki, hogy lehet­e glükóz.

Feladat 0426

A glükóz (szőlőcukor) képlete a következő:

C_6 H_12 O_6

A szacharóz (étkezési cukor: nádcukor, répacukor, juharcukor) képlete a következő:

C_12 H_22 O_11

Írjon programot, amely bekéri egy molekula szén, hidrogén és oxigén tartalmát. A program írja ki, hogy lehetséges­e, hogy glükóz, szacharóz vagy inkább más molekula.

Mentés: vizscu

Feladat 0427

Kérje be egy ember testtömegét (kg) és testmagasságát (méter). Számolja ki a testtömegindexét, ha a képlet a következő:

testtömegindex = tömeg / magasság^2

Testtömegindex (kg/m²)  Testsúlyosztályozás

< 16  súlyos soványság

16 – 16,99  mérsékelt soványság

146

17 – 18,49  enyhe soványság

18,5 – 24,99  normális testsúly

25 – 29,99  túlsúlyos

30 – 34,99  I. fokú elhízás

35 – 39,99  II. fokú elhízás

≥ 40  III. fokú (súlyos) elhízás

A táblázat alapján, írassa ki, hogy a megfelelő testsúlyosztályt.

Mentés: testfel

Írjon programot, amely bekér egy számot, majd eldönti, hogy negatív, pozitív szám vagy nulla.

Mentés: elojel

Megjegyzés: Figyelem! Ez a számítás nem veszi figyelembe a testmagasságot, ezért nem ad jó eredményt. Alacsonyabb embereknél soványságot, magasabb embereknél testsúlyfelesleget mutathat.

Forrás: www.telegraph.co.uk

Mérjél helyette testzsírszázalékot. Például itt: http://szit.hu/tzs/

Feladat 0428

Kérjen be négy számot, majd rendezve, írassa ki a képernyőre. A program először saját nevét írja a képernyőre, legyen beszédes, írja ki mit várunk.

Mentés: negyszam

Feladat 0429

Kérje be két háromszög 3 oldalát. Számítsa ki a területét, majd írja ki melyik nagyobb.

147

Mentés: harnagy

Feladat 0430

Kérje be egy dolgozó egyéves bruttó jövedelmét. A következő adatokat kell bekérnie:

    Név

    Alapbér

    Juttatások

    Nyelvi pótlék

Ha az éves jövedelme meghaladja az 1 000 000 ­ Ft­ot, akkor 36% adót kell fizetnie. Ha nem, akkor 16%­ot. Számítsa ki, írja a képernyőre mennyi adót kell fizetnie a dolgozónak.

Mentés: adofiz

Feladat 0431

A program első sora saját nevét írja a képernyőre.

Majd bekeretezve a „Jövedelem” felirat következzen középre igazítva.

Konzolos felületen (GUI­val legyen valamiféle szegély ) ez így nézzen ki:

*******************************

*                             *

*         Jövedelem           *

*                             *

*******************************

Számítsuk ki egy dolgozó havai járandóságát. Bemenő adatok:

148

    név

    ledolgozott órák

    óradíj

    levonás mértéke %­osan

    pótlék egész hónapra, ha van

A ledolgozott órák és az óradíj szorzata, plusz a pótlék havonta adja a dolgozó bruttó bevételét. Ebből elvesszük a levonásokat, majd megkapjuk az utalandó összeget, azaz a nettó munkabért. Írassuk a képernyőre a bruttó és nettó fizetést.

Ha a havi nettó jövedelem kevesebb mint 223000, akkor családipótlékra jogosult a dolgozó. A program írja ki, hogy jogosult­e a családi pótlékra.

Mentés: fize

Feladat 0432

Írjon programot, amely először saját nevét írja a képernyőre. A program ez után kérjen be két hőmérsékletadatot. A bemenő adatok valós számok. Számítsa ki a két adat különbségét, majd írassa a képernyőre a „Különbség” szó után, 3 tizedesjegy pontossággal. A program következő sora írja ki a nagyobb hőmérsékletadatot, szintén 3 tizedesjegy pontossággal.

Mentés: homer

Feladat 0433

Adott egy egyenáramú elektromos hálózat. Ki kell számolnunk a feszültséget.

Bemenő adat lehet

    P = teljesítmény

    R = ellenállás

vagy:

149

    P = teljesítmény

    I = áram

Kimenő adat:

    U = feszültség

Ha bemenő adat a teljesítmény és az ellenállás akkor a képlet: U = sqrt{P*R}

Ha bemenő adat a teljesítmény és az áram akkor a képlet: U = P/I

Kérdezzük meg a felhasználót, melyik két adatból szeretné kiszámítani a feszültséget. Kérjük be a két adatot, majd számítsuk ki a feszültséget.

A program első sora a saját nevüket írja a képernyőre.

Mentés: fesz

Feladat 0434

Kérje be egy elektronikai eszköz üzemi hőmérsékletének alsó és felső határát. Ha az alsó határ < 25 °C akkor és a felső határ > 85 °C, akkor katonai célokra megfelel az eszköz.

A program írja ki, hogy katonai célokra megfelel­e.

A képernyő első sorában azonban saját nevét és osztályát írja a képernyőre.

Mentés: katonai

Feladat 0435

A program először saját nevét írja a képernyőre. A következő sorba a programkészítés dátumát írja a 

150

képernyőre.

Kérjen be egy kódszámot. Ha a bekért kódszám 2248, 1834 vagy 3823, akkor írjon tájékoztató szöveget, hogy a bejutott a rendszerbe Ellenkező esetben írja ki: „Sikertelen azonosítás”

Mentés: kod

Feladat 0436

Egy repülőtéren dolgozunk. Kérjünk be időjárás adatokat.

    Kérjük be a szélsebességet (km/óra).

    Kérjük be az 1­s jelű kifutóhoz képest milyen szögben fúj a szél (szélirány).

    Kérjük be felhősödés arányszámát.

Ha a szélsebessége nagyobb mint 50 km/óra és 1­s kifutóhoz képest az eltérés nagyobb mint 30%, akkor írjuk ki, hogy nem ajánlott a felszállás.

Ha szél sebessége nagyobb mint 100 km/óra, a széliránytól függetlenül írjuk ki, hogy Tiltott felszállás.

Ha a felhősödési arányszám nagyobb mint 45, akkor írassuk ki, hogy tiltott felszállás.

Ellenőrizzük a bemenő adatokat.

    A szél sebessége nem lehet negatív érték és nagyobb mint 500 km/óra

    A szélirány 0 és 180 fok közötti érték lehet

    A felhősödési arányszám 1 és 100 közötti szám lehet. Ha felhasználó nem ebbe az intervallumba eső számot ír, figyelmeztessük.

Feladat 0437

Önnek ki kell számolnia, hogy az adott félévben mennyiségileg és minőségileg hogyan teljesített az 

151

iskolában, az elvárt szinthez képest. Ehhez szüksége van az elért kreditpontokra és az osztályzatok átlagára.

Egy félévben az elvárt kredit nagyság: 30. Ennél persze többet is teljesíthet. Ha több tantárgy van, akkor könnyen 6.0 fölé is mehet. A sok tantárgy elvégzése azonban jó eredménnyel persze fizikailag képtelenség.

Az elért kreditpontok és az osztályzatok átlagának szorzata, elosztva az elvárt kreditpontokkal megadja az ösztöndíjindext.

Ösztöndíjindex képlete ezek után:

ösztöndíjindex={elértKreditpont*osztályzat}/30

Kérje be az elért kreditpontokat a félévben, kérje be az osztályzatainak átlagát, majd számoltassa ki az ösztöndíjt átlagot és írja a képernyőre.

Ha az index nagyobb mint 5,8 azaz öt­egész­nyolctized, akkor írja a képernyőre, hogy jó eredmény. Ha kisebb, írja ki, hogy gyenge eredmény.

Mentés: osztondij

Feladat 0438

A 150 éve ismert BMI (testtömegindex) képlet nagy magasságkülönbségek esetén torzít. Az Oxford Egyetem matematikusai, ezért egy újabb képlettel álltak elő, a testtömegindex számításához, amely a következő:

{1,3 x testtömeg (kilogramm)} / {magasság (méter)}^{2,5}

Pubertáskorban számolhatunk 2,5 hatvány helyett, 2 hatvánnyal. Csecsemőkorban pedig 3 hatványával.

Írjon programot, amely bekéri a testtömeget és a magasságot, majd a képlet alapján kiírja testtömegindexet.

152

index  megállapítás

16 alatt  súlyos soványság

16 és 16,9 között  mérsékelt soványság

17 és 18,49 között  enyhe sovány

18,5 és 24,9 között  egészséges

25 és 29,9 között  túlsúlyos

30 és 34,9 között  I. fokú elhízás

35 és 39,9 között  II. fokú elhízás

40 felett  III. fokú súlyos elhízás

50 éves korban és sportolók esetén (nagyobb izomtömeg miatt) 27­ig még egészséges.

A program, a táblázat alapján írja ki a megfelelő megállapítást. A program, vegye figyelembe, hogy csecsemő vagy pubertáskorról, 50 év feletti személyről vagy sportolóról van­e szó.

Iterációs tevékenység

Feladat 0701

Készítsen programot amely összeadja a bekért számokat 0 végjelig!

Mentés: zerovegjel

Feladat 0702

Kérjen be egy számot. Ha 50­nél kisebb kérje újra.

Mentés: nagyobb50

Feladat 0703

Írassuk ki a számokat 1­től – 50­ig.

Mentés: szamokotvenig

153

Feladat 0704

Írassuk ki 5 többszöröseit, 50­ig.

Mentés: ottobbszoros

Feladat 0705

Írjunk programot, amely előállítja az első 10 egész szám négyzetét!

Mentés: negyzet

Feladat 0706

Írjunk programot, amely előállítja az első 10 páros számot!

Mentés: parosszam

Feladat 0707

Írjon programot, amely kiírja 5 többszöröseit 100­tól – 200­ig.

Mentés: otoszt

Feladat 0708

Írjon programot, amely bekér számokat 0 végjelig, majd kiírja azok átlagát.

Mentés: beatlag

Feladat 0709

Írjon programot, amely bekér egy számot, majd kiírja a faktoriálisát.

Mentés: nfakt

154

Feladat 0710

Írjon programot, amely bekér számokat 0 végjelig, majd kiírja a legkisebbet és a legnagyobbat.

Mentés: kisnagyn

Feladat 0711

Írjon programot, amely bekéri n­t, majd bekérünk n darab számot. A program írja ki a számok összegét.

Mentés: nbesum

Feladat 0712

Írjon programot, amely bekér számokat 0 végjelig, minden számnak írja ki a négyzetgyökét.

Mentés: gyukokz

Feladat 0713

Írjon programot, amely kiírja az ASCII karaktereket a képernyőre. Az egyes jeleket egymás mellé írja a képernyőre, egy sorba amennyi kifér.

Mentés: ascki

Feladat 0714

Írjon programot, amely kiírja az ASCII karaktereket és a hozzájuk tartozó kódokat. Egy sorba annyi ASCII karaktert és kódját írjon, amennyi csak elfér.

Mentés: asckodki

Feladat 0715

Írassa ki az angol ábécé nagybetűit. A program első sora saját nevét, osztályát és a mai dátumot tartalmazza.

155

Mentés: abcnagy

Feladat 0716

Írjon programot, amely az alábbi szabályos fordított piramist rajzolja a képernyőre:

@ @ @ @ @ @ @ @ @

  @ @ @ @ @ @ @ 

    @ @ @ @ @

      @ @ @

        @

Ha a piramist nem látja szabályosnak, akkor másolja egy Notepad2, Scite, SWScite vagy egy olyan szövegszerkesztőbe, amelyben olyan fontkészlet van beállítva, amelynél minden karakter egyforma széles(Mono típusú fontok).

Csak két ciklus használhat maximum! A „@” karakter kiíratására csak egy kiírató utasítást használhat. Nem használhat kurzorpozíciót beállító utasítást.

Mentés: piralj

Feladat 0717

Írjon programot, amely bemenetként karaktereket vár. Mindaddig fogadja el a bevitelt amíg a bevitt karakter az angol ábécé betűje. A program írja ki, hány kis és hány nagybetű volt.

Mentés: karkisnagy

Feladat 0718

Írjon programot amely bekér egy páratlan számot. A következő sorba ennyi „@” karaktert ír ki, de minden karakter után legyen egy üres hely. Az utána következő sorba 2­el kevesebb „@” karaktert írjon,de két karakter hellyel beljebb írja. Minden ezt következő sorba ugyanígy 2­el kevesebbet írjon ki. Az utolsó sorba csak egyetlen karakter legyen. Például 9 beírt szám esetén így néz ki a kiírt alakzat:

156

@ @ @ @ @ @ @ @ @

  @ @ @ @ @ @ @ 

    @ @ @ @ @

      @ @ @

        @

A megoldásnál a páratlan szám bekérésre használhat egy ciklust, majd kettő ciklust a fordított piramis kiíratására.

Mentés: piramid

Feladat 0719

A program első sora a saját nevét és vesszővel tagolva az aktuális évszámot írja a képernyőre.

Írjon programot, amely kiírja a számokat 1­től 100­ig. Egy sorba 10 számot írjon ki jól láthatóan elkülönítve.

Mentés: tizzel

Feladat 0730

A program első sora a saját nevét és vesszővel tagolva az aktuális évszámot írja a képernyőre.

Írjon programot, amely bekéri a számokat 0 végjelig, miközben összegezi azokat, ha azok nagyobbak mint 49. Ha szám 49 vagy kisebb, akkor írjon hibaüzenet a felhasználónak.

Mentés: otvenossz

Feladat 0731

A program első sora a saját nevét és vesszővel tagolva az aktuális évszámot (készítés ideje) írja a képernyőre.

157

A program második sorában ciklusutasítással, egyetlen „*” karakter kiíratásával húzzon egy vízszintes vonalat. A csillagokból álló vonal 80 karakter széles legyen, és minden 5­dik csillag helyén egy „­” kötőjelálljon.

****­****­****­****­****­****­****­****­****­****­****­****­****­****­****­****­

Mentés: vonalas

Feladat 0732

Írjon programot, amely bekéri egy kifizetendő fizetés összegét, majd kiszámolja hogyan lehet a legkevesebb címletben kifizetni.

158