Kivételkezelés

A Wikipédiából, a szabad lexikonból.

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 struktúrált programozási kereteken túlmutató hibakezelésre, valamint magasabb szintű hibadetekcióra, esetleg korrigálásra használható.

Tartalomjegyzék 1 A hibakezelés módszerei, a kivételkezelés célja 2 Története 3 Működése 3.1 Elterjedt típusok 3.2 Példa a kivételkezelésre 4 Gyakorlati használat

[szerkesztés] 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 mint GOTO) nélkül. Azonban ha az adott problémát nem kezeljük le, akkor a program defektje kárt okozhat a rendszerben. (Pl. 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é.

[szerkesztés] Története

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ó kaliberű 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 script-szerű nyelvekre is. Ez furcsa, mivel pont az interpretált kódoknál könnyebb a magasszintű hibakezelés megvalósítása. Így manapság szinte mindegyik komolyabb programozási nyelv alkalmazza a kivételeket ilyen-olyan formában.

[szerkesztés] Működése

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, amik a hibaesemények bekövetkeztekor reagálni tudnak.

A hibaeseményt (pl. 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.

[szerkesztés] Elterjedt típusok

Általában két fő típusuk ismeretes:

• Operációs rendszerszintű kivételek: pl. memória elfogyása, rendszererőforrás problémák, fájlhibák, 0-val osztás stb.
• 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 őket, olyan plusz információk hordozására bírva ezeket, amelyekkel a szülő elemek nem rendelkeztek.

[szerkesztés] Példa a kivételkezelésre

Nézzük konkrétan egy példát: egész értékké szeretnénk alakítani egy szövegfüzért. 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űvelet (ezzel esetleg információt adunk arról is, hogy miért nem sikerült maga a konverzió).

Pszeudo-kód:

 AzEgesz, AzEredmeny = Szoveget_Egessze(ASzoveg)
 Ha Sikeres ...
 Ha Nem Sikeres, miért is ? ...

Python-stílusú kód:

 ...
 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.

Pszeudo-kód: Vizsgalandó blokk:

   AzEgesz, AzEredmeny = Szoveget_Egessze(ASzoveg)
   # Sikeres, folytatjuk a többi kóddal
   ...

Hibakezelő blokk:

   # Nem volt sikeres, hiba törtért, itt kezelhetjük
   ...

Python-stílusú kód:

 ...
 try:
   an_int=str_to_int(a_string)
   print "The value is:", an_int
 except:
   print "Value converting error"
 ...

[szerkesztés] Gyakorlati használat

A nyelvi megjelenésük roppant egyszerű. Általában 3 szakaszban definiálhatóak és mindháromnak meghatározott szerepe van. E szakaszokból az kettőt párosítva kell használni: az elsőt, és második vagy harmadik elem közül opcionálisan választhatunk, az elérni kívánt hatás szerint.

1.) A védett (próbára tett) kódszakasz:

try:
  {blokk}

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:

except:
  {blokk}

vagy

catch:
  {blokk}

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áskezelő) szakasz:

finally:
  {blokk}

E kódblokk tartalmaz minden olyan kritikus utasítást, aminek mindenképpen le kell futni - még kivétel bekövetkezte esetén is ! Vagyis ide teendő minden erőforráskezelő rutin - általában az összes felszabadító, 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áskezelé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óriafolyást, memóriahiányt okozva.

Ezért egy olyan blokkot is definiálhatunk, amelynek célja a mindenkoron - akár 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

Helyesen:

 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.