hu hu hu hu hu hu hu hu hu hu hu hu hu hu hu hu hu hu hu hu hu hu hu hu hu hu hu hu hu hu hu hu hu hu hu hu hu hu en hu hu hu hu en hu hu hu nb hu hu nb hu nb hu hu nb hu hu hu en la hu hu hu hu hu hu hu hu hu hu hu sk hu hu hu hu hu hu hu hu hu hu hu hu hu hu hu hu hu hu hu hu hu hu de hu hu hu hu hu hu hu hu hu hu hu hu hu hu hu hu hu hu hu hu hu hu hu en ar bg bn hbs_lat de es et fa fi fr he hi hbs_lat id is it ja ta ko nl nb pl pt ru en sl hbs_lat sv ta th tr fy zh zh hu hu hu hu hu hu hu hu hu hu
A Wikipédiából, a szabad enciklopédiából
Ez a közzétett változat, ellenőrizve: 2020. december 19.
Ugrás a navigációhoz Ugrás a kereséshez
Ez a szócikk nem tünteti fel a független forrásokat, amelyeket felhasználtak a készítése során. Emiatt nem tudjuk közvetlenül ellenőrizni, hogy a szócikkben szereplő állítások helytállóak-e. Segíts megbízható forrásokat találni az állításokhoz! Lásd még: A Wikipédia nem az első közlés helye.
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 hívjuk. A hagyományos, szekvenciális és strukturált programozási kereteken túlmutató hibakezelésre, valamint magasabb szintű hibadetekcióra, esetleg korrigálásra használható.
1 A hibakezelés módszerei, a kivételkezelés célja
A programok alapvetően szekvenciális – így a folyamatában jól nyomon követhető – működésében sok esetben következhetnek be olyan események, amelyekre a programozó nem készül, vagy nem készülhet fel (esetleg nem is akar felkészülni).
Az ilyen hibajelenségek az alapvető utasításkészlettel régen nem voltak kezelhetőek (elkaphatóak). A normál hibakezelés általában körülményes, sok változó beiktatását és figyelését, valamint rengeteg feltételes utasítást igényel. Ezen túl nem is alkalmas arra, hogy például az operációs rendszer, vagy a processzor által küldött különféle jelzéseket, figyelmeztetőket elfogja. Így a programozónak kellett sok olyan sorral megtűzdelnie a kódjait, amelyek nem csak a helyet foglalták, de ormótlanná tették és le is lassították a program futását. Ha nem tette volna meg ezt, akkor hiba esetén az alkalmazása váratlan helyen megszakította volna a futását, és ezáltal a program használata adatvesztéssel járt volna.
A hagyományos hibakezelés esetén az utasítások végrehajtása jól követhető nyomvonalakon halad végig, jó esetben ugrások (például GOTO) nélkül. Azonban ha az adott problémát nem kezeljük le, akkor a program defektje kárt okozhat a rendszerben. (Például az alkalmazás leáll, vagy rossz esetben adatsérülés lesz az eredmény.)
A megszakítás-elvű kivételkezeléses rendszerben a hibákat könnyebb elfogni, valamint a nyelvek általában egy beépített eljárással kezelik a hibákat, ha mi nem tettük volna meg. Ezért a kivételek használata és az ezekkel való munka mindenképpen egy magasabb szintű, felügyelt hibakezelést tesz lehetővé.
A központosított hibakezelés igénye már régóta megmutatkozott a programozásban. Nem véletlen, hogy már a Primo, HT-1080Z és hasonló kategóriájú számítógépek is támogatták ezt, az ON ERROR GOTO utasítással, amely hiba esetén a megfelelő kezelőrutinra adta a vezérlést.
Később, az Enterprise számítógépekben már valódi kivételkezeléssel találkozhattunk. A PC-s világban már a DOS-os időszakban feltűntek az kivételkezelést alkalmazó nyelvek, mint a Pascal, a C stb.
Később ez a tendencia átterjedt a szkript-szerű nyelvekre is. Ez azonban ellentmondásos, mivel pont az interpretált kódoknál könnyebb a magas szintű hibakezelés megvalósítása. Így manapság szinte mindegyik komolyabb programozási nyelv alkalmazza a kivételeket bizonyos formában.
Az operációs rendszer által kezelt szoftveres megszakítások felhasználása révén a különféle programnyelvek lehetőséget nyújtanak olyan blokkok beiktatására, amelyek a hibaesemények bekövetkeztekor reagálni tudnak.
A hibaeseményt (például rossz helyről olvasunk a memóriában) a processzor (illetve az operációs rendszer) érzékeli, majd szoftveres megszakítással él. A megszakításkezelő a megfelelő alkalmazás hibakezelőjére adja a vezérlést. Ez az eljárás a veremben, vagy más adatközegben felkutatja a legközelebbi hibakezelő blokkot, és oda ugrik. Ha nincs ilyen, akkor az alapértelmezett hibakezelőt használja.
Általában két fő típusuk ismeretes:
Operációs rendszerszintű kivételek: például memória elfogyása, rendszererőforrás-problémák, fájlhibák, nullával való osztás.
Nyelvi szintű kivételek: általános kivételek, jelzések, eseményjelzők, kódblokk-megszakítások, erőforrás-felszabadító szakaszok.
Az objektumorientált programnyelvek általában objektumokba burkolják a kivételek, így lehetőséget biztosítanak arra, hogy azokat leszármaztassuk, és saját elemekkel bővítsük, így olyan plusz információk hordozására bírva őket, amelyekkel a szülő elemek nem rendelkeztek.
Nézzünk egy konkrét példát: egész értékké szeretnénk alakítani egy karakterláncot. A hagyományos megoldás esetén két visszatérési értéket kell szolgáltatnunk: magát az eredményt, illetve egy változót, amellyel jelezzük, ha nem tudtuk végrehajtani a műveletet (utóbbival esetleg információt adunk arról is, hogy miért nem sikerült maga az átalakítás).
AzEgesz, AzEredmeny = Szoveget_Egessze(ASzoveg) Ha Sikeres … Ha Nem Sikeres, miért is ? …
… an_int, an_rescode = str_to_int(a_string) if an_rescode == 1: print "Non numeric value" elif an_rescode == 2: print "Numeric value overflow" elif an_rescode == 0: print "The value is: ", an_int …
A kivételkezeléses módszernél két blokkot definiálunk. Az elsőben magát az egésszé alakító utasítást helyezzük el, a másodikban pedig a hiba előfordulásakor lefutó kódsort.
AzEgesz, AzEredmeny = Szoveget_Egessze(ASzoveg) # Sikeres, folytatjuk a többi kóddal … # Nem volt sikeres, hiba történt, itt kezelhetjük …
… try: an_int=str_to_int(a_string) print "The value is: ", an_int except: print "Value converting error" …
A nyelvi megjelenésük roppant egyszerű. Általában 3 szakaszban definiálhatóak, és mindháromnak meghatározott szerepe van, melyek közül kettőt kell párosítva használni: az elsőt, illetve a második és harmadik elem közül az elérni kívánt hatás szerint választottat.
1.) A védett (próbára tett) kódszakasz:
Ebbe a szakaszba helyezzük el azokat az utasításokat, amelyekben hibát "várunk". Tulajdonképpen kipróbáljuk, hogy történik-e hiba. Ha nem, akkor a blokkban szereplő utasítások lefutnak, majd a következő utasításhalmazhoz kerülünk.
2.) A hibakezelő szakasz:
Ezen blokkokba kerül a végrehajtás, ha valamilyen hiba fordult elő. Általában a programnyelvek támogatják a kivételtípusok szerinti szelekciót, vagy a kivételekből információk kinyerését. E kódszakaszba tehetünk minden kezelőt vagy reagáló elemet, amit a hiba kiküszöbölése vagy észlelése miatt be akarunk vetni.
3.) A lezáró (erőforrás-kezelő) szakasz:
E kódblokk tartalmaz minden olyan kritikus utasítást, aminek mindenképpen le kell futni – vagyis még kivétel bekövetkezte esetén is. Ide helyezendő minden erőforrás-kezelő rutin – általában az összes felszabadító és elengedő szekvenciát ide érdemes halmozni, ami kapcsolatban lehet a védendő kódszakasszal.
A kompilált kódok esetében egy speciális kezelőt regisztrálunk az operációs rendszer számára. E kód a veremben, vagy egyéb területen elhelyezett jelzők alapján fogja tudni kideríteni, hogy hol kell folytatódnia a kódnak kivétel történte esetén. Interpretált nyelveknél ezeket a funkciókat az értelmező és futtató modul végzi.
A manapság használt nyelveknél általában kétféle kivételkezelő utasításblokkot találhatunk, amelyek szinonimák:
try {blokk} (on) except(ion) {hibakezelő blokk}
try {blokk} catch {hibakezelő blokk}
A fenti elemeket a megfelelő erőforrás-kezelés számára kiegészítették egy újjal – hiszen a program futása a kivételekre "várakozás" miatt nem várt irányba is folytatódhat, aminek okán az előzőleg lefoglalt erőforrások nem kerülnek felszabadításra – memóriaszivárgást, memóriahiányt okozva.
Ezért egy olyan blokkot is definiálhatunk, amelynek célja a minden esetben – tehát kivétel bekövetkezte esetén is – történő lefutás.
Ezt általában "finally" utasítással teszik. Ennek használata:
try {blokk} except {hibakezelő blokk} finally {mindenképpen lefutó blokk}
Példa a hibás erőforráskezelésre:
try: afile=open_new_file("data.fil","w") afile.write(data) afile.close() except: print "Nem sikerült az adat mentése" # nincs lezárva a fájl és felszabadítva a hozzá tartozó memóriapuffer
try: afile=None afile=open_new_file("data.fil","w") afile.write(data) except: print "Nem sikerült az adat mentése" finally: if afile None: afile.close()
Több nyelvnél a "finally" taghoz tartozó kódblokk általában előbb fut le, mint az "except" szakasz.
Informatikai portál • összefoglaló, színes tartalomajánló lap
A lap eredeti címe: „https://hu.wikipedia.org/w/index.php?title=Kivételkezelés&oldid=23366645”
Forrással nem rendelkező lapok
Hivatkozás erre a változatra
Hogyan hivatkozz erre a lapra?
A lap utolsó módosítása: 2020. december 19., 18:37
A lap szövege Creative Commons Nevezd meg! – Így add tovább! 3.0 licenc alatt van; egyes esetekben más módon is felhasználható. Részletekért lásd a felhasználási feltételeket.