Programozás | Delphi » Delphi programozás tételek

Prog III Vizsga, 2005/2006 1. Kliens – Szerver adatbázis-kezelés Delphivel (gyakorlat) 2. Kezdésnek ezekre a komponensekre lesz szükséged:  Datasource – Data Acces fül  Database – BDE fül  Query – BDE fül  DbGrig – Data controls fül Ezeket be kell állítani és össze kell kapcsolni. Először a Database komponenssel kell kezdeni: AliasName-et beállítani mssql delphire /legalábbis órán erre kell állítani, hogy el tudd érni a suliservert/. Aztán DatabaseName-nek adnod kell egy nevet /ez teljesen mindegy hogy mi, pl saját név vagy akármi, de lehetőleg ne legyen benne ékezet/. A connected tulajdonságát ha TRUE-ra állítod akkor csatlakozik a serverhez /jelszót és felhasználónevet kér/. Ha nem állítod TRUE-ra, az sem baj, mert amikor a programban el akarja érni a servert, úgy is fogja kérni a jelszót+felhasználónevet. Felhasználónév: nmm user Jelszó: nmm123 Ezután jöhet a query beállítása. Itt a databasename-et kell

beállítani arra, amit az előbb megadtál a database-nél /ha mindent jól csináltál, akkor ki lehet választani a lenyíló listából/. Ha ez megvan, akkor a Datasource-nek a dataset tulajdonságát beállítod query1-re, a DbGrid datasource-ét pedig datasource1-re és készen is vannak az összekapcsolások. 2. Dinamikus memóriakezelés -Statikus memóriakezelés A változók tulajdonságai:  neve  címe  típusa 1 Prog III Vizsga, 2005/2006  értéke A változók élettartamát nem mi szabályozzuk! A foglalás program indulásakor, a felszabadulás a program leállásakor történik. -Dinamikus memóriakezelés Mi szabályozzuk a változó élettartamát. A változó akkor keletkezik, amikor szükség van rá, és mikor már nem kell, nem foglal több helyet. Akkor felszabadul, vagy felszabadítható. Miért van rá szükség: Nincs az a memória ami ne telne be! Szükség van a memóriagazdálkodásra. -Foglalunk -Használunk -Felszabadítunk A

felszabadítás után ugyanarra a helyre egy más nevű, típusú, értékű változó hozható létre. Alkalmazás Delphi-ben (Pascal) Mutatókat (pointer ) alkalmazunk, amik statikusak. A mutató arra képes, hogy egy változóra mutasson A mutatott elem mindig nagyobb, mint a mutató. „P” változó mutató típusú, magában hordozza, hogy milyen típusú változóra mutat. VAR P: ^Real; //valós típusú változóra mutat Lefoglalás: New(P) Lefoglalódik a dinamikus memóriából egy akkora terület, ami a P által mutatott változó számára szükséges. P rámutat erre a területre. Használata: P^:= 1,71; P1^:=P2^ // Értéket adtunk a dinamikus változónknak. //P1 átadja értékét P2-nek Felszabadítás: Dispose(P) Felszabadítja a memóriát, a központi memóriakezelő a „P” által mutatott helyet ezután szabadnak fogja tekinteni. Megj.: A „P” ezután is arra a címre fog mutatni, és az értéke is megmarad, mert nem törlni fizikailag, itt csak logikai

törlés történt. P:= NIL; //sehová sem mutató mutató Eldönthető ezzel, hogy van-e igazi értéke egy adott „P”-nek: If not P = NIL Then //ha P nem NIL-re mutat 3. Láncolt lista ADAT M ADAT M ADAT NIL Dinamikus memóriakezeléssel valósítjuk meg. Azonos típusú elemeket tud tárolni, de mindig csak annyi helyet foglal, ahány eleme éppen van, azaz amennyire éppen szükség van. -Eleje: mutatja az első elemet (Nincs adat tartalma) -M: mutató rész, ez mutat a következő elemre 2 Prog III Vizsga, 2005/2006 -NIL: ott a lánc vége. Előnye: csak annyi helyet foglal amennyire tényleg szükség van, szemben a tömbökkel. Hátránya: Az elemeket körülményes elérni. Ha van tíz elemünk, akkor végig kell olvasni az első kilenc elemet, hogy olvasni tudjuk az utolsót. Műveletek láncolt listáknál: 1., Alaphelyzetbe hozás Type PElem = ^Elem Elem = Record Tart : string; Kov: PElem; //Mutató lesz ami Elem-re fog mutatni //Tartalma a listának : ADAT

rész //Következő elemre mutat VAR eleje: PElem Begin Eleje:=NIL; End; Nincsen benne egyetlen elem sem, csak alaphelyzetbe hoztuk. A típusok létrehozásánál egy előretekintés található. Olyan típusokat használ fel, melyek még nem léteznek A Delphi előretekint, és tudja, hogy a még nem létező típust (ELEM) a következő sorban létre fogjuk hozni. 2., Új elem felvétele (elejére beszúrás) VAR P: PElem; Begin New(P); P^.Tart := ’Új elem’; P^.Kov := Eleje; Eleje := P; End; //lefoglalódik a memóriában a mutatott elem méret . // terület és P rá fog mutatni //Ami eddig volt a lánc eleje, oda mutat az új elem. //A lánc eleje a P lesz, mivel ő az első elem! B. Végre szúrás -Elmegy a lkista végére és beszúrja oda az elemet. (Üres listára is jó) If Eleje = NIL Then //Ha üres a lista, akkor Begin New(Eleje); //Létrehozza Eleje^.Tart:=X; //Tartalmát átadja Eleje^.kov:=NIL; //Mivel ez az egy elem van benn, nincs következő! End ELSE //Ha

nem üres a lista, akkor elmegy a végére BEGIN P:= Eleje; While P^.kov<> NIL then do //Addig megy, míg a végére nem ér P:=P^.kov; New(P^.kov); //Új elem P^.kov^tart:=X; //értéket ad neki P^.kov^KOv:=NIL; //mivel ő az utolsó értéket ad neki. END; 3 Prog III Vizsga, 2005/2006 C. Rendezett beszúrás -Megkeressük azt a helyet, ahová be akarjuk szúrni, és Beláncoljuk (R-et szeretném Q és P közé betenni) If Eleje = NIL Then //Ha üres a lista, akkor Begin New(Eleje); //Létrehozza Eleje^.Tart:=X; //Tartalmát átadja Eleje^.kov:=NIL; //Mivel ez az egy elem van benn, nincs következő! End ELSE IF P^.Tart > X Then //Mi van akkor ha 1 eleme van a listának, és azaz elem Begin //nagyobb, mint a beillesztendő elem, akkor az elé kell tenni. New(Eleje); Eleje^.tart:=X; Eleje^.kov:= P; End Else BEGIN //Ha nem üres, és nem csak egy eleme van, akkor P:= Eleje; While (P<>NIL) And (P^.tart < X) do Begin Q:= P; //Megjegyzi az előző elemet P:= P^.Kov;

//A következőre áll rá End; New(R); //Létrehozza az új elemet (R) R^.tart:= X; //Tartalmat ad neki Q^.kov:= R; //A Q az R elött lesz R^.kov:= P; //R-t a P fogja követni a listában End; END; 3.,Lánc listázása (Memo-ba) VAR P: PElem; Begin P:=eleje; //Rááll az előre While P<>NIL do //Addig megy, amíg a lánc végére nem ér Begin Memo1.linesadd(P^Tart); //kiirja a tartalom részt a memoba P:=P^.Kov; //Rááll a következő elemre * End; End; *P mutasson oda ahová az általa mutatott elem mutatott, azaz a következő elemre. 4., Keresés a láncolt listában P:= Eleje; //A lánc elejére áll While (P<>NIL) and (P^.tart<> KeresettElem) Do Begin P:=P^.Kov; //Rááll a következő elemre End; If P = NIL then ’Nincsen ilyen elem’ Else ’Megvan’; //Ekkor P a keresett elemre mutat 4 Prog III Vizsga, 2005/2006 //Ha a bal oldal nem teljesül az AND kapcsolatnál, akkor a jobbat meg sem vizsgálja. Ha NIL-nél akarna tartalmat vizsgálni, akkor

behalna a progi, mivel a NIL sehova sem mutat! 5., Törlés A., Az első elem törlése P:= Eleje; If P<> NIL then Begin Eleje:=P^.Kov; Dispose (P); End Else ’Üres a lista!’ //Ha nem üres a lista, akkor. //A második elemet jelöli ki elsőnek //Az elsőt törli //Ha üres a lista, akkor szól nekönk! B., Konkrét elem törlése -Keressük a kért elemet -Kiláncoljuk: az előtte lévő elem mutatóját a következő elemre állítjuk, így az adott elem kiesik a láncból. Problémás, mert az előző elem helyét mindig tárolnunk kell! P:= Eleje; While (P<>NIL) and (P^.tart<> KeresettElem) Do //Keressük az elemet Begin Q:=P; //Mielött a következő elemre lépnénk eltároljuk, ő lesz az előző elem. P:=P^.Kov; //A következő elemre lépjük End; If (P <> NIL) then If (P = Eleje) then Begin Eleje:=P^.kov; Dispose(P); End; ELSE Begin Q^.kov:=P^kov; Dispose(P); End; ELSE ’Nincs ilyen elem’; //Lekezeli azt, ha az első elemet akarjuk törölni

//ha nem az első elemet töröljük //Kiláncol //töröl //Nincsen ilyen elem a listában, nincsen mit törölni. //P = NIL Problémák a láncolt listánál:  Lánc elejére kell beszúrni  Láncolt lista üres  Utolsó elem után kell beszúrni Erre találták ki a strázsa technológiát: Az üres lánc is tartalmaz két elemet. Abszolút legkisebb, és az abszolút legnagyobb értéket. Így soha nincsen üres lista, és nem lehet sem a lista elejére, sem a végére adatot tenni, mert végtelennél nincs nagyobb! -Végtelen +Végtelen 5 Prog III Vizsga, 2005/2006 Mutatott elem elé beszúrás -Közvetlenül elem elé nem lehet beszúrni, mert ott már van egy másik elem. Pl.: 8 és 10 közé szeretném beszúrni a 9-et „P” 10-re mutat, mert elé kell betenni a 9-est Létrehozom „R” –t, oda fogom tenni a 10-est, átírom a tartlmét. Majd P-nek új tartalmat adok: 9-et (X). R oda mutasson, ahová eddig P mutatott. Mivel P-ben ezentúl a 9-es lakik,

ő mutasson a 10-esre, vagyis P után jöjjön R; New(R); R^.tart:=P^tart; P^.tart:= X; R^.Kov:=P^kov; P^.kov:=R; Mutatott elem törlése (P-t akarom törölni, Q jön utána: Q-t rámásolom P-re, majd Q-t törlöm) Q:=P.Kov; P^.tart:=Q^tart; P^.kov:= Q^Kov Dispose(Q); //Q a P után jövő elem lesz. //P-re rámásolom Q tartalmát //P mostantól oda mutat, ahová Q mutatott //Q mostantól felesleges, tehát töröljük Teljes lista törlése P:= Eleje; While (P<>NIL) Do Begin Q:=P^.kov; Dispose(P); P:=Q; End; Eleje:=NIL; //A lista elejére állunk //Ha a lista nem üres, akkor nekilátunk törölni. //Eltároljuk a következő elemet //Töröljük azt az elemet, amin állunk //A következő elemre lépünk //Addig töröl, amíg van elem a listában //Ha már üres a lista, akkor ezt azzal jelezzük, //hogy az „Eleje” mutatót NIL-re állítjuk. 4. Bináris fa Fa: összefüggő körmentes gráf, maximum két ága van. Gyökérpont: nem megy bele él. Levélpont: nem

jön ki él. Rendezett bináris fa: a gyökér ponttól balra kisebb elemek, jobbra nagyobb elemek vannak (ez minden pontjára érvényes). 6 Prog III Vizsga, 2005/2006 Miért jó ez?  Azonos típusú elemek tárolására szolgál  Dinamikus adatszerkezet (csak akkor foglal helyet, ha kell)  Kiegyensúlyozott esetben gyors keresését biztosít Hátránya:  Elfajulhat  Memóriában van  Problémás a lemezen való tárolása Teljesen kiegyensúlyozott a bináris fa, ha pontosan két él fut minden pontjából (levélpont kivétel). Elfajult fa a pontjaiból csak egy él fut ki, és az is egy irányba Keresés  A kiegyensúlyozott fán Log 2 N  Elfajult esetben átlagosan: N/2 Az elemek felrakásának sorrendje határozza meg, hogy egy fa elfajul-e vagy sem, meghatározzák a fa szerkezetét. Létrehozása: Type PFa = ^Fa; Fa: = Record Tartalom: String; Bal, Jobb: PFa; End; * Begin Gyökér:= NIL; End; //tartalma //Jobb és bal ágának mutatója

//Nincsen benne egyetlen elem sem Bináris fa bejárása InOrder: a tevékenység a két rekurzió között van, ezért „In” Ha az InOrder eljárást használná, fájlba mentéskor, akkor a visszaolvasáskor egy elfajult fát kapnék vissza. Növekvő sorrendbe írja ki a számokat. Procedure InOrder(P); Begin IF P<>NIL Then Begin InOrder(P^.Bal); Tevékenység(P); InOrder(P^.Jobb); End; End; //Ez a tevékenység, amiért bejárjuk a fát, pl.: kiíratás PreOrder: a tevékenységet a rekurzió előtt hajtja végre Mindig a gyökérelemeket írja ki, ezzel kezdi. Először a teljes fa gyökerét írja ki, majd a részfák gyökereit Ha ezzel az eljárással menteném kia fát egy fájlba, akkor ugyanezt a fát tudnám visszaépíteni! 7 Prog III Vizsga, 2005/2006 Procedure PreOrder(P); Begin If P<> NIL then Begin Tevékenység(P); PreOrder(P^.bal); PreOrder(P^.jobb); End; End; //Tevékenység végrehajtása PostOrder: a tevékenységet a két rekurzió után

hajtja végre Alulról járja be a fát, ezért a fa felszabadítására alkalmas. Procedure PostOrder Begin If P<> NIL Then Begin PostOrder(P^.bal); PostOrder(P^.jobb); Tevékenység(P); End; End; Bináris fa felépítése, avagy hogyan rakjunk rá elemeket. Meg kell keresni a helyét, és fel kell rakni. Ha fent van már az baj! Eljárás ÚjElem(P,X) //P: gyökérmutató, X: új elem Ha P=NIL akkor //ha üres a fa akkor New(P); //új elem létrehozása P^.tart:=X; //tartalmat ad neki P^.bal:=NIL¿ //mivel ő az első elem jobbra és balra nem lesz elem P^.jobb:=NIL; Különben //nem üres a fa, tehát Ha X < P^.tart akkor //ha az új elem kisebb a gyökérpontnál, akkor UjElem(P^.bal, X); //megpróbálja baloldalára felrakni Különben Ha X > P^.tart akkor //ha az új elem nagyobb, akkor ÚjElem(P^.jobb, X); //a jobb oldalára teszi fel Különben //ha az új elem = egy már fent lévővel ’Hiba, mert már fenn van a fán!’ //ekkor hiba van Ev Ev; Ev. Eljárás

vége; Törlés a bináris fáról Attól függ, hogy melyik értéket akarom törölni. Levélpontot könnyű törölni, mert nem kell a hozzá kapcsolódó elemekkel foglalkozni. Olyan elemet is könnyű törölni, amiből csak egy él indul, mert azt egyszerűen kiláncoljuk. De mi van azzal, amelyikből két él fut ki? Ki kell cserélni egy olyan elemre, amely csak minimálisan változtatja meg a fát. A törlendő elem  Baloldali részfájának legjobboldalibb elemével vagy  Jobboldali részfájának legbaloldalibb elemével kell felülírni. Nekik nem lehet két leszármazottjuk, mert különben nem lennének a legjobboldalibbak vagy a legbaloldalibbak! 8 Prog III Vizsga, 2005/2006 1., Keresés Ha X > az elemnél akkor jobbra, ha X < akkor balra kell tovább keresni. Ha X= az elemmel, akkor megvan a törlendő elem. 2., Megnézni, hogy hány leszármazottja van!  Ha csak egy van, akkor kiláncoljuk  Ha mindkét irányban van folytatása, akkor o Baloldali

részfa legjobboldalibb eleme (X) o (Jobboldali részfa legbaloldalibb eleme) o Felülírjuk ezzel az elemmel a törlendőt o Kiláncoljuk a törlő elemet (X) Procedure Tor(VAR R: PCsucsT) Begin If (R^.Jobb<>NIL) then Tor(R^.jobb); Else Begin Q^.tart:= R^Tart; Q:=R; R:=R^.bal; End; End; //Törlendő elem baloldali részfájának legjobboldalibb //eleméhez lemászik: R a törlendő elem bal mutatója //ha van még jobbra elem, akkor //meghívja önmagát és megy tovább jobbra!!! //ha nincs több elem jobbra, akkor //Felülírja Q-t, ezzel törli! //Megjegyezzük, hogy kit kell majd törölni //Kiláncolja Procedure Torol(X:integer; Var:P: PCsucsT); //X-et szeretném törölni, VAR Q : PCsucsT; //Q tárolja a fizikailag törlendő elem címét BEGIN If (P=NIL) then ’Hiba, nincsen ilyen elem’ Else //Ha a fán van a keresett elem, akkor Begin If (X < P^.Tart) Then //ha a keresett elem kisebb, mint az az elem, Torol(X, P^.bal) //mint amin állunk, akkor balra megy tovább

a Else //kererés If (X>P^.Tart) then //Ha a keresett elem nagyobb, mint azaz elem, Torol(X,P^.jobb) //amin állok, akkor jobbra keresek tovább. Else //se nem nagyobb, se nem kisebb, tehát Begin //megvan a keresett elem. Q:=P; //Fizikailag törlendő elem címét eltárolom Q-ban If (Q^.jobb = NIL) then P:=P^bal //ha jobbra NIL van, akkor Else //a Dispose-ra ugrik, töröl! Begin If Q^.bal=NIL then P:=P^jobb; //mivel jobbra nem NIL Else TOR(P^.bal); //van, ezért mehet tovább jobbra! End; //Amikor elérte a legjobboldalt, akkor. Dispose(Q); //Törli a baloldali részfa legjobboldalibb elemét End; End; END; 9 Prog III Vizsga, 2005/2006 5. Bináris fa és a típusos fájl összekapcsolása Összefoglalás Bináris fa: Előnyök:  Dinamikus adatszerkezet, akkor foglal helyet, ha kell  Gyors keresés  Egyszerű törlés, és beszúrás Hátrányok:  Elfajulhat  Memóriában van  Problémás a lemezen való tárolás Típusos fájl Előnyök:  Végtelen sok

kis dobozból áll  A háttértáron foglal helyet  Ha tudjuk az elem sorszámát, akkor gyors a pozicionálás Hátrányok:  A keresés sokáig tart benne  Rendezettnek kell lennie  Új elem beszúrása körülményes 1. Helyének keresése 2. Utána lévő elemek, egyel hátra tolása 3. Betenni az elemet  Törlés is bonyolult  Csak egy szempont szerint lehet rendezni. Megoldás: Indexállomány! Indexállomány egy bináris fával valósítjuk meg. Minden eleme két részből fog állni: Kulcsmező és Rekordsorszám. Mivel a bináris fában gyors a keresés, ezért a kulcsmezőre nagyon gyorsan rá lehet keresni Amikor megtaláltuk a kulcsmezőt tartalmazó elemet, akkor kiolvassuk a Rekordsorszámot is. A rekordsorszám segítségével gyorsan lehet pozícionálni a típusos fájlban, ami az adatainkat tartalmazza. Műveletek: Új elem felvétele 1. Keresés bináris fában 2. Ha van ilyen elem, akkor hiba van, mert már fenn van a fán 3. Ha nincsen fenn a

fán, akkor az adatokat a típusos fájl végére szúrjuk 4. Bináris fára felakasztjuk az új elemet (kulcs, rekordsorszám) Keresés 1. Keresés a bináris fában 2. Ha nincsen, akkor nincs meg a keresett elem (hiba) 3. Ha megvan, akkor kiolvassuk a rekordsorszámot 4. A rekordsorszám alapján megkeressük a típusos fájlban az adatainkat: Seek(f,Rekordsorszam) 5. Kiolvassuk az adatokat Read(f,Adatok) Törlés 1. Keresünk a bináris fában, ha nincs meg a keresett elem, akkor hiba van! 2. Ha megtaláltuk, akkor  Fizikai törléskor: 3. Utolsó elemet rámásoljuk a törlendőre a típusos fájlban 4. Az utolsó elemet levágjuk (Truncate(f)); 5. Az átmásolt elemnek módosítjuk a rekordsorszámát a binfában 6. Bin-fából töröljük a törlendő elem bejegyzéseit 10 Prog III Vizsga, 2005/2006  Logikai törlés Visszavonható (adatvisszanyerés) Ekkor nem töröljük ki fizikailag, hanem csak törölté nyilvánítjuk, és ezzel jelezzük, hogy ha szüksége van

a rendszernek arra az adott helyre, felhasználhatja. Ha a rendszer nem használta még fel azt a helyett, akkor az adatok visszanyerhetők. Rendezett listák előállítása szűrőfeltételekkel (Indexelés, hogy gyorsabb legyen a keresés név szerint, telephelyenként, stb.) Bináris fát kell építeni, ahol a név lesz a kulcsmező! InOrder bejárással Tevékenység(P) -> helyére a következő parancsokat kell írni. Seek(f, P^.RecSorszam) //Az adott Rekordra rááll Read(f, Adatok) //Kiolvassa onnan az adatokat Bináris fa csomópontja így fog kinézni: Név RecSorszám Telephely A névre fogunk rákeresni (X), amikor megtaláltuk ezt a csomópontot, akkor kiolvassuk a Rekord sorszámot, annak segítségével rápozícionálunk a típusfájlban a rekordunkra, és kiolvassuk az adatot. A Telephely arra szolgál, hogy további szűrőfeltételt állítsunk fel. Pl.: Listázzuk ki a Kis Bélákat -Erre elég sok eredményt dobna ki -Ha a telephelynél beállítjuk a

szűrőfeltételt, hogy csak a kistarcsai Kis Bélákat listázza, máris sokkal kevesebb eredményt fogunk kapni. Indexállományok a lemezen: Külön állományokban (fájlokban) tárolódik a lemezen. Ha nem fér el a memóriában, akkor csak részfákat töltünk be, mindig felülről lefelé haladva. A főfa megmutatja, hogy melyik al-fát töltsük be! -Gondot jelent az elfajulás, mert néhány fa üres, néhány meg nagyon sok elemet tartalmazhat. -A törlés elég macerás, de nem megoldhatatlan. 6. B - fa A keresések további gyorsítására szolgál. A bináris fa, ha nincsen elfajulva log2N-es gyorsaságú keresést, biztosít. Hogyan lehetne ezt gyorsítani? N 1 millió 1000 millió log 2 N 20 30 log 4 N 10 Log 1000 N 2 3 Mi lenne ha egy fának nem két ága lenn, mint a binárisnak, hanem 1024 ágú volna. Az SQL szerverek indexállománya 2-3 lépésből képes megtalálni a keresett elemet, mert B-fát használ.  Bayer – fa  Rend N: 1 csomópontban maximum

2*N elem lehet  Kihasználtsága minimum 50%-osnak kell lennie, tehát  A gyökérpontot kivéve, 1 csomópontban minimum N, maximum 2N elemnek kell lennie. 11 Prog III Vizsga, 2005/2006 Felépítése: Kulcsokból (K) és mutatókból (P = pointer) áll. A kulcsok azok, amiket keresünk, a mutatók mutatják a fa további ágait. P0 K1 P1 K2 P2 K3 P3 K4 P4 A kulcsok egymás mellett állnak, növekvő sorrendben. A közöttük elhelyezkedő mutató arra a csomópontra mutat, ahol azok a kulcsok helyezkednek el, amelyeknek az értéke az előző két kulcs értéke között helyezkedik el. Példa: N=2, 10 2 4 X<10 6 8 21 12 30 13 40 18 20 24 10<X<21 26 27 29 21<X<30 B – fa beszúró algoritmus Csak a gyökér elembe estében lehet N-nél kevesebb kulcsot betenni, minden más elembe minimum N-et, maximum 2N-et. Példa: helyezzük el a B-fán: 2, 7, 21, 8, 2-t! 1. lépés Növekvő sorrendbe felvisszük az első hármat. A 8 nem, mert

az kisebb, mint a 21. 2. lépés Átrendezzük a fát, és beszúrjuk a 8-ast Hiba, mert a 2-es egyedül van, holott ott minimum két elemnek kéne lennie!!! Megoldás Szükség van egy segédváltozóra, amibe 2N+1 elem fér el. (Ha N=2, akkor 5 elem férjen bele benne)    Kiválasztjuk a középső elemet Felküldi eggyel magasabb szintre A maradék 2N darab elemet két lapra osztja (laponként N darab lesz). A 7-es gyökérben van, ő lehet egyedül! 2, 4 és a 8, 21 két lapra került!    Új gyökérelem jött létre (ott lehet egy elem is), és a fa szintjeinek száma eggyel nőtt! Mindig alulról felfelé nő a B- fa! Ha jönnének még új elemek pl.: 6-os, 3-as, 5-öst! A 6-os menne a 4-es mellé Amikor jönne a hármas, az felvinné a négyest, és megosztaná a maradékot! 12 Prog III Vizsga, 2005/2006   A B - fa levélpontjai mindig azonos szinten vannak! Megjegyzés.: a lemezen tároljuk a lapokat, és csak annyit olvasunk be, amennyi

szükséges. Mi legyen a szempont a B-fa rendjénél? (Mekkora legyen N?) Szektor méretéhez igazodjon, azaz akkora legyen, hogy azt egyszerre be tudja olvasni a gép. 7. Sor és verem adatszerkezet és műveletei Absztrakt adatszerkezet= mi korlátozzuk le, hogy megbízhatóbb programokat tudjunk írni. I.Verem: -legelőször betett elemet tudjuk legutoljára kivenni: first in last out (FILO) És :last in first out (LIFO) milyen területeken használható? Eljárás: „elem”-verem használata: pl. eljárások és függvények visszatérési címének tárolására szolgál eljáráshíváskor beletessük azt a me memóriacímet, ahol majd az eljárás end végrehajtása után folytatni kell a programot Ha már nem hívunk meg új eljárást=>eljárás end-jénél a verem tetejéről leveszi, hogy hol kell folytatni a vezérlést. Procedure elso; Var I:integer; Begin; I:=100; I:=I+1; End; kapu adatverem I I Procedure masodik; Var I,J:integer; Begin I:10; J:20; I Elso;

End; //végrehajtódik az eljárás, ilyenkor kipakolja a veremből az adatokat// Rekurzív algor. kezelése esetén erre a logikára kell gondolni! Ezeket át lehet írni nem rekurzív algoritmusokká, de vermet nekem kell kezelni. PL.: bináris fa bejárás nem rekurzívan: 13 Prog III Vizsga, 2005/2006 Megvalósítás: Tömbbel N . . . 1 VM Fel.-ok: inicializálás, berakás, kivétel VM veremmutató a következő szabad helyre mutat 1. mire kell állítani:Unit VM:=1; //elején az elsőre mutat// end; 2. verembe (X) If VM>0 Then hiba //nincs már hova rakni// Else (VM):=X VM:=VM+1 3.kivenni veremből (X) If VM=1 Then hiba //üres a verem// Else VM:=VM-1; X:=V(VM) Dinamikus adatszerkezettel hogyan lehet vermet megvalósítani: 1.Indít Eleje:=NIL; vége Új elemet mindig a lánc elejére Tegyük, az elejére beszúrás művelettel 2.Verembe (X) . . . . vége; 3.Veremből (X) Vegyük ki az első elemet,(kimeneti+lánc elejéről való törlés) (ha a 3. elemet akarjuk

kivenni, akkor az 1és2-at is ki kellene venni),de egyébként ilyen feladatokhoz nem használunk vermet! II.Sor: First in first out Last in last out 14 Prog III Vizsga, 2005/2006 Puffer, Buffer átmeneti tároló egység PL-nyomtatás -billenytyűzet -bevásárlásnál sorbanállás -ütemezési feladatoknál megvalósítás: tömb 1 2 3 . N pointerek A, nem hatékony megoldás: 1. Unit Honva:=1; Honnan:=1; Vége; 2. Sorba (X): //ha hova<=N;akkor beteheti// S(hova):=x; Hova:=hova+1; Különben hiba 3. Sorból(X): Ha nem üres a sor+hova<>honnan, akkor X:=S(honnan);ű Honnan:=honnan+1; Különben hiba B, Hatékonyabb megoldás: Végén meg szeretném nézni, hogy hátha az elejéről már kipakolták az elemeket, mert akkor ott lehetne folytatni. 1. Unit Hova:=1; Honnan:=1; DB:=0; Éppen mennyi elem van a sorban 2. Sorba(X): If DB<N then S(hova):=X; DB:= DB+1; Ha hova=N then Hova:=1; Els hova:=hova+1; vége 3. Sorból(X): Ha DB=0 then 15 Prog III Vizsga,

2005/2006 Hiba Else X:=S(honnan); DB:=DB-1; Ha honnan=N then Honnan:=1; Különben Honnan:=honnan+1; Hogyan lehet láncolt listával megvalósítani a sort? 1. Unit eleje:=NIL ; end; 2. sorba(X): sor elejére(X) end; sorból(X); kivenni a sor végéről(X); end; !!! 2 irányú láncolt lista: Eleje utolsó Van egy eleje és egy vége mutató, így a sor- adatszerkezet könnyen megvalósítható, mert nemm krll rajta végigmenni. 8. Objektum Orientált Programozás (OOP) OOP: osztályok létrehozását, vagy meglévő osztályok használatát jelenti. Önálló osztály létrehozása előtt nézzük meg, hogy nincsen-e valami hasonló, mert azt érdemesebb bővíteni, mint teljesen újat alkotni. Célja hogy megbízhatóbb programokat írjunk, és a korábban elkészített kódokat újra felhasználhatjuk. Objektum: Változó Osztály: Típus Strukturált programozás előzte meg: eljárásokat, függvényeket írtak, és azokat pontos szerkezetek szerint használták. Objektum

modell (referencia modell): -A változó létrehozása azonnal lefoglalja a szükséges területet, elég helypazarló (statikus). -A Delphi esetében van egy statikus mutató, amely az adott objektumra fog mutatni, ami már dinamikus. Dinamikusan kezeljük: van egy Mutató, ez mutat az OBJKTUMRA ezért inicializáni kell használat előtt (létrehozni) . Létrehozás: VAR Obj: TMyClass; Begin Obj:= TMyClass.Create; End; A „Create” a konstruktora az osztálynak (létrehozó metódus). Figyelni kell arra, hogy az osztálynak hívjuk meg a konstruktorát, ne az Objektumnak, mert „Obj” még nem létezik. 16 Prog III Vizsga, 2005/2006 Felszabadítás: Obj.Free; Obj:=NIL; //felszabadítja az objektumot //a mutató nem fog mutatni sehova. Létre van-e már hozva az Objektumunk? IF Assigned(Obj) Then ’Van értéke’ Else ’Nincsen értéke’; Öröklődés Osztályokat hozunk létre, amik lehetnek ősosztályok. Az ősosztályok nem származnak semmiből Azt tudják, amit

mi megtanítunk nekik, nem többet. Sok osztályt a Delphi készítői előre elkészítettek, ennek köszönhető, hogy az ablakot nem kell minden program elején újra elkészítenünk, és nem kell mindig a gombok megalkotásával foglalkoznunk, egyszerűen csak a komponens palettáról levesszük. Megtehetjük, hogy egy olyan osztályt hozunk létre, ami egy másikból öröklődik, vagyis mindent tud, amit az ő őse tudott. Pl: Type TMyClass = Class(TForm); Ekkor a TMyClass nevű osztály azonos tulajdonságokkal, és képességekkel (azonos adatterülettel, és metódusokkal) fog rendelkezni, mint a TForm. Munkánk során ezeket a tulajdonságokat újabbakkal bővíthetjük, és így nem kell mindig a kályhától indulni. Tehát az ős metódusait képesek vagyunk  Bővíteni  Átdefiniálni (módosítani)  Újradefiniálni (ugyanazon a néven mást fog tenni, mint az őse) Minden származtatott osztálynak csak egyetlen egy közvetlen őse lehet!!! Komponensek

dinamikus létrehozása Procedure TForm1.FormMouseDown(Sender: TObject); VAR Btn : TButton; Begin Btn:=TButton.Create(Self); //létrehozza Btn.Parent:=Self; //Megadja, hogy ki volt az akiből ő származik Btn.Left:=X; Btn.Top:=Y; Btn.Caption:=’Kilépés’; Btn.Show; //Megjeleníti a gombot End; A Self mindig azt mutatja, hogy éppen melyik objektum hozta létre. (Itt a Form1) Vannak alapértelmezett értékei is, amikor létrehozzuk a gombot. A gomb szélességét nem adtuk meg (width), mégis lesz szélessége, színe, stb. Egységbe zárás (encapsulation) Metódusok és az adatterületek szerves egységet alkotnak, és elzárjuk a külvilág elől, ezek az objektumok.  Egy helyen deklaráljuk őket  A tagfüggvények a saját adatterületüket látják.  Általában csak saját metódus állíthatja az adatterületet. Láthatósági szabályok: PRIVAT Az osztályt tartalmazó egységen (Unit) kívül nem érhető el. PROTECTED Adott osztályban, annak

leszármazottjában érhető el, PUBLIC 17 Prog III Vizsga, 2005/2006 Bárhonnan elérhető. Ha nincsen semmilyen jelzés, akkor a Delphi alapból mindenkit PUBLIC-ként kezel, mindenki láthat mindenkit. Egy azon unit-on belül mindenki PUBLIC! Egy Unit-ba csak egy osztály kerüljön! Javaslat: A PRIVATE rész adatterület legyen, ott legyenek a változók! A PUBLIC-ban legyenek a metódusok, ezeket mindenki használhassa. Polimorfizmus (sokalapúság) Objektum hierarchiában az osztályok különböző szintjein ugyanaz a nevű eljárás mást csinálhat. A metódusok neve azonos. -Lehetővé teszi, hogy különböző típusú változókat kezeljenek. -A leszármaztatott osztályok típus kompatibilisek az ősosztállyal. 9. Hibakezelési technikák, kivételkezelés Hibakezelési technikák 1. Próbáljuk a hibát megelőzni: S:=A/B {Csak pozitív} IF B=0 then {IF B<0.000000001} Begin Hibaüzenet End Else Begin S:=A/B End; 2. Váltsuk le a hibát, aztán kezeljük le: Try

S:=A/B; (Védett blokk) Except OnEditbyZero Do Begin //ha 0-val való osztás történt, akkor ide kerül a vezérlés// //Kivétel-v. hibakezelő blokk, ide kerül a vezérlés, ha hiba van a védett blokkban; ha nincs hiba, akkor end után folytatódik a program// End; End; Raise Ennek a parancsnak akkor van értelme, ha a hibakezelő blokkot egymásra lehet ágyazni. Screen.cursor:=HourGlass; //átkapcsoljuk homokórára a kurzort// Try Try „Hosszú algoritmus” Finally Screen.cursor:=crdefault; End; //amit ide írunk az mindenképpen fusson le,ha volt hiba, ha nem, állítsd vissza a kurzort// Except 18 Prog III Vizsga, 2005/2006 OnEditbyZero Do Begin; End; End; Irsz: -Ip -Varos (-Nepesseg) -Megyekod megyek: - Megyekod -Megyenev 1. Új tábla XY-ugyfelek -ugyfelszam -veznev -kernev -cím.azon->iranyitoszamokid 2. Az ügyfelek száma megyénként Select valami, valami2 Where barmi and barmi 3. A megyék népessége 19