Kifejezésorientált nyelv...18 Objektum orientált nyelv...18 Párhuzamos programnyelv...18 Programozási alapfogalmak...19 Algoritmus...19 Program

Tartalomjegyzék Programozás története.............................................................................................................................................6 Programozási nyelvek generációi............................................................................................................................7 Első generációs programozási nyelvek...............................................................................................................7 Második generációs programozási nyelvek........................................................................................................8 FORTRAN.....................................................................................................................................................9 ALGOL..........................................................................................................................................................9 COBOL..........................................................................................................................................................9 BASIC..........................................................................................................................................................10 RPG..............................................................................................................................................................11 Harmadik generációs programozási nyelvek....................................................................................................11 PL/1 (Programming Language I.)................................................................................................................11 APL (A Programming Language)................................................................................................................12 PASCAL.......................................................................................................................................................12 MODULA-2.................................................................................................................................................12 ADA.............................................................................................................................................................13 C nyelv.........................................................................................................................................................13 Objektum-orientált programozási nyelvek...................................................................................................13 Tiszta objektum-orientált nyelvek................................................................................................................14 SmallTalk.................................................................................................................................................14 Eiffel........................................................................................................................................................14 Vegyes nyelvek............................................................................................................................................14 Turbo Pascal............................................................................................................................................14 Borland C++............................................................................................................................................14 Specializált programozási nyelvek...............................................................................................................14 Rendszer- és fordítóprogramok fejlesztése.............................................................................................15 Formulakezelő nyelvek...........................................................................................................................15 Szimbólum-feldolgozó nyelvek..............................................................................................................15 Szimulációs nyelvek................................................................................................................................15 Adatbázis-kezelő nyelvek.......................................................................................................................15 Kiterjeszthető programnyelvek...............................................................................................................15 Negyedik generációs programozási nyelvek....................................................................................................15 Lekérdező nyelvek.......................................................................................................................................15 Programgenerátorok.....................................................................................................................................16 Egyéb 4 GL nyelvek.....................................................................................................................................16 Programozási nyelvek osztályzása........................................................................................................................16 Felhasználói kör szerint....................................................................................................................................16 Amatőr nyelvek............................................................................................................................................16 Professzionális nyelvek................................................................................................................................16 Számítási modell szerint...................................................................................................................................16 Neumann elvű nyelvek.................................................................................................................................16 Automata elvű nyelvek................................................................................................................................16 Funkcionális nyelvek...................................................................................................................................17 Logikai nyelvek............................................................................................................................................17 Felhasználói közelség szerint...........................................................................................................................17 Gépi kód.......................................................................................................................................................17 Alacsonyszintű nyelv...................................................................................................................................18 Magasszintű nyelvek....................................................................................................................................18 Egyéb osztályozások.........................................................................................................................................18 "Compiler" illetve "Interpreter" nyelvek.....................................................................................................18 Procedurális illetve nem procedurális nyelvek............................................................................................18 Deklaratív nyelv...........................................................................................................................................18 Utasításorientált nyelv..................................................................................................................................18 1

Kifejezésorientált nyelv...............................................................................................................................18 Objektum orientált nyelv.............................................................................................................................18 Párhuzamos programnyelv...........................................................................................................................18 Programozási alapfogalmak..................................................................................................................................19 Algoritmus........................................................................................................................................................19 Program.............................................................................................................................................................19 Programozó.......................................................................................................................................................19 Programozás.....................................................................................................................................................19 Forrásprogram...................................................................................................................................................19 Programozási nyelv..........................................................................................................................................19 A programozás szintjei.....................................................................................................................................19 Szintaxis és szemantika leírás...........................................................................................................................20 Szintaxisleíró eszközök....................................................................................................................................20 Fordítás és értelmezés.......................................................................................................................................20 Programkészítés és futtatás menete..................................................................................................................20 Byte-kód fordítás..............................................................................................................................................21 Case-sensitive, case-insensitive nyelvek..........................................................................................................22 Megjegyzések...................................................................................................................................................22 Kulcsszavak......................................................................................................................................................22 Programstruktúrák.................................................................................................................................................22 Program.............................................................................................................................................................22 Programcsomag................................................................................................................................................22 Párhuzamos folyamat (taszk)............................................................................................................................22 Fordítási egység................................................................................................................................................22 Export-, importlisták.........................................................................................................................................22 Programegység.................................................................................................................................................22 Eljárás, függvény, operátor..........................................................................................................................23 Deklarációs rész, törzs.................................................................................................................................23 Blokkstruktúra..................................................................................................................................................23 Programkészítés elvei............................................................................................................................................23 Stratégiai elvek.................................................................................................................................................23 Taktikai elvek....................................................................................................................................................24 Technológiai elvek............................................................................................................................................24 Technikai elvek.................................................................................................................................................25 Esztétikai-ergonómiai elvek.............................................................................................................................25 Programkészítés lépései.........................................................................................................................................27 Feladat meghatározása (specifikáció)...............................................................................................................27 Algoritmuskészítés...........................................................................................................................................28 Algoritmus...................................................................................................................................................28 Algoritmussal szemben támasztott követelmények.....................................................................................28 Algoritmikus elemek....................................................................................................................................28 Program...................................................................................................................................................29 Értékadó utasítás.....................................................................................................................................29 Beolvasó utasítás.....................................................................................................................................29 Kiíró utasítás...........................................................................................................................................29 Megjegyzések..........................................................................................................................................29 Utasításblokk - szekvencia......................................................................................................................29 Elágazás - szelekció................................................................................................................................30 Ciklus - iteráció.......................................................................................................................................30 Eljárás, függvények, operátor..................................................................................................................31 Műveletek csoportosítása.............................................................................................................................32 Algoritmus leíróeszközök............................................................................................................................32 Folyamatábra (blokkdiagram).................................................................................................................32 Struktogram.............................................................................................................................................35 2

Jackson diagram......................................................................................................................................36 Mondatszerű leírás..................................................................................................................................37 Kódolás.............................................................................................................................................................38 Tesztelés, hibakeresés, javítás...........................................................................................................................38 Hibaüzenetek értelmezése............................................................................................................................41 Hibakeresés (Bedugolás)..................................................................................................................................41 Bedugolás technikák....................................................................................................................................42 Kivételkezelés...................................................................................................................................................42 Hatékonyságvizsgálat.......................................................................................................................................42 Hatékonyság fogalma...................................................................................................................................42 Hatékonyságvizsgálat szempontjai..............................................................................................................43 Hatékonyságvizsgálat szintjei......................................................................................................................43 Globális hatékonyság...................................................................................................................................43 Lokális hatékonyság.....................................................................................................................................43 Algoritmus hatékonysága.............................................................................................................................43 Programkód hatékonysága...........................................................................................................................43 Dokumentálás...................................................................................................................................................43 Dokumentáció fajtái.....................................................................................................................................44 Dokumentáció tulajdonságai........................................................................................................................45 Dokumentáció általános alakja....................................................................................................................46 Példa dokumentációra..................................................................................................................................48 Strukturált program...............................................................................................................................................49 Típusok..................................................................................................................................................................50 Adatok, adatszerkezetek........................................................................................................................................51 Változó..............................................................................................................................................................51 Konstans...........................................................................................................................................................51 Definíció, deklaráció.........................................................................................................................................51 Azonosító..........................................................................................................................................................51 Védett azonosítók.............................................................................................................................................52 Azonosítók átlapolása (túlterhelés)...................................................................................................................52 Hozzáférési jog.................................................................................................................................................52 Kezdőérték........................................................................................................................................................52 Hatáskör............................................................................................................................................................52 Láthatóság.........................................................................................................................................................52 Élettartam..........................................................................................................................................................52 Típus.................................................................................................................................................................52 Értékhalmaz......................................................................................................................................................52 Adat csoportosítása................................................................................................................................................52 Egész típus........................................................................................................................................................53 Valós típus.........................................................................................................................................................54 Logikai típus.....................................................................................................................................................54 Karaktertípus.....................................................................................................................................................54 Felsorolástípus..................................................................................................................................................55 (Rész)Intervallumtípus.....................................................................................................................................55 Valós résztípus..................................................................................................................................................56 Rekord...............................................................................................................................................................56 Vektor/Tömb.....................................................................................................................................................56 Mátrix...............................................................................................................................................................57 Halmaz..............................................................................................................................................................57 Szöveg...............................................................................................................................................................57 Sorozat..............................................................................................................................................................58 Számábrázolások...................................................................................................................................................59 Számábrázolás..................................................................................................................................................59 Fixpontos ábrázolás..........................................................................................................................................59 3

Lebegőpontos ábrázolás....................................................................................................................................60 Programozási tételek.............................................................................................................................................61 Programozási tétel fogalma..............................................................................................................................61 Tételek megfogalmazásának elemei.................................................................................................................61 Tételek alkalmazásának lépései........................................................................................................................61 Tételek csoportosítása.......................................................................................................................................61 Egy sorozathoz egy értéket rendelő tételek......................................................................................................61 Összegzés tétele...........................................................................................................................................61 Megszámlálás tétele.....................................................................................................................................62 Eldöntés tétele..............................................................................................................................................62 Kiválasztás tétele..........................................................................................................................................63 Egy sorozathoz egy sorozatot rendelő tétele....................................................................................................63 Másolás, transzformálás tétele.....................................................................................................................63 Kiválogatás tétele.........................................................................................................................................64 Egy sorozathoz több sorozatot rendelő tétel.....................................................................................................64 Szétválogatás tétele......................................................................................................................................64 Több sorozathoz egy sorozatot rendelő tételek................................................................................................65 Metszetképzés tétele....................................................................................................................................65 Unióképzés tétele.........................................................................................................................................66 Összefuttatás tétele (UNIÓ).........................................................................................................................66 Összefuttatás tétele (METSZET).................................................................................................................68 Keresési tételek......................................................................................................................................................68 Lineáris keresés tétele.......................................................................................................................................68 Logaritmikus keresés tétele..............................................................................................................................69 Rendezések************....................................................................................................................................69 Rekurzió******....................................................................................................................................................72 Objektumorientált programozás............................................................................................................................73 Objektumorientált programozás fogalma.........................................................................................................73 Objektumorientált program jellemzői, alapfogalmak.......................................................................................74 Futóverseny példa.............................................................................................................................................77 Objektum-orientált tervezés..............................................................................................................................78 Ábrázolás osztálydiagramon.............................................................................................................................78 Objektumosztály definiálása, objektumok létrehozása.....................................................................................78 Linux alapok..........................................................................................................................................................79 Python....................................................................................................................................................................83 Első lépések......................................................................................................................................................83 Számolás Pythonban.........................................................................................................................................83 Adatok és változók...........................................................................................................................................83 Változónevek és foglalt szavak........................................................................................................................83 Értékadás, hozzárendelés.................................................................................................................................84 Változó értékének a kiírása...............................................................................................................................84 Változók típusadása..........................................................................................................................................85 Operátorok és kifejezések.................................................................................................................................85 A műveletek prioritása......................................................................................................................................85 GUI tananyag***************..........................................................................................................................86 Programok feladatok**************.................................................................................................................86 Specifikáció készítés.........................................................................................................................................86 A specifikáció során használható szimbólumok..........................................................................................86 Algoritmus készítés..........................................................................................................................................87 Egyszerű konzol feladatok................................................................................................................................91 Programok.........................................................................................................................................................91 Beolvasás, kiíratás............................................................................................................................................91 Típuskonverzió.................................................................................................................................................91 Egyszerű műveletek..........................................................................................................................................91 4

Elágazások........................................................................................................................................................91 Ciklusok............................................................................................................................................................91 Vegyes feladatok...............................................................................................................................................91 Menü a programban..........................................................................................................................................91 Eljárást tartalmazó............................................................................................................................................91 Függvényt tartalmazó.......................................................................................................................................91 Összetett adattípusok........................................................................................................................................91 Tömb.................................................................................................................................................................91 Mátrix...............................................................................................................................................................91 Rekord...............................................................................................................................................................91 Tételek..............................................................................................................................................................91 Keresési tételek.................................................................................................................................................91 Rendezési tételek..............................................................................................................................................91 Műveletek fájlokkal..........................................................................................................................................91 GUI programok.................................................................................................................................................95 OOP 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 diagramok ké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 egyetlen mű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 a sokoldalú Analytical Engine fejlesztésének kedvéért. Ez a gép a modern számítógép alapelemeit tartalmazta, és megalapozta 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 lyuk volt, 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 a Mark II Aiken­féle átkapcsoló kalkulátoron dolgozott. A gépekkel akkortájt folyamatosan probléma volt, és az egyik ilyen kellemetlen eset során, 1945. szeptember 9­én az egyik technikus felfedezte, hogy egy moly került a gé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ő programnyelv jö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 nyelvek iránti érdeklődés egyre nő, és ezt az érdeklődést az információk, ötletek és alkalmazások akadálytalan cseréje mé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őt vett 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ése volt   az   igény,   szerettek   volna   számítógépen   ennél   összetettebb   feladatokat   is   megoldani.   A   nehézkes programozási módszerek és a gazdasági élet – amely a vállalatok döntéseit alapvetően befolyásolja – dinamikus változásai nem igazán voltak összhangban egymással. A hosszú, nehéz munkával készített programok igen gyorsan   elavultak,   és   máris   lehetett   hozzákezdeni   a   következő   írásához.   Tehát   új,   gyorsabb,   egyszerűbb programfejlesztési módszerekre volt szükség. Ebben az időben jelentek meg az első magas szintű programozási nyelvek, amelyek 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ár nemcsak a problémamegoldás egyszerűsítése volt a cél, a programok szerkezeti felépítése, az emberi logika minél   hatékonyabb   kihasználása   lett  az   újabb  fejlesztések   irányvonala.   Megjelentek   az   általános   célú   és  a specializált programozási nyelvek, a ’70­es évek elején új módszerként jelentkezett a strukturált programozás. A ’90­es évekre komoly teret nyertek a számítógépek az élet valamennyi területén. Komoly igény volt arra, hogy a szoftverpiac követni tudja az egyre szélesebb körű igényeket, tehát új eszközökre volt szükség, amelyek segítségével   a   programozók   gyorsan   tudnak   hatékony   és   megbízható   alkalmazásokat   írni.   A   gyors programfejlesztés   céljait   egy   az   emberi   gondolkodáshoz   közel   álló   módszer   teszi   lehetővé,   ugyanakkor   a programnak nem szabad hatékonyságát elveszítenie, tehát minél elemibb egységekből kell felépíteni. Mindkét igényt kielégítette az objektum­orientált programozási technika, amely a valódi tárgyakhoz hasonlóan képes kezelni   a   rendszer   absztrakt   elemeit.   Azaz   a   programozónak   rendelkezésére   állnak   az   előre   definiált programelemek, amelyekből összeállíthatja a működőképes programot. Annak érdekében, hogy a problémának leginkább megfelelő alkalmazást lehessen előállítani, az egyes elemek tulajdonságait a programozó tetszése szerint 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ár nemcsak 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, sokkal fontosabbá válik a mivel kérdése. A legfejlettebb programozási rendszerek már automatikusan generálják a kódot, ezzel a programozónak már nem kell foglalkoznia. Ezek a rendszerek sok esetben nemcsak a program helyességét  ellenőrzik,  hanem   a  problémamegoldás hatékonyságát   is.  Ezáltal   a programozónak  kizárólag  a megoldandó probléma lényegére kell  figyelnie, megkeresheti  a kritikus pontokat a programban, és minden korá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án négy generációba soroltak.

Programozási nyelvek generációi Első generációs programozási nyelvek Az   első   programozási   nyelv   a  gépi   kód  volt.   Ennek   a   nyelvnek   az   utasításait   a   számítógép   képes   volt közvetlenül,   minden   átalakítás   nélkül   végrehajtani,   értelmezni.   A   problémákat   nagyon   precízen   kellett megfogalmazni, lépésekre bontani. Emellett a nyelv erősen gépfüggő volt, hiszen minden gépen más és más utasításokat  használt, az adott  problémát  minden géptípus esetén másképpen  kellett  leírni,  megfogalmazni, 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 emberi nyelvektő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 0D00 Az 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 a második memóriacím. A gépi kódú lehetőségekhez képest komoly előrelépést jelentett az  Assembly  nyelvek megjelenése, amelyek tulajdonképpen segédeszközt jelentettek a gépi kódú utasítások egyszerűbb megfogalmazásában. Az egyes gépi kódú utasításokhoz egy­egy mneomnikus kódot rendeltek hozzá, a tárcímeket pedig a memória kezdetéhez viszonyított relatív címekkel számították. Szintén újdonságnak számított, hogy az egyes memóriacímeket egy­ egy szimbolikus névvel lehetett helyettesíteni.  Egy összeadás Assembly nyelven: ADD X, Y Az ADD szócska az összeadásra (addition) utal, az X és Y pedig memóriacímeket szimbolizálnak. Tehát   az   Assembly   egy   olyan   alacsony   szintű   programozási   nyelv,   amelynél   a   művelet   és   a   tárcím szimbolikusan megadható, 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   Assembly virágkorában   az   operációs   rendszerek   tartalmazták   az   Assembly   fordítót.   A   fordítóprogramok   compiler típusúak  voltak. Az  Assembly  legtöbb utasítása  egyetlen  gépi  utasítást  reprezentált, azaz  az Assembly 1:1 tipusú 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. Az Assembly­t ma már csak olyan feladatok esetén használják, ahol hardver szintű vezérlést kell megvalósítani. A visszaszorulá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ő programok felé mutat. Második generációs programozási nyelvek A számítógépek alkalmazási területének bővülése szükségessé tette a programok fejlesztési idejének csö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 és az assembly nehézkessége, géphez igazodása miatt nem volt erre alkalmas. A 60­as évek elején jelentek meg az első magas szintű programozási nyelvek. Az új nyelvek struktúrája már nem a számítógép sajátosságaihoz, hanem a problémához igazodott, a programozóknak itt már nem kellett a gé­ pi végrehajtással foglalkoznia. Minél függetlenebb egy programozási nyelv a gépi logikától, annál magasabb szintű, 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ás több gépi kódú utasítást reprezentál. Természetesen a magas szintű nyelven írt programokat is le kell fordítani ­ az assembly­hez hasonlóan ­ de komoly előny, hogy ezeknél a nyelveknél már sokkal kisebb a hibalehetőség, a forrásprogram sokkal áttekinthetőbb lett. A magas szintű programozási nyelvek már sokkal közelebb állnak az emberi logikához, mint elődük, jóval egyszerű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,10 mov y,12 add x,y mov sum,x

X=10 Y=12 SUM=X+Y

FORTRAN Az 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 algoritmusok szé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 nyelv első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ított változata jelent meg. 1966­ban a FORTRAN 66, 1977­ben a FORTRAN 77 ANSI, és ezek mellett készültek el a FORTRAN II., IV. és V. változatok. Az utolsó szabványosított változat a FORTRAN 90 volt, melyek ma is haszná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 FORTRAN 2000. ALGOL A FORTRAN­hoz hasonlóan, úttörő nyelv volt a magas szintű nyelvek sorában. 1955­ben fejlesztették ki, a matematikai, 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 emberi beszé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 a program nevét. A programban használt változókat deklarálni kell, a deklarációk a blokkok elején helyezkednek el. 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. COBOL Az 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 rendszerek kezelé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ések utá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 nagy vá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 a programok mérete igen nagy lesz, és az alapvető matematikai műveleteken túl nem támogatja a bonyolultabb számítási feladatokat. BASIC A BASIC nyelv kialakulása a programozási nyelvek fejlődésének bölcsőjéhez vezet vissza, amikor a magyar származású Kemény János és munkatársa, Thomas Kurtz elhatározták, hogy kidolgoznak egy olyan programo­ zási nyelvet, amelynek segítségével a programozás könnyen oktatható és tanulható. A köztudatban a BASIC nyelv a kezdő programozók nyelveként vált ismertté. Az ötlet a 60­as évek elején született, amikor megjelentek az első Time­sharing (időbeosztásos) rendszerek, és a központi számítógépen tárolt adatokhoz egyre több felhasználó férhetett hozzá. A felhasználóknak szükségük volt 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ási nyelv létrehozására. Az első ilyen interpreter típusú nyelv a BASIC volt, amely nagymértékben egyszerűsítette a 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 jelent meg. 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ó VISUAL BASIC. 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

RPG A 60­as évek végén jelent meg egy új, az IBM cég által kidolgozott programozási nyelv, amely a COBOL­hoz hasonló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ális nyelvekkel, 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 viszonylag kis 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átozott felhasználási területe miatt háttérbe szorult. Harmadik generációs programozási nyelvek A második generáció programozási nyelvei már lényegesen függetlenebbek voltak a gépi logikától, mint az első generációs nyelvek, az elkészített programokat többféle gépen is használni lehetett. Azonban a 2 GL nyelvek többsége egy­egy problémacsoport megoldására specializálódott, ami a programok fejlesztése, javítása során igen komoly akadályokat jelentett. A 60­as évek derekán kíséreltek meg először olyan programozási nyelvet fejleszteni, amely rendelkezik a 2 GL nyelvek 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éle problé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ági számításoktól a rendszerprogramozási fejlesztésekig, széles a lehetőségek skálája. Néhány ismertebb, szélesebb körben elterjedt 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ég nem 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 szerkezete egyszerű é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 tartalmaz egy 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ól Az 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 a COBOL 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ási nyelv 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ált programozá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. PASCAL A 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 Blaise Pascal 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. A fü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. A PASCAL 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­2 Amint 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 a rekurzí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 a moduláris felépítésű programok könnyen áttekinthetők, értelmezhetők egy esetleges módosításkor. Manapság is népszerű nyelv, majdnem minden operációs rendszerhez beszerezhető a fordítóprogramja.

12

ADA A ’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 nyelv Augusta Ada Byron­ról kapta a nevét, akit Charles Babbage munkatársaként az első női programozóként említ az 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 modulokat Package­nek nevezzük. Ezek az egységek gyakorlatilag egymástól függetlenül elkészíthetők és lefordíthatók. A modulok 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ába mutat 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. A megírt program áttekinthető, könnyen módosítható, a moduláris felépítés miatt. A nyelv szerteágazó lehetőségei szinte 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 nyelv A 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ók adta 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örben haszná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 nyelvek Az 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ési munká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ált nyelvek, 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 nyelvek SmallTalk A ’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ált programozási nyelv. Eiffel 1988­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 nyelvek Turbo Pascal A Turbo Pascal 5.5 verziójától kezdve támogatja az objektumok létrehozásának és kezelésének lehetőségét. A 6.0 verzióba már került egy előre definiált objektumrendszer – TVISION – is, amely a szöveges felületű 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 nyelvek Ma 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ületek olyan speciális igényeket támasztanak a számítógépekkel szemben, amelyek megoldásához hasonlóan speciális eszkö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ése A 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ő nyelvek Nagy pontosságot igénylő, bonyolult matematikai, műszaki számítások számítógép által történő elvégzéséhez biztosítanak hatékony segítséget ezek a nyelvek. Például: FORMAC, REDUCE, MACSYMA. Szimbólum­feldolgozó nyelvek Nagy 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 nyelvek Nagyon 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ő nyelvek Adatbá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ő programnyelvek A harmadik generációs programozási nyelvek legfejlettebb változatai. A programozási feladat megoldásához a nyelv 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 nyelvek A XX. század második felében a számítástechnika forradalmi változáson ment keresztül. A Neumann elvek megjelenése és az első memóriában tárolt gépi nyelvű program lefuttatása után alig ötven évvel már informáci­ ós rendszerek, központilag vezérelt számítógép hálózatok programozása, döntéshozást támogató rendszerek 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, hogy mit 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énye is, 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öznek bizonyulnak a 3 GL nyelvek. A 4 GL nyelvek osztályozása Lekérdező nyelvek Biztosí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átorok Lehetővé teszik, hogy a felhasználó egy előre definiált minta alapján egyszerűen és hibátlanul hozzon létre egy harmadik generációs programnyelvi alkalmazást. Egyéb 4 GL nyelvek Ebbe a csoportba sorolhatjuk a döntéstámogató rendszerek fejlesztésére használatos nyelveket, a prototípus nyelveket (modellezést, tervezést segítő nyelvek), és a formális specifikáció nyelveit. Ötödik generációs programozási nyelvek A XX. század második felében a számítástechnika forradalmi változáson ment keresztül. A Neumann elvek megjelenése és az első memóriában tárolt gépi nyelvű program lefuttatása után alig ötven évvel már informáci­ ós rendszerek, központilag vezérelt számítógép hálózatok programozása, döntéshozást támogató rendszerek 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ása

Felhasználói kör szerint Amatő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 szerint Neumann elvű nyelvek A 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 szerint Gé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" nyelvek Arra utal, hogy egyes nyelvekhez gyakrabban készítenek interpretert (értelmezőprogramot), míg másokat szinte kizárólag compilerrel (fordítóprogrammal) használnak. Procedurális illetve nem procedurális nyelvek procedurá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 nyelv Olyan 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 nyelv Olyan 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 nyelv Olyan programnyelv, melynek alapelemei kifejezések,s a program kifejezések kiértékeléséből áll. Objektum orientált nyelv Olyan programnyelv, mely az objektum orientált programozás eszközeivel rendelkezik. (pl. Delphi) Párhuzamos programnyelv Olyan programnyelv, mely a párhuzamosság kezelésére szolgáló eszközökkel rendelkezik.  18

Programozási alapfogalmak Algoritmus Lépések sorozata, amellyel egy feladat kiindulásától a megoldásáig jutunk. Program Az 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ékeli azok  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ás A 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ásprogram A  programot,  ahogyan  azt  egy  szerkesztő  programmal   (egyfajta  specializált  szövegszerkesztővel)  megírjuk mostantól fogva forrásprogramnak (vagy forráskódnak) nevezzük. Programozási nyelv A  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 szintjei Gé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ára ismert 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 nyelv A nyelv utasításkészlete szinte teljesen egyezik a gépi kódú programozáséval, de az utasításokat könnyebben megjegyezhető 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 nyelvek Magasabb 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 nyelvek Az emberi gondolkodáshoz még közelebb álló programozási nyelvek. Szintaxis és szemantika leírás Szintaxisnak 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ök A 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 – metanyelv Nagyon kevés szimbólumot használ. A definiálandó fogalmakat <, > jelek közé kell tennünk, a definiálás jele a ::=, az alternatív definíciókat a |­jellel választjuk el egymástól, a megismétlendő elemeket pedig a {,}­jelek közé tesszük. Példák:  ::= Program: {} Program vége. <Értékadás> ::=  :=   ::=  |  Szintaxisgráf – vasútdiagram A szintaxisgráf csomópontjait nyelvi elemek alkotják, s ezek lehetséges sorrendjét az irányított gráf élei jelölik ki. Példák: Program

Értékadás

Fordítás és értelmezés Ahhoz, hogy egy számítógéppel „beszéljünk”, olyan fordító rendszereket kell alkalmaznunk, melyek képesek a szá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 menete Interpreteres 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ás Egyes modern nyelvek megpróbálják a két módszert kombinálni, hogy mindegyikből a legjobbat hozzák ki. Ez a 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ép szempontjából  a   bytecode­ot nagyon egyszerű gépi nyelven interpretálni. Ez  az interpretáció  tehát sokkal gyorsabb 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é,   de szá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 nyelvek A 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ések A 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. Kulcsszavak A nyelv rögzített jelentéssel bíró szavai, amelyet más célra nem lehet használni. Programstruktúrák Program A 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ó. Programcsomag Rokon 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árhuzamosan végrehajthatók, a megoldás során egymással kommunikálnak, működésüket szinkronizálni kell, s meg kell oldani a közös erőforrások megosztását. Ezeket a párhuzamosan működő programrészleteket nevezzük folyamatoknak. 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ási egységnek. Ez a fordítóprogram egyszeri végrehajtásával lefordítható. Nem tévesztendő össze azzal, amikor egy fájlban több fordítási egységet helyezünk el, s azokat egyszerre fordítjuk. Export­, importlisták Ezek a fordítási egységek olyan részei, amelyek leírják egyrészt, hogy az adott egység mely azonosítóit használhatja más modul, másrészt, hogy ő mely modulokat, azokat, azoknak mely objektumait használja. Nem csak a modulnevet kell megadni, hanem azt is, hogy abból a modulból mire van szükségünk. Programegység Egy 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 rendelkező utasításcsoport. 22

Eljárás, függvény, operátor Gyakorlatilag háromfajta programegységet használunk : az eljárást, a függvényt, valamint a függvény egy speciá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 kifejezésben szereplő értéket reprezentálhat. Az unáris vagy bináris operátort szintén kifejezésekben használhatjuk. Ezek a programegységek, az ún. alprogramok paraméterezhetők. Definíciójukban formális paramétereket használunk, a ezeket híváskor feleltetjük meg az aktuális paramétereknek. Deklarációs rész, törzs Egyes 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 hogy előzze a definiálása. Néhány nyelvben a programegységek egy harmadik részt is tartalmaznak, a kivételkezelés. Blokkstruktúra Programok programegységeit kétféleképpen helyezhetjük el. Az egyik, egyszerűbb elv szerint a program programegysé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 elveinek Taktikai elvek Technológiai elvek Technikai elvek Esztétikai­ergonómiai elvek Stratégiai elvek Egyik 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. Így programunk könnyen kézben tarthatjuk. Lépésenkénti finomítás A feladat megoldását először átfogóan végezzük el, nem törődve a részletekkel, részfeladatra bontjuk. Úgy is mondhatnánk: a feladatot megoldjuk a legfelső szinten. Ezt az eljárást fogjuk követni az egyes részfeladatok megoldásakor is mindaddig, amíg olyan utasítások szintjéig nem érünk, amelyeket gépünk (kódolás után) már vé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 a megfelelő utasítássort.

23

Taktikai elvek Milyen elv alapján hajtsuk végre a lépésenkénti finomítást. Párhuzamos finomítás elve A 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 elv Erre 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 elvek Ezek az elvek az algoritmus (és a kód) írására, annak szabályaira vonatkoznak. Algoritmusleírási szabályok Kevé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ások segí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ára szolgáló eszközökkel is. Értelmes sorokra tördelés – világos tagolás Kérdés, hogy mit írjunk egy sorba, mit több sorba. Alapelképzelésünk lehetne például az, hogy minden utasítást külön sorba kell tenni. Ezt a következőképpen módosítjuk: kerüljenek egy sorba azok az utasítások, amelyek szervesen összekapcsolhatók, és egy sorba írásukkal a program még áttekinthető marad. Bekezdéses leírás Az algoritmikus gondolatainkat, az algoritmus főbb eseményeit, epizódjait jól láthatóan el kell különíteni a programban. A program teljes levezetése (finomítása) után a program szerkezetének vissza kell tükröznie a szintekre 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ése Az 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 elve A konstansoknak, változóknak, típusoknak, eljárásoknak, függvényeknek, operátoroknak olyan nevet érdemes adni, 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 elvek A 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ág Az 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ág A „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 a feltett kérdésére. Ennek érdekében a program kritikus pontjait, azaz ahol a felhasználó közvetlenül avatkozik be a program további menetébe, nagy odafigyeléssel kell megírni. Az esetleges hibalehetőségekre fel kell készíteni a 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át a program írója, nem pedig a használója számára készültek. Jól olvasható program A 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én könnyen kiolvasható formában megtalálhatók, és így biztos kézzel nyúlhatunk bele a program legérzékenyebb ré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 algoritmust nagyban 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 program Sokszor 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 és ezek 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 a programozási nyelv utasításainak, illetve változóinak megfeleltetését). Ezeket a dokumentációban is rögzíteni kell, amelyben ezen kívül még foglalkozni kell a használat mikéntjével és az esetleges, előre látható fejlesztési lehetőségekkel is. Esztétikai­ergonómiai elvek A program emberközelségéről van szó. Nagy gondot kell fordítani a program által megjelenített információk kü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 technika A 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és techniká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éc vagy 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 össze nem tartozó információk egymástól elkülönülnek. Az elkülönítés megoldható üres sorok beiktatásával, az egyes ré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ütechnika A lapkezeléssel szorosan összefüggő módszer, amely a felhasználóval való párbeszéd elegáns megszervezésére alkalmas. Á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 fel sem 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   (vagy kezdő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ása után pedig újra e főmenü jelenik meg. Az egyes almenük hasonló elven épülhetnek fel, de ezekben a befejezés helyett a Vissza az előző menühöz pont választható. Ikontechnika A 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ése A kérdéseknél nagyon sokszor épp az okoz bizonytalanságot, hogy a felhasználónak fogalma sincs arról, hogy az 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 legnagyobb természetességgel fokban adja meg az értéket. Az ilyesmiből származó hibát nyilván nem kell ecsetelnünk. Fontos adatok kiemelése Nemcsak 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 grafikus formában is –, hogy a feldolgozás hány százalékánál tart éppen a program. Tördelés A  legelemibb elvárás a képernyőn megjelenő szövegekkel szemben, hogy a sorok/szavak tördelése a helyesírás szabá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ég A következetes beolvasási és kiírási szokások is fontosak. Tartsunk mértékletességet a beolvasási módszerek változatosságában. Nem díjazzák a felhasználók kiterjedt programozási ismereteinket, ha a választ hol ENTERrel 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 egyfajtá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 eredményadatok a lapok azonos helyein jelenjenek meg. Hibajelzés követelményei A 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 progra26

mot. Igyekezni kell a hibajelzés legmegfelelőbb módjának kiválasztására. Ehhez a következő szempontokat érdemes megfontolni: • A hibajelzés ideje. Hibát akkor kell jelezni, amikor bekövetkezett, nem pedig valamely következményekor! Tipikusan „bosszantó” lehet több száz adat beolvasása után olyan üzenetet látni, hogy kezdjü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 a ké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 éppen nem 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 ember az ilyenkor természetes türelmetlensége miatt csak hevenyészve képes végigszaladni a leírt „regé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ás A program futása során több olyan esemény következhet be, amelyeket jó feljegyezni a későbbi esetleges feldolgozás érdekében. A felhasználó nem biztos, hogy megteszi ezeket. Ennek megoldására szolgál az ilyen események automatikus fájlba írása, a naplózás. Ez többnyire egy egyszerű szerkezetű szöveges fájl, amit a haszná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ármikori lenyomá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ére stb. vonatkoznak. Segítség Egy 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át adja a felhasználó kívánságára. 5.12. Ablaktechnika A homogén képernyő helyett célszerű olyan lapokat, ún. ablakokat használni, amelyek a képernyő elkülönített ré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észt eltakarja, é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. 2. 3. 4. 5. 6.

Feladat meghatározása (specifikáció) Algoritmus készítése Kódolás Tesztelés, hibakeresés, javítás Hatékonyságvizsgálat 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őket A 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ő adatokra kirótt feltételeket nevezzük  előfeltételnek, illetve  utófeltételnek. Az előfeltétel nagyon sokszor egy azonosan igaz á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ég Előfeltétel: csukva legyen az ablak Kimenet: 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ódszer Előfeltétel: legalább 10 fő legyen az osztály, legyenek csökkenő sorba rendezve Kimenet: egy emberke Utófeltétel: előtte 9 ember legyen Feladatok 1. 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ódszer Előfeltétel:  legyenek növekvő sorba rendezve Kimenet: egy vagy kettő emberke Utó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ódszere Előfeltétel:  valaki (pl. Géza) tudjon egy angol szót Kimenet: tábla Utófeltétel: táblán legyen egy angol szó Algoritmuskészítés Algoritmus Az algoritmus olyan pontos elírás, amely megmondja, hogy milyen műveleteket kell meghatározott sorrendben elvégezni, hogy megoldjuk a problémát. Az algoritmus olyan pontos elírás, amely megmondja, hogy milyen műveleteket kell meghatározott sorrendben elvégezni, hogy megoldjuk a problémát. Algoritmussal szemben támasztott követelmények Legyen 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ó).

Program A program minden esetben utasítások sorozata. Program: utasítás … Program vége. Értékadó utasítás Vá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.  azonosító := kifejezés pl. a:=12 Az 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ás Tetsző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. Be: azonosítók [feltételek] A feltételek elmaradhatnak, ha a beolvasandó értékekre semmilyen előfeltevésünk nincs. Kiíró utasítás A felhasználó által figyelt perifériára helyezi el az adatokat karakteresen. Ki: kifejezések [formátum megkötés] 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ések Az 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. [magyarázó szöveg] Utasításblokk ­ szekvencia A szekvenciát alkotó utasítások a megadás (leírás) sorrendjében végrehajtandók. Utasítás1 Utasítás2 ... Pl.: Kelj fel!        Moss arcot!        Fésülködj meg 29

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ás Egy utasításblokkból áll. Az utasításblokk a feltételtől függően vagy végrehajtásra kerül, vagy nem.  Ha logikai kifejezés akkor utasítássor Ö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.  Ha logikai kifejezés akkor utasítássor            különben  utasítássor Ö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  Ha logikai kifejezés akkor utasítássor különben ha logikai kifejezés akkor utasítássor különben utasítássor Elágazás feltétel_1 akkor utasítássor_1 feltétel_2 akkor utasítássor_2 … feltétel_n akkor utasítássor_n egyéb esetben utasítássor_n+1 Elágazás vége. 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 ciklus Feltétel előbb értékelődik ki, majd megfelelő esetben végrehajtásra kerül a ciklusmag  „… előbb tesztel, aztán  ciklusmag…”. Ciklus amíg logikai kifejezés utasítássor Ciklus vége Hátultesztelős ciklus A 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

Ciklus utasítássor amíg feltétel Ciklus vége Számlálós/Növekményes ciklus A ciklusmag utasításai a fejrészben megadott számszor hajtódnak végre, megadott lépésenként. Ciklus cv=K­tól L­ig utasítássor Ciklus vége. Eljárás, függvények, operátor Programjainkat célszerű részfeladatokra bontani. Az olyan részfeladatokat megoldó részprogramokat, amelyek „valamit csinálnak”, nevezzük eljárásoknak. Az eljá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. Eljárás Eljárásnév: utasítássor Eljárás vége. Az eljárások paraméterezhetőek, az eljáráson belül használt paramétereket formális paramétereknek, az eljárás hí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 pedig nem (konstans). 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) 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. 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és Függvény vége. Vannak speciális függvények, amelyeket a többiektől eltérő módon használunk, jelüket nem az argumentumuk elé, hanem argumentumaik közé írjuk, ezeket operátoroknak vagy műveleteknek nevezzük. Művelet Operátornév(formális paraméterek): értékének típusa utasítássor Operátornév:=érték Művelet vége. ...aktuális paraméter_1 Operátornév aktuális paraméter_2

31

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 a vé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ások Az ismétlési szerkezeteket elrejtve tartalmazza az ábra.

32

5. Ciklusok:

33

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 terjedelmes nehezen 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ás BE: 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ás Egyszerű: 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 AKKOR utasítások  KÜLÖNBEN utasítások ELÁGAZÁS VÉGE. 37

ELÁGAZÁS feltétel_1 AKKOR utasítássor_1 feltétel_2 AKKOR utasítássor_2 … feltétel_n AKKOR utasítássor_n EGYÉB ESETBEN utasítássor_n+1 ELÁGAZÁS VÉGE. 5. Ciklusok Elöltesztelős  CIKLUS AMÍG logikai kifejezés utasítássor CIKLUS VÉGE Hátultesztelős CIKLUS utasítássor AMÍG feltétel CIKLUS VÉGE Számlálós CIKLUS 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ások ELJÁ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és FÜ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 a terv 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 minden hibá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, ha kijelö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áskor meg kell állnia. A felhasználó információt szerezhet a program állapotáról és folytathatja a 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 a fejezetben 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 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

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

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, szintaxis hiba

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

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. Ilyenkor egy 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ást szeretné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 (amely minden programozási környezetben működik) úgy valósíthatjuk meg, hogy a változók tartalmát a program megfelelő 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 nem szá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ó specifikus információ következik. Számos esetben előre lehet látni, hogy bizonyos hibák léphetnek fel a program egyik vagy másik részében. Ezekbe a programrészekbe beépíthetünk olyan speciális utasításokat, amik csak akkor aktiválódnak, ha ezek hibák fellépnek. Az olyan magasszintű nyelvekben, mint amilyen a Python, lehetőség van 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 semmilyen hiba 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ében nincs é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ág A 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ág A 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 a koprocesszor), 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 milyen programot, 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, a programot 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, grafikus ká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   kell megadni (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önyv Nagyobb 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 programmal automatizá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 Szerkezet A dokumentáció elsődleges célja segítségnyújtás a program leendő felhasználóinak, továbbfejlesztőinek. Ezért olyannak 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. Forma A 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ílus A 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 Felhasználói dokumentáció Feladat ”Feladat megfogalmazása.” Használat A 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ás Fontosabb típusok ”Változók, konstansok megadása.” Algoritmus ”A feladat megoldása mondatszerű algoritmus leírással.” Kód ”A program kódja.”

46

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”

47

Példa dokumentációra Felhasználói dokumentáció Feladat A program olvasson be két számot, adja össze azokat, majd írja ki az összeget! Használat A program indítása: Dokumnetumok könyvtárban taláható osszeg.py Indítása Terminálból python osszeg.py prancs kiadásával. A program indítása: Egy lehetséges párbeszéd: Kérem az első számot: 12 Kérem az első számot: 3 A program eredménye: A két szám összege: 15 Hibalehetőség: Szám helyett szöveg megadása, a hiba nincs lekezelve.

48

Fejlesztői dokumentáció Feladat A program olvasson be két számot, adja össze azokat, majd írja ki az összeget! Környezet Forráskód Dokumnetumok könyvtárban taláható osszeg.py Indítása Terminálból python osszeg.py prancs kiadásával. Megoldás Fontosabb típusok szam1, szam2, osszeg: Valós Algoritmus Program osszeg: Ki: „Kérem az első számot:” Be: szam1 Ki: „Kérem a második számot:” Be: szam2 osszeg=szam1+szam2 Ki: „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=5 szam1=-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 Strukturált program Böhm­Jacopini tétel: (1966)

49

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ált programnak 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ága A 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 nyelvek Azokat a nyelveket, amelyekben kötelező minden használni kívánt változót deklarálni és minden adattípussal szigorú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ást automatikusan 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 olyan tí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ípusos nyelvek 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 az erő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ás Mikor 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ípus azonos, ha szerkezetük azonos. Típuskényszerítés Ha kifejezésben különböző típusú tényezők szerepelnek, akkor vagy kötelező a felhasználónak típuskonverziós függvénnyel azonos típusúvá alakítani őket, vagy automatikus konverzió, típuskényszerítés történik. Altípus Olyan 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ípus Ez 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ípusok Statikusnak 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ípus Paramé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 lefoglalva a 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éket adunk 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űvel kell 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ég akkor 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álatlan változóknak szokás nevezni. Egyes nyelvek fordító programjai nem engedik felhasználni az inicializálatlan vá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, 2 byte­os, 4 byte­os, stb. másrészt meghatározza, hogy az adatot hogyan lehet kezelni, egész számként, valós számként, karakterkódként, stb. harmadrészt meghatározza, hogy milyen műveletek végezhetők az adattal. Konstans A konstans is egy memóriatartományt reprezentál, adott típusú értéket tárolhat, ez az érték megvizsgálható, de nem 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 a vá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, hogy tö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ás Inicializá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és A 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ási egysé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ók Programozá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 objektum neve lehet ugyanaz, ha a hatáskörük különböző. Hozzáférési jog Az adat módosíthatósága és lekérdezhetősége. Kezdőérték Kezdőértéknek nevezzük a memóriába képezéskor a lefoglalt helyre elhelyezett értéket. Hatáskör Egy 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ág A 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 a programszövegbeli  tartományt, ahol az azonosítót semmi sem  takarja, nevezzük láthatósági körnek. Ez vagy azonos a hatáskörrel, vagy része annak. Élettartam A futási idő azon része, ahol az azonosító ugyanazt az adatot jelenti. Statikus változónak nevezzük azokat a vá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ípus Az alábbi adattulajdonságok összessége: értékhalmaz, műveletek, ábrázolás. Értékhalmaz Az a halmaz, amelyből a változó értéket vehet fel. Adat csoportosítása (értékhalmaz szempontjából) Egyszerű típusok Szerkezetileg 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ípusok Szerkezettel 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ékhalmaz Hamis..Igaz (Min'Logikai..Max'Logikai: Hamis, illetve Igaz) Műveletek Nem, és, vagy (a szokásos logikai műveletek) . Relációk =, <, ≤, ≥, >, ≠ (a belső ábrázolásuk alapján). Ábrázolás 0 =Hamis ­1 =Igaz(néha 1 =Igaz). Karaktertípus Értékhalmaz 0..255­kódú jelek (Min'Karakter..Max'Karakter: a 0, illetve a 255 kódú karakter) Műveletek nincs. Relációk 54

=, <, ≤, ≥, >, ≠ (a belső ábrázolásuk alapján). Ábrázolás Valamely ú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 által kreá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űveletek a 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ós fü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ékhalmaz konstans1..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űveletek Ugyanazok, 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ók Ugyanazok, amik a bázistípuson értelmezettek.

55

Valós résztípus Értékhalmaz való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űveletek Korlátozott valós műveletek (csak a formulával előállíthatók jöhetnek ki – automatikus kerekítéssel, ha szükséges), vagy ha nem ilyen, akkor mint „egyszerű” valós értékkel lehet csak továbbszámolni. Relációk való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őbbivel lé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ás Mezőnként folytonos memóriaterületen Példa      

TDá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 vektor fogalmá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űveletek Alaptípussal megegyezik, kiválasztás. Megadása né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 az elemei, 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ékhalmaz Az 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élda napok=(hétfő,kedd,szerda, csütörtök,péntek,szombat,vasárnap) Halmaztípus=Halmaz(napok) vagy SET OF napok Szöveg Értékhalmaz Karakterek 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élda Változó: s: szöveg s:=”Ez egy példa” Sorozat Értékhalmaz Alaptípus iteráltja és a lineáris rendezettség jellemzi: pontosan egy megelőző és következő létezik. Műveletek Az 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élda vá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ás Amikor 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íteni kell. Egy bájt bitjeit 0­tól 7­ig szokás számozni, ahol 0 a legalacsonyabb helyi értékű bit.  Fixpontos ábrázolás Fixpontos 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óban kitö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−1 Egé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 a pozití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 viszonylag kompliká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−1 2. 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ám negatí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, avagy ismét a kettes komplemensét képezzük. Előnye, hogy a kivonást nem kell implementálni, ez egyszerűen negatív szá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úlcsordult bittel 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ív szá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ás A 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ész első 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 6 szá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 fogalma A programozási tételek típusalgoritmusok, amelyek alkalmazásával garantáltan helyes megoldást adhatunk a programozá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 elemei Feladatkitűzés: az általános feladat szöveges formában Specifikáció: az általános feladatban szereplő adatok (intervallumok, függvények, relációk) megadása, elő­ és  utófeltételek megadása Algoritmus: az általános specifikációban szereplő adatok segítségével megfogalmazott megoldás.  Tételek alkalmazásának lépései Specifiká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ása A 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és Adott 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űvelet s: H (s a végeredmény) Előfeltétel: m,n, f adott, m<=n n Utófeltétel:

s= ∑ f (i)

i=m / 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:=0 Ciklus 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és Adott 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ész T:[m..n] -> logikai s: egész Előfeltétel: m,n, T adott, m<=n Utófeltétel:

s

n

1 i m T (i )

/ azaz s tartalmazza az [m..n] intervallum azon elemeinek a számát, amelyekhez T igazat rendel / Algoritmus Eljárás Megszamlal: s:=0 Ciklus i:=m-től n-ig Ha T(i) akkor s:=s+1 Elágazás vége Ciklus vége Eljárás vége Eldöntés tétele Kitűzés Adott 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ész T:[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:=m Ciklus amíg (i<=n) és nem(T(i)) i:=i+1 Ciklus vége L:=(i<=n) 62

Eljárás vége Kiválasztás tétele Kitűzés Adott egy sorozat, a sorozat elemein értelmezett egy T tulajdonság, és tudjuk, hogy van a sorozatban T tulajdonságú elem. Feladat: Határozzuk meg az első T tulajdonságú elem sorszámát! Specifikáció m,n: egész T:[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:=m Ciklus amíg nem(T(i)) i:=i+1 Ciklus vége Ind:=i Eljárás vége Feladatok - 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és Adott 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áma f: HA -> HB B:Tömb[1..Max]:HB Ef: A, N adott, 0<= N <= Max Uf: B adott és ∀ i ∈[ 1. . N ]:( B [ I ]=f ( A [ I ]) ) / Azaz B tartalmazza az A elemeinek a transzformáltjait / Algoritmus Eljá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és Adott 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]:H N:egész / A elemszáma B:Tömb[1..Max]:H DB:egész / B elemszáma Ef: A, N adott, 0<= N <= Max Uf: B adott és tartalmazza az A összes T tulajdonságú elemét, 0 <= DB <= N Algoritmus Eljárás Kivalogat: DB:=0 Ciklus i:=1-től N-ig Ha T(A[i]) akkor DB:=DB+1 B[DB]:=A[i] Elágazás vége Ciklus 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és Adott 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]:H N:egész / A elemszáma B,C:Tömb[1..Max]:H BDB,CDB:egész / B, C elemszáma Ef: A, N adott, 0 <= N <= Max Uf: 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

Algoritmus Eljárás Szetvalogat: BDB:=0 CDB:=0 Ciklus i:=1-től N-ig Ha T(A[i]) akkor BDB:=BDB+1 B[BDB]:=A[ii] Különben CDB:=CDB+1 C[CDB]:=A[i] Elágazás vége Ciklus 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és Adott 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]:H N,M:egész / A és B elemszáma C:Tömb[1..Max]:H L: egész / C elemszáma Ef.: A,B adott, elemeik egyediek; 0<=N<=Max , 0<=M<=Max Uf: 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/ Algoritmus Elve: 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és Adott 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]:H N,M:egész / A és B elemszáma C:Tömb[1..2*Max]:H L: egész / C elemszáma Ef.: A,B adott; elemeik egyediek; 0<=N<=Max , 0<=M<=Max Uf: 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. Algoritmus Elve: 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ége 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 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és Adott 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]:H N,M:egész / A és B elemszáma C: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<=Max Uf: C tartalmazza az A és B sorozatok rendezett unióját, Max(A,B)<=L<=M+N Algoritmus Az ö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:=0 Ciklus amíg (i<=N) és (j<=M) l:=l+1 Elágazás 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ége Ciklus 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+1 C[l]:=A[k] Ciklus vége Ciklus k:=j-től M-ig /Csak akkor fut le, ha marad elem B-ben/ l:=l+1 C[l]:=B[k] Ciklus vége Eljárás vége

67

Összefuttatás tétele (METSZET) Kitűzés Adott 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]:H N,M:egész / A és B elemszáma C: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<=Max Uf: C tartalmazza az A és B sorozatok rendezett metszetét, 0<=L<=Min(A,B) Algoritmus Metszet 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:=0 Ciklus amíg (i<=N) és (j<=M) Elágazás A[i]B[j] esetén j:=j+1 /csak továbblép a B-ban A[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ége Ciklus vége Eljárás vége Feladat 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étele Kitűzés N elemű sorozat; sorozat elemein értelmezett T tulajdonság. Van­e T tulajdonságú elem és ha van, akkor mi a sorszá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 algoritmust kell í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ész Ef.: N≥0 Uf.: VAN=(?i(1≤i≤N): T(X[i])) és VAN → 1≤SORSZ≤N és T(X[SORSZ]) Algoritmus      Eljárás lin_keres: i:=1 Ciklus amíg i≤N és A(i) nem T tulajdonságú i:= i+1 Ciklus vége VAN:=(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 és ha 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 elemhez ké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(SORSZX[K] esetén E:=K+1 Elágazás vége amíg E≤U és X[K]?Y Ciklus vége VAN:=(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 sorozatra, 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 menet végén a legnagyobb elem a vektor végére kerül. Ugyanezt a páronkénti cserét végrehajtjuk a még rendezetlen A[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 legnagyobb 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, hogy egy menetnek az eredményeként a maximális elem a sor végére kerül. Eszerint a menet közbeni adatcseréket megtakaríthatjuk, ha a maximális elemet és ennek helyét megállapítjuk és csak a menet végén egyetlen cserével tesszü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 im 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áltozó 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 kisebb 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 pedig 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, amikor az É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át hí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ás magától értetődik, majd találnunk kell egy olyan ismételt egyszerűsítési folyamatot (indukciós lépés), mely alapjá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ális Az 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 Az iteratív megoldás: fakt(N,R): def faktIter(n):      R:=1        eredmeny = 1      Ciklus i:=1­től N­ig        while n > 1: R:=R*i             eredmeny = eredmeny * n      Ciklus vége.             n ­= 1 Függvény vége.        return eredmeny Rekurzív algoritmus fakt(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 tornyai A játék szabályai szerint az első rúdról az utolsóra kell átrakni a korongokat úgy, hogy minden lépésben egy korongot 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 el já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 – 1 korongot á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 megoldjuk az 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) def tornyok(n, honnan, hova, tartalek): Ha N>0 akkor     if n == 1: Hanoi(N­1,honnan,hova,tartalek)          print(str(honnan) + '. rúdról átmozgatjuk Ki: N,honnan,hova     a ', str(hova) + '. rúdra') Hanoi(N­1,tartalek,hova,honnan)          else: Elágazás vége          tornyok(n­1, honnan, tartalek, hova) Eljárás vége.          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ámok Rekurzí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 paradigma Programozási mód. Alapvetően a program felépítésére használt eszközkészletet jelenti, vagyis milyen egységek ké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ás Olyan 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ég Minden objektumnak megvan a jól meghatározott feladata, amelynek elvégzéséért felelős. Osztályozás Az 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ódus Az 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 a mű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ók elrejté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és Futá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és Fordí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és Tö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ása Egy 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 ezen keresztü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ály Olyan 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ály Olyan 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ál egy adott interfészt, akkor példányai  az interfészben meghatározott viselkedéssel  fognak rendelkezni. Csak konstans 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 konstruktort ké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 az adott 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ául az 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 objektum fele. 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 a tároló bejárását, azaz a tárolt elemek egymás utáni feldolgozását. Statikus metódusok Az 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ás ré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ódusok Ilyen 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, és az ö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élda A 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 a cé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. A szí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   a Helyzet 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 a Létrehoz metódusát. A Futás metódus hívásával elindítja a versenyt, a végén pedig az Eredmény metó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 a ké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ő fogalmak Az 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ódusokat ví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 mely másik osztály mezőit kérdezik le vagy módosítják, illetve mely metódusokat hívják! Melyik osztály objektuma hoz 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 objektum nevét, osztályát aláhúzzuk, és kettősponttal választjuk el egymástól. Ha nem lényeges az objektum neve, akkor el 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:  OSZTÁLY Osztálynév változók (mezők) deklarálása eljárások, függvények (metódusok) definiálása OSZTÁLY VÉGE A TPálya osztály definíciója például (vázlatosan): 

78

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

Linux alapok Parancs általános alakja parancs kapcsolók paraméterek Könyvtárszerkezet abszolút útvonal: útvonal megadása a gyökérből kiindulva / gyökérkönyvtár relatí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 pwd kiírja az aktuális könyvtár abszolút elérési útját cd   lesz az aktuális könyvtár, paraméter nélkül a home könyvtárba ugrik ls  <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  <lista> Létrehozza a listában található könyvtárakat Kapcsoló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  <lista> Törli a listában megadott könyvtárakat Kapcsolók ­p a teljes megadott útvonalat törli mv  <eredeti> <új> 79

Á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  <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  <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  <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  <lista> Törli a listában megadott fájlokat Kapcsoló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  <lista> Összeszámolja a könyvtárban található fájlok méretét Kapcsoló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 quota

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

df A 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ájlok cat  A  teljes tartalmát egyszerre kiírja a képernyőre  more  A  teljes tartalmát oldalanként kiírja a képernyőre  head ­  A  első  sorát kiírja a képernyőre  tail ­  Autolsó  sorát kiírja a képernyőre grep <minta>  Kiírja a  azon sorait, amelyekben megtalálható a <minta> szövegrészlet more  A fájl teljes tartalmát oldalanként írja ki a képernyőre tee

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

less  A fájl tartalmát görgethetően írja ki wc   Kiírja a ­ban található byte­ok/sorok/szavak számát Kapcsoló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   A fájl sorait ábécé sorrendben írja ki. Kapcsolók ­r csökken sorrend (z­a) Egyéb man <parancs> Előhozza a parancs részletes leírását file  Megadja a fálj típusát. echo <szöveg> Kiírja a szöveget. passwd A 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  <jogosultság> <lista> Jogosultság <mit>  a (all), u (user), g (group), o (others)  + (megadás), ­ (megvonás), = (beállítás) <mit> r (read), w (write), x, (execute) <user> oktális számjegyek read: 4, write: 2, execute: 1 ezek ö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ók finger Megadja, hogy ezen a gépen kik vannak bejelentkezve. finger  Felsorolja azokat a felhasználókat akiknek a neve vagy azonosítója megegyezik a   paraméterrel. finger @host Megadja, hogy a host gépen kik vannak bejelentkezve. who

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

w Mint, a who, de megmondja azt is, hogy ki min dolgozik. last exit

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

Kapcsolat megszakítása.

82

Python Első lépések Az interpretert közvetlenül a parancssorból indíthatjuk (egy Linux shell­ben, vagy Windows alatt egy DOS ablakbó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: Python 3.4.0 (default, Apr 11 2014, 13:05:18) [GCC 4.8.2] on linux Type "copyright", "credits" or "license()" for more information. >>> 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 Pythonban Az 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.  >>> 2+3 5 >>> 10-4 6 >>> 3*3 9 >>> 21/2 10.5 >>> (5+4)*2/3 6.0 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 lehetnek lé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. Egy programozá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 komplex szá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

nálja): 

 Értékadás, hozzárendelés Egy 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 és a változó értéke (tartalma) között. A Pythonban számos más nyelvhez hasonlóan a hozzárendelés műveletét az egyenlőségjel reprezentálja. >>> a=12 >>> a 12 >>> koszones="Szia!" >>> koszones 'Szia!' >>> pi=3.14 >>> pi 3.14 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: >>> szam1=szam2=2 >>> szam1 2 >>> szam2 2 >>> szam1,szam2,szo=23,-45.4,"alma" >>> szam1 23 >>> szam2 -45.4 >>> szo 'alma'   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 34 >>> koszones 'Szia!' >>> pi 3.14 A másik lehetősé a print(változónév) parancs kiadása. >>> print(a) 34 >>> print(koszones) Szia! 84

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ódolva volt, míg a másik módszer az idézőjeleket is. Változók típusadása Nem 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 nyelvekben elő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 lehet tartalmat 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. >>> szam1=12 >>> szam2=3.23 >>> szo="körte" >>> szam1,type(szam1) (12, ) >>> szam2,type(szam2) (3.23, ) >>> szo,type(szo) ('körte', ) Típusok: int : egész float : valós str : 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, 5 Változók: a,b,c Az  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­nal x!=y nem egyenlő y ­nal  x >y nagyobb, 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 sorrendben tö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

• • •

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ünk rá, 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 oldalai Kimenő adatok:      T : valós szám a háromszög területe Elő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  T  s(s  a)(s  b)(s  c)   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élda Ké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ámok Kimenő adatok:      y : valós szám Előfeltétel     x >= 0  Utófeltétel     y >= 0 és y2 = x  Példa Ké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ám Kimenő adatok:       (X1 ... XN) : egész szám Elő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 algoritmussal 1. 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ása 5. 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ényt 15. Adott a következő algoritmus: Start a = 3 b = 5 c = 1 d = 0 Ha b < 5 akkor   d = 8   c = 5 + a ellenben d = 15 Ha vége Ha c < d akkor   d = 40 Ha vége Vége A program végén mi a d értéke? Start a = 45 z = 37 d = a ­ z g = 3 r = 2 v = v / 2 Ha v > r akkor a = 23 ellenben z = 23 Ha vége Ha z == r akkor a = 4 Ha vége Stop A végrehajtás után mi lesz „a” és „z” értéke?

88

Start a = 45 b = 37 c = a ­ b d = 3 f = 2 g = b * a a = g Ha a > f akkor b = 23 ellenben c = 23 Ha vége Ha b == c akkor b = 4 ellenben d = 4 Ha vége Stop Az 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 .. a print i ciklus vége Fü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és A 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ín r  sugár h  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 h T  alapterület h  magasság r  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íg nyitva van különböző információkat lehet belőle olvasni és lehet bele írni, de általában a kettőt nem tesszük egyszerre. A neve segítségével férünk hozzá (ami tartalmazhat egy könyvtárnevet is). A fájl tartalmát mindig tekinthetjük egy 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, ahol maga a script található, kivéve ha a scriptet egy IDLE shell ablakból indítjuk. Ez esetben az aktuális könyvtár az 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 akarjuk majd 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ós rendszerü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árjuk le a fájlt. Jegyezzük meg, hogy ha a fájl még nem létezik, akkor automatikusan létre lesz  hozva. Ha viszont a név egy már létező és adatokat tartalmazó fájlra vonatkozik, akkor a bejegyzendő karaktereket hozzáfogja fűzni a 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 gyakorlat során ellenőrizhetjük, hogy a rendszerünkben (az aktuális könyvtárban) egy «sajatFile» nevű  fájlt (aminek a tartalmá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 azonos nevű 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 adatokat sorban 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ített informá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óba teszi. 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 a né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 t ello ! 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én egyszerű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ájlt kell kezelnünk, aminek nem ismerjük előre a tartalmát. Az alapelképzelés az, hogy részletekben olvassuk a fájlt mindaddig, 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ást kö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é ugyanabba a programhurokba:  while  :  ­­­ különböző utasítások ­­­  if  :         break  ­­­ különböz ő utasítások ­­­  if :         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ő sorokba rendezve. 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 egyszerre csak 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 csak akkor 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.) Ha nagy 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 a tí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   >>> t = pickle.load(f)  >>> print t, type(t)  2.83   >>> t = pickle.load(f)  >>> print t, type(t)  67   >>> 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 írja ki.

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 fajlagos ellená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 és az 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). A program 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